/* * Copyright (C) 2021 Christopher J. Howard * * This file is part of Antkeeper source code. * * Antkeeper source code is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * Antkeeper source code is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with Antkeeper source code. If not, see . */ #ifndef ANTKEEPER_RESOURCE_MANAGER_HPP #define ANTKEEPER_RESOURCE_MANAGER_HPP #include "resource-handle.hpp" #include "resource-loader.hpp" #include "debug/logger.hpp" #include #include #include #include #include #include #include #include /** * Loads resources. */ class resource_manager { public: /** * Creates a resource manager. */ resource_manager(debug::logger* logger); /** * Destroys a resource manager and frees all of its resources. */ ~resource_manager(); bool mount(const std::filesystem::path& path); /** * Adds a path to be searched when a resource is requested. * * @param path Search path. */ void include(const std::filesystem::path& path); /** * Loads the requested resource. If the resource has already been loaded it will be retrieved from the resource cache and its reference count incremented. * * @tparam T Resource type. * @param path Path to the resource, relative to the search paths. * @return Pointer to the requested resource, or nullptr if the resource could not be found nor loaded. */ template T* load(const std::filesystem::path& path); /** * Decrements a resource's reference count and unloads the resource if it's unreferenced. * * @param path Path to the resource, relative to the search paths. */ void unload(const std::filesystem::path& path); /** * Saves the specified resource. * * @tparam T Resource type. * @param resource Pointer to the resource. * @param path Path to the resource. */ template void save(const T* resource, const std::filesystem::path& path); entt::registry& get_archetype_registry(); private: std::map resource_cache; std::list search_paths; entt::registry archetype_registry; debug::logger* logger; }; template T* resource_manager::load(const std::filesystem::path& path) { // Check if resource is in the cache auto it = resource_cache.find(path); if (it != resource_cache.end()) { /* if (logger) { logger->log("Fetched resource \"" + path.string() + "\""); } */ // Resource found resource_handle* resource = static_cast*>(it->second); // Increment resource handle reference count ++resource->reference_count; // Return resource data return resource->data; } if (logger) { logger->push_task("Loading resource \"" + path.string() + "\""); } // Resource not cached, look for file in search paths T* data = nullptr; bool found = false; for (const std::filesystem::path& search_path: search_paths) { std::filesystem::path full_path = search_path / path; // Check if file exists if (!PHYSFS_exists(full_path.string().c_str())) { continue; } // File found found = true; // Open file for reading PHYSFS_File* file = PHYSFS_openRead(full_path.string().c_str()); if (!file) { logger->error(std::string("PhysicsFS error: ") + PHYSFS_getErrorByCode(PHYSFS_getLastErrorCode())); break; } // Load opened file try { data = resource_loader::load(this, file, full_path); } catch (const std::exception& e) { logger->error("Failed to load resource: \"" + std::string(e.what()) + "\""); } // Close opened file if (!PHYSFS_close(file)) { logger->error(std::string("PhysicsFS error: ") + PHYSFS_getErrorByCode(PHYSFS_getLastErrorCode())); } break; } if (!data) { if (!found) { logger->error("File not found"); } logger->pop_task(EXIT_FAILURE); return nullptr; } // Create a resource handle for the resource data resource_handle* resource = new resource_handle(); resource->data = data; resource->reference_count = 1; // Add resource to the cache resource_cache[path] = resource; if (logger) { logger->pop_task(EXIT_SUCCESS); } return resource->data; } template void resource_manager::save(const T* resource, const std::filesystem::path& path) { logger->push_task("Saving resource to \"" + path.string() + "\""); // Open file for writing PHYSFS_File* file = PHYSFS_openWrite(path.string().c_str()); if (!file) { logger->error(std::string("PhysicsFS error: ") + PHYSFS_getErrorByCode(PHYSFS_getLastErrorCode())); logger->pop_task(EXIT_FAILURE); return; } // Save to opened file int status = EXIT_SUCCESS; try { resource_loader::save(this, file, path, resource); } catch (const std::exception& e) { logger->error("Failed to save resource: \"" + std::string(e.what()) + "\""); status = EXIT_FAILURE; } // Close opened file if (!PHYSFS_close(file)) { logger->error(std::string("PhysicsFS error: ") + PHYSFS_getErrorByCode(PHYSFS_getLastErrorCode())); status = EXIT_FAILURE; } logger->pop_task(status) } inline entt::registry& resource_manager::get_archetype_registry() { return archetype_registry; } #endif // ANTKEEPER_RESOURCE_MANAGER_HPP