From 8784cbfebcb8a0220fb947a6070032e20b80fc2f Mon Sep 17 00:00:00 2001 From: untodesu Date: Thu, 11 Sep 2025 14:13:39 +0500 Subject: Another qfengine graft: resource management DECOPYPASTA DECOPYPASTA DECOPYPASTA DECOPYPASTA --- core/pch.hh | 1 + core/resource/CMakeLists.txt | 1 + core/resource/binfile.cc | 68 ++++++++--------------- core/resource/binfile.hh | 2 + core/resource/image.cc | 96 +++++++++++--------------------- core/resource/image.hh | 2 + core/resource/resource.cc | 129 +++++++++++++++++++++++++++++++++++++++++++ core/resource/resource.hh | 43 ++++++++++++++- core/utils/CMakeLists.txt | 2 + core/utils/physfs.cc | 76 +++++++++++++++++++++++++ core/utils/physfs.hh | 18 ++++++ 11 files changed, 327 insertions(+), 111 deletions(-) create mode 100644 core/resource/resource.cc create mode 100644 core/utils/physfs.cc create mode 100644 core/utils/physfs.hh (limited to 'core') diff --git a/core/pch.hh b/core/pch.hh index 3a013bd..dedd310 100644 --- a/core/pch.hh +++ b/core/pch.hh @@ -21,6 +21,7 @@ #include #include #include +#include #include #include #include diff --git a/core/resource/CMakeLists.txt b/core/resource/CMakeLists.txt index ef2ffae..7df4306 100644 --- a/core/resource/CMakeLists.txt +++ b/core/resource/CMakeLists.txt @@ -3,4 +3,5 @@ target_sources(core PRIVATE "${CMAKE_CURRENT_LIST_DIR}/binfile.hh" "${CMAKE_CURRENT_LIST_DIR}/image.cc" "${CMAKE_CURRENT_LIST_DIR}/image.hh" + "${CMAKE_CURRENT_LIST_DIR}/resource.cc" "${CMAKE_CURRENT_LIST_DIR}/resource.hh") diff --git a/core/resource/binfile.cc b/core/resource/binfile.cc index 726ef9b..0e6efa8 100644 --- a/core/resource/binfile.cc +++ b/core/resource/binfile.cc @@ -4,68 +4,48 @@ #include "core/resource/resource.hh" -static emhash8::HashMap> resource_map; +#include "core/utils/physfs.hh" -template<> -resource_ptr resource::load(std::string_view name, unsigned int flags) +static const void* binfile_load_func(const char* name, std::uint32_t flags) { - auto it = resource_map.find(std::string(name)); + assert(name); - if(it != resource_map.cend()) { - // Return an existing resource - return it->second; + auto file = PHYSFS_openRead(name); + + if(file == nullptr) { + spdlog::error("binfile: {}: {}", name, utils::physfs_error()); + return nullptr; } - auto file = PHYSFS_openRead(std::string(name).c_str()); + PHYSFS_sint64 file_size = PHYSFS_fileLength(file); - if(file == nullptr) { - spdlog::warn("resource: {}: {}", name, PHYSFS_getErrorByCode(PHYSFS_getLastErrorCode())); + if(file_size < 0) { + spdlog::error("binfile: {}: {}", name, utils::physfs_error()); + PHYSFS_close(file); return nullptr; } - auto new_resource = std::make_shared(); - new_resource->size = PHYSFS_fileLength(file); - new_resource->buffer = new std::byte[new_resource->size]; + auto binfile = new BinFile(); + binfile->size = static_cast(file_size); + binfile->buffer = new std::byte[binfile->size]; - PHYSFS_readBytes(file, new_resource->buffer, new_resource->size); + PHYSFS_readBytes(file, binfile->buffer, file_size); PHYSFS_close(file); - return resource_map.insert_or_assign(std::string(name), new_resource).first->second; + return binfile; } -template<> -void resource::hard_cleanup(void) +static void binfile_free_func(const void* resource) { - for(const auto& it : resource_map) { - if(it.second.use_count() > 1L) { - spdlog::warn("resource: zombie resource [BinFile] {} [use_count={}]", it.first, it.second.use_count()); - } - else { - spdlog::debug("resource: releasing [BinFile] {}", it.first); - } + assert(resource); - delete[] it.second->buffer; - } + auto binfile = reinterpret_cast(resource); + delete[] binfile->buffer; - resource_map.clear(); + delete binfile; } -template<> -void resource::soft_cleanup(void) +void BinFile::register_resource(void) { - auto iter = resource_map.cbegin(); - - while(iter != resource_map.cend()) { - if(iter->second.use_count() == 1L) { - spdlog::debug("resource: releasing [BinFile] {}", iter->first); - - delete[] iter->second->buffer; - - iter = resource_map.erase(iter); - - continue; - } - - iter = std::next(iter); - } + resource::register_loader(&binfile_load_func, &binfile_free_func); } diff --git a/core/resource/binfile.hh b/core/resource/binfile.hh index 6bb5e3d..5f24d77 100644 --- a/core/resource/binfile.hh +++ b/core/resource/binfile.hh @@ -3,6 +3,8 @@ #pragma once struct BinFile final { + static void register_resource(void); + std::byte* buffer; std::size_t size; }; diff --git a/core/resource/image.cc b/core/resource/image.cc index 8b570e4..d5e256d 100644 --- a/core/resource/image.cc +++ b/core/resource/image.cc @@ -4,7 +4,7 @@ #include "core/resource/resource.hh" -static emhash8::HashMap> resource_map; +#include "core/utils/physfs.hh" static int stbi_physfs_read(void* context, char* data, int size) { @@ -22,94 +22,60 @@ static int stbi_physfs_eof(void* context) return PHYSFS_eof(reinterpret_cast(context)); } -template<> -resource_ptr resource::load(std::string_view name, unsigned int flags) +static const void* image_load_func(const char* name, std::uint32_t flags) { - auto it = resource_map.find(std::string(name)); + assert(name); - if(it != resource_map.cend()) { - // Return an existing resource - return it->second; - } + stbi_io_callbacks callbacks; + callbacks.read = &stbi_physfs_read; + callbacks.skip = &stbi_physfs_skip; + callbacks.eof = &stbi_physfs_eof; + + stbi_set_flip_vertically_on_load(bool(flags & IMAGE_LOAD_FLIP)); - auto file = PHYSFS_openRead(std::string(name).c_str()); + auto file = PHYSFS_openRead(name); if(file == nullptr) { - spdlog::warn("resource: {}: {}", name, PHYSFS_getErrorByCode(PHYSFS_getLastErrorCode())); + spdlog::error("image: {}: {}", name, utils::physfs_error()); return nullptr; } - if(flags & IMAGE_LOAD_FLIP) { - stbi_set_flip_vertically_on_load(true); - } - else { - stbi_set_flip_vertically_on_load(false); - } - - stbi_io_callbacks callbacks; - callbacks.read = &stbi_physfs_read; - callbacks.skip = &stbi_physfs_skip; - callbacks.eof = &stbi_physfs_eof; - - auto new_resource = std::make_shared(); + int desired_channels; if(flags & IMAGE_LOAD_GRAY) { - new_resource->pixels = stbi_load_from_callbacks(&callbacks, file, &new_resource->size.x, &new_resource->size.y, nullptr, STBI_grey); + desired_channels = STBI_grey; } else { - new_resource->pixels = stbi_load_from_callbacks( - &callbacks, file, &new_resource->size.x, &new_resource->size.y, nullptr, STBI_rgb_alpha); + desired_channels = STBI_rgb_alpha; } - PHYSFS_close(file); + int width, height, channels; + auto pixels = stbi_load_from_callbacks(&callbacks, file, &width, &height, &channels, desired_channels); - if(new_resource->pixels == nullptr) { - spdlog::warn("resource: {}: {}", name, stbi_failure_reason()); - return nullptr; - } + PHYSFS_close(file); - if(new_resource->size.x <= 0 || new_resource->size.y <= 0) { - spdlog::warn("resource {}: invalid dimensions", name); - stbi_image_free(new_resource->pixels); + if(pixels == nullptr) { + spdlog::error("image: {}: {}", name, stbi_failure_reason()); return nullptr; } - return resource_map.insert_or_assign(std::string(name), new_resource).first->second; + auto image = new Image; + image->pixels = pixels; + image->size = glm::ivec2(width, height); + return image; } -template<> -void resource::hard_cleanup(void) +static void image_free_func(const void* resource) { - for(const auto& it : resource_map) { - if(it.second.use_count() > 1L) { - spdlog::warn("resource: zombie resource [Image] {} [use_count={}]", it.first, it.second.use_count()); - } - else { - spdlog::debug("resource: releasing [Image] {}", it.first); - } - - stbi_image_free(it.second->pixels); - } + assert(resource); + + auto image = reinterpret_cast(resource); + stbi_image_free(image->pixels); - resource_map.clear(); + delete image; } -template<> -void resource::soft_cleanup(void) +void Image::register_resource(void) { - auto iter = resource_map.cbegin(); - - while(iter != resource_map.cend()) { - if(iter->second.use_count() == 1L) { - spdlog::debug("resource: releasing [Image] {}", iter->first); - - stbi_image_free(iter->second->pixels); - - iter = resource_map.erase(iter); - - continue; - } - - iter = std::next(iter); - } + resource::register_loader(&image_load_func, &image_free_func); } diff --git a/core/resource/image.hh b/core/resource/image.hh index 13e912e..b62fcbb 100644 --- a/core/resource/image.hh +++ b/core/resource/image.hh @@ -6,6 +6,8 @@ constexpr static unsigned int IMAGE_LOAD_GRAY = 0x0001U; constexpr static unsigned int IMAGE_LOAD_FLIP = 0x0002U; struct Image final { + static void register_resource(void); + stbi_uc* pixels; glm::ivec2 size; }; diff --git a/core/resource/resource.cc b/core/resource/resource.cc new file mode 100644 index 0000000..600843f --- /dev/null +++ b/core/resource/resource.cc @@ -0,0 +1,129 @@ +#include "core/pch.hh" + +#include "core/resource/resource.hh" + +struct ResourceLoader final { + ResourceLoadFunc load_func; + ResourceFreeFunc free_func; + emhash8::HashMap> resources; + std::vector> cache; + std::string class_name; +}; + +namespace +{ +emhash8::HashMap> loaders; +} // namespace + +void resource::detail::register_loader(const std::type_info& type, ResourceLoadFunc load_func, ResourceFreeFunc free_func) +{ + assert(load_func); + assert(free_func); + + auto type_index = std::type_index(type); + auto loader = std::make_unique(); + loader->class_name = type.name(); + loader->load_func = load_func; + loader->free_func = free_func; + + assert(!loaders.contains(type_index)); + + loaders.insert_or_assign(type_index, std::move(loader)); +} + +std::shared_ptr resource::detail::load_resource(const std::type_info& type, std::string_view name, std::uint32_t flags) +{ + auto name_str = std::string(name); + auto type_index = std::type_index(type); + auto loader = loaders.find(type_index); + + if(loader == loaders.cend()) { + spdlog::error("resource: no loader registered for type [{}]", type.name()); + return nullptr; + } + + auto resource_it = loader->second->resources.find(name_str); + + if(resource_it == loader->second->resources.cend()) { + auto resource_raw = loader->second->load_func(name_str.c_str(), flags); + + if(resource_raw == nullptr) { + spdlog::error("resource: {} [{}]: load failed", loader->second->class_name, name); + return nullptr; + } + + std::shared_ptr resource_ptr(resource_raw, [](const void* ptr) { /* empty */ }); + auto loaded_it = loader->second->resources.insert_or_assign(name_str, std::move(resource_ptr)); + + if(flags & RESOURCE_CACHE) { + loader->second->cache.push_back(loaded_it.first->second); + } + + return loaded_it.first->second; + } + + return resource_it->second; +} + +std::shared_ptr resource::detail::find_resource(const std::type_info& type, std::string_view name) +{ + auto name_str = std::string(name); + auto type_index = std::type_index(type); + auto loader = loaders.find(type_index); + + if(loader == loaders.cend()) { + spdlog::error("resource: no loader registered for type [{}]", type.name()); + return nullptr; + } + + auto resource_it = loader->second->resources.find(name_str); + + if(resource_it == loader->second->resources.cend()) { + spdlog::error("resource: {} [{}]: not found", loader->second->class_name, name); + return nullptr; + } + + return resource_it->second; +} + +void resource::hard_cleanup(void) +{ + for(auto& [type_index, loader] : loaders) { + loader->cache.clear(); + + for(auto& [name, resource_ptr] : loader->resources) { + if(resource_ptr.use_count() > 1) { + spdlog::warn("resource: zombie resource: {} [{}] [use_count={}]", name, loader->class_name, resource_ptr.use_count()); + } + else { + spdlog::debug("resource: releasing {} [{}]", name, loader->class_name); + } + + loader->free_func(resource_ptr.get()); + } + + loader->resources.clear(); + } + + loaders.clear(); +} + +void resource::soft_cleanup(void) +{ + for(auto& [type_index, loader] : loaders) { + auto resource_it = loader->resources.begin(); + + while(resource_it != loader->resources.end()) { + if(resource_it->second.use_count() <= 1) { + spdlog::debug("resource: releasing {} [{}]", resource_it->first, loader->class_name); + + loader->free_func(resource_it->second.get()); + resource_it = loader->resources.erase(resource_it); + + continue; + } + + resource_it = std::next(resource_it); + } + } +} diff --git a/core/resource/resource.hh b/core/resource/resource.hh index 5b6b2ac..ad8d944 100644 --- a/core/resource/resource.hh +++ b/core/resource/resource.hh @@ -5,14 +5,53 @@ template using resource_ptr = std::shared_ptr; +constexpr std::uint32_t RESOURCE_CACHE = 0x00000001U; ///< Cache the resource after loading +constexpr std::uint32_t RESOURCE_USER = 0xFFFFFF00U; ///< User-defined flags for custom behavior + +using ResourceLoadFunc = const void* (*)(const char* name, std::uint32_t flags); +using ResourceFreeFunc = void (*)(const void* resource); + +namespace resource::detail +{ +void register_loader(const std::type_info& type, ResourceLoadFunc load_func, ResourceFreeFunc free_func); +resource_ptr load_resource(const std::type_info& type, std::string_view name, std::uint32_t flags); +resource_ptr find_resource(const std::type_info& type, std::string_view name); +} // namespace resource::detail + namespace resource { template -resource_ptr load(std::string_view name, unsigned int flags = 0U); +void register_loader(ResourceLoadFunc load_func, ResourceFreeFunc free_func); template -void hard_cleanup(void); +resource_ptr load(std::string_view name, std::uint32_t flags = 0U); template +resource_ptr find(std::string_view name); +} // namespace resource + +namespace resource +{ +void hard_cleanup(void); void soft_cleanup(void); } // namespace resource +template +void resource::register_loader(ResourceLoadFunc load_func, ResourceFreeFunc free_func) +{ + resource::detail::register_loader(typeid(T), load_func, free_func); +} + +template +resource_ptr resource::load(std::string_view name, std::uint32_t flags) +{ + auto result = resource::detail::load_resource(typeid(T), name, flags); + return std::reinterpret_pointer_cast(result); +} + +template +resource_ptr resource::find(std::string_view name) +{ + auto result = resource::detail::find_resource(typeid(T), name); + return std::reinterpret_pointer_cast(result); +} + #endif // CORE_RESOURCE_RESOURCE_HH diff --git a/core/utils/CMakeLists.txt b/core/utils/CMakeLists.txt index 4f96261..5d59e8d 100644 --- a/core/utils/CMakeLists.txt +++ b/core/utils/CMakeLists.txt @@ -1,5 +1,7 @@ target_sources(core PRIVATE "${CMAKE_CURRENT_LIST_DIR}/epoch.cc" "${CMAKE_CURRENT_LIST_DIR}/epoch.hh" + "${CMAKE_CURRENT_LIST_DIR}/physfs.cc" + "${CMAKE_CURRENT_LIST_DIR}/physfs.hh" "${CMAKE_CURRENT_LIST_DIR}/string.cc" "${CMAKE_CURRENT_LIST_DIR}/string.hh") diff --git a/core/utils/physfs.cc b/core/utils/physfs.cc new file mode 100644 index 0000000..cb310df --- /dev/null +++ b/core/utils/physfs.cc @@ -0,0 +1,76 @@ +#include "core/pch.hh" + +#include "core/utils/physfs.hh" + +bool utils::read_file(std::string_view path, std::vector& buffer) +{ + auto file = PHYSFS_openRead(std::string(path).c_str()); + + if(file == nullptr) { + spdlog::error("physfs: {}: {}", path, PHYSFS_getErrorByCode(PHYSFS_getLastErrorCode())); + return false; + } + + PHYSFS_sint64 file_size = PHYSFS_fileLength(file); + buffer.resize(static_cast(file_size)); + + PHYSFS_readBytes(file, buffer.data(), file_size); + PHYSFS_close(file); + + return true; +} + +bool utils::read_file(std::string_view path, std::string& buffer) +{ + auto file = PHYSFS_openRead(std::string(path).c_str()); + + if(file == nullptr) { + spdlog::error("physfs: {}: {}", path, PHYSFS_getErrorByCode(PHYSFS_getLastErrorCode())); + return false; + } + + PHYSFS_sint64 file_size = PHYSFS_fileLength(file); + buffer.resize(static_cast(file_size)); + + PHYSFS_readBytes(file, buffer.data(), file_size); + PHYSFS_close(file); + + return true; +} + +bool utils::write_file(std::string_view path, const std::vector& buffer) +{ + auto file = PHYSFS_openWrite(std::string(path).c_str()); + + if(file == nullptr) { + spdlog::error("physfs: {}: {}", path, PHYSFS_getErrorByCode(PHYSFS_getLastErrorCode())); + return false; + } + + PHYSFS_writeBytes(file, buffer.data(), static_cast(buffer.size())); + PHYSFS_close(file); + + return true; +} + +bool utils::write_file(std::string_view path, const std::string& buffer) +{ + auto file = PHYSFS_openWrite(std::string(path).c_str()); + + if(file == nullptr) { + spdlog::error("physfs: {}: {}", path, PHYSFS_getErrorByCode(PHYSFS_getLastErrorCode())); + return false; + } + + PHYSFS_writeBytes(file, buffer.data(), static_cast(buffer.size())); + PHYSFS_close(file); + + return true; +} + +std::string_view utils::physfs_error(void) +{ + auto error_code = PHYSFS_getLastErrorCode(); + auto error_string = PHYSFS_getErrorByCode(error_code); + return std::string_view(error_string, std::strlen(error_string)); +} diff --git a/core/utils/physfs.hh b/core/utils/physfs.hh new file mode 100644 index 0000000..df5e392 --- /dev/null +++ b/core/utils/physfs.hh @@ -0,0 +1,18 @@ +#ifndef UTILS_PHYSFS_HH +#define UTILS_PHYSFS_HH 1 +#pragma once + +namespace utils +{ +bool read_file(std::string_view path, std::vector& buffer); +bool read_file(std::string_view path, std::string& buffer); +bool write_file(std::string_view path, const std::vector& buffer); +bool write_file(std::string_view path, const std::string& buffer); +} // namespace utils + +namespace utils +{ +std::string_view physfs_error(void); +} // namespace utils + +#endif // UTILS_PHYSFS_HH -- cgit