Added Resource Manager
This commit is contained in:
sippeangelo
@@ -0,0 +1,148 @@
|
||||
#ifndef ResourceManager_h__
|
||||
#define ResourceManager_h__
|
||||
|
||||
#include <string>
|
||||
#include <functional>
|
||||
#include <vector>
|
||||
#include <set>
|
||||
#include <unordered_map>
|
||||
#include <fstream>
|
||||
|
||||
#include "Util/UnorderedMapPair.h"
|
||||
#include "Util/Factory.h"
|
||||
#include "Util/FileWatcher.h"
|
||||
|
||||
/** Base Resource class.
|
||||
|
||||
Implement this class for every resource to be handled by the resource manager.
|
||||
Implement Create() to return a new object of that type.
|
||||
*/
|
||||
class Resource
|
||||
{
|
||||
friend class ResourceManager;
|
||||
|
||||
protected:
|
||||
Resource() { }
|
||||
|
||||
public:
|
||||
// Pretend that this is a pure virtual function that you have to implement
|
||||
// FIXME: Why did we do this again instead of just using the constructor?
|
||||
// static Resource* Create(std::string resourceName);
|
||||
|
||||
virtual void Reload() { }
|
||||
virtual void OnChildReloaded(Resource* child) { }
|
||||
|
||||
unsigned int TypeID;
|
||||
unsigned int ResourceID;
|
||||
};
|
||||
|
||||
/** Singleton resource manager to keep track of and cache any external engine assets */
|
||||
class ResourceManager
|
||||
{
|
||||
private:
|
||||
ResourceManager();
|
||||
|
||||
public:
|
||||
/*static ResourceManager& Instance()
|
||||
{
|
||||
static ResourceManager s;
|
||||
return s;
|
||||
}*/
|
||||
|
||||
template <typename T>
|
||||
static void RegisterType(std::string typeName);
|
||||
|
||||
/** Preloads a resource and caches it for future use
|
||||
|
||||
@tparam T Resource type.
|
||||
@param resourceName Fully qualified name of the resource to preload.
|
||||
*/
|
||||
template <typename T>
|
||||
static void Preload(std::string resourceName);
|
||||
static void Preload(std::string resourceType, std::string resourceName);
|
||||
|
||||
/** Checks if a resource is in cache
|
||||
|
||||
@param resourceType Resource type as string.
|
||||
@param resourceName Fully qualified name of the resource to preload.
|
||||
*/
|
||||
// TODO: Templateify
|
||||
static bool IsResourceLoaded(std::string resourceType, std::string resourceName);
|
||||
|
||||
/** Hot-loads a resource and caches it for future use
|
||||
|
||||
@tparam T Resource type.
|
||||
@param resourceName Fully qualified name of the resource to load.
|
||||
*/
|
||||
template <typename T>
|
||||
static T* Load(std::string resourceName, Resource* parent = nullptr);
|
||||
static Resource* Load(std::string resourceType, std::string resourceName, Resource* parent = nullptr);
|
||||
|
||||
/** Reloads an already loaded resource, keeping its resource ID intact.
|
||||
|
||||
@tparam T Resource type.
|
||||
@param resourceName Fully qualified name of the resource to reload.
|
||||
*/
|
||||
static void Reload(std::string resourceName);
|
||||
|
||||
static void Update();
|
||||
|
||||
private:
|
||||
static std::unordered_map<std::string, std::string> m_CompilerTypenameToResourceType;
|
||||
static std::unordered_map<std::string, std::function<Resource*(std::string)>> m_FactoryFunctions; // type -> factory function
|
||||
static std::unordered_map<std::pair<std::string, std::string>, Resource*> m_ResourceCache; // (type, name) -> resource
|
||||
static std::unordered_map<std::string, Resource*> m_ResourceFromName; // name -> resource
|
||||
static std::unordered_map<Resource*, Resource*> m_ResourceParents; // resource -> parent resource
|
||||
|
||||
// TODO: Getters for IDs
|
||||
static unsigned int m_CurrentResourceTypeID;
|
||||
static std::unordered_map<std::string, unsigned int> m_ResourceTypeIDs;
|
||||
// Number of resources of a type. Doubles as local ID.
|
||||
static std::unordered_map<unsigned int, unsigned int> m_ResourceCount;
|
||||
// Flag to suppress hot-load warnings when a preloading resource chain loads another resource
|
||||
static bool m_Preloading;
|
||||
|
||||
static FileWatcher m_FileWatcher;
|
||||
static void fileWatcherCallback(std::string path, FileWatcher::FileEventFlags flags);
|
||||
|
||||
static unsigned int GetTypeID(std::string resourceType);
|
||||
static unsigned int GetNewResourceID(unsigned int typeID);
|
||||
|
||||
// Internal: Create a resource and cache it
|
||||
static Resource* CreateResource(std::string resourceType, std::string resourceName, Resource* parent);
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
T* ResourceManager::Load(std::string resourceName, Resource* parent /* = nullptr */)
|
||||
{
|
||||
auto resourceTypename = typeid(T).name();
|
||||
auto it = m_CompilerTypenameToResourceType.find(resourceTypename);
|
||||
if (it == m_CompilerTypenameToResourceType.end()) {
|
||||
LOG_ERROR("Failed to load resource \"%s\" of type \"%s\": type not registered", resourceName.c_str(), resourceTypename);
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
return static_cast<T*>(Load(it->second, resourceName, parent));
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
void ResourceManager::RegisterType(std::string typeName)
|
||||
{
|
||||
m_CompilerTypenameToResourceType[typeid(T).name()] = typeName;
|
||||
m_FactoryFunctions[typeName] = [](std::string resourceName) { return new T(resourceName); };
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
void ResourceManager::Preload(std::string resourceName)
|
||||
{
|
||||
auto resourceTypename = typeid(T).name();
|
||||
auto it = m_CompilerTypenameToResourceType.find(resourceTypename);
|
||||
if (it == m_CompilerTypenameToResourceType.end()) {
|
||||
LOG_ERROR("Failed to load resource \"%s\" of type \"%s\": type not registered", resourceName.c_str(), resourceTypename);
|
||||
return;
|
||||
}
|
||||
|
||||
Preload(it->second, resourceName);
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,118 @@
|
||||
#include "PrecompiledHeader.h"
|
||||
#include "Core/ResourceManager.h"
|
||||
|
||||
std::unordered_map<std::string, std::string> ResourceManager::m_CompilerTypenameToResourceType;
|
||||
std::unordered_map<std::string, std::function<Resource*(std::string)>> ResourceManager::m_FactoryFunctions;
|
||||
std::unordered_map<std::pair<std::string, std::string>, Resource*> ResourceManager::m_ResourceCache;
|
||||
std::unordered_map<std::string, Resource*> ResourceManager::m_ResourceFromName;
|
||||
std::unordered_map<Resource*, Resource*> ResourceManager::m_ResourceParents;
|
||||
unsigned int ResourceManager::m_CurrentResourceTypeID = 0;
|
||||
std::unordered_map<std::string, unsigned int> ResourceManager::m_ResourceTypeIDs;
|
||||
std::unordered_map<unsigned int, unsigned int> ResourceManager::m_ResourceCount;
|
||||
bool ResourceManager::m_Preloading = false;
|
||||
FileWatcher ResourceManager::m_FileWatcher;
|
||||
|
||||
unsigned int ResourceManager::GetTypeID(std::string resourceType)
|
||||
{
|
||||
if (m_ResourceTypeIDs.find(resourceType) == m_ResourceTypeIDs.end()) {
|
||||
m_ResourceTypeIDs[resourceType] = m_CurrentResourceTypeID++;
|
||||
}
|
||||
return m_ResourceTypeIDs[resourceType];
|
||||
}
|
||||
|
||||
|
||||
void ResourceManager::Reload(std::string resourceName)
|
||||
{
|
||||
auto it = m_ResourceFromName.find(resourceName);
|
||||
if (it != m_ResourceFromName.end()) {
|
||||
LOG_INFO("Reloading resource \"%s\"", resourceName.c_str());
|
||||
Resource* resource = it->second;
|
||||
resource->Reload();
|
||||
|
||||
// Notify parent
|
||||
auto it2 = m_ResourceParents.find(resource);
|
||||
if (it2 != m_ResourceParents.end()) {
|
||||
it2->second->OnChildReloaded(resource);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
unsigned int ResourceManager::GetNewResourceID(unsigned int typeID)
|
||||
{
|
||||
return m_ResourceCount[typeID]++;
|
||||
}
|
||||
|
||||
bool ResourceManager::IsResourceLoaded(std::string resourceType, std::string resourceName)
|
||||
{
|
||||
return m_ResourceCache.find(std::make_pair(resourceType, resourceName)) != m_ResourceCache.end();
|
||||
}
|
||||
|
||||
void ResourceManager::fileWatcherCallback(std::string path, FileWatcher::FileEventFlags flags)
|
||||
{
|
||||
if (flags & FileWatcher::FileEventFlags::SizeChanged || flags & FileWatcher::FileEventFlags::TimestampChanged) {
|
||||
auto it = m_ResourceFromName.find(path);
|
||||
if (it != m_ResourceFromName.end()) {
|
||||
Reload(path);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void ResourceManager::Update()
|
||||
{
|
||||
m_FileWatcher.Check();
|
||||
}
|
||||
|
||||
void ResourceManager::Preload(std::string resourceType, std::string resourceName)
|
||||
{
|
||||
if (IsResourceLoaded(resourceType, resourceName)) {
|
||||
//LOG_WARNING("Attempted to preload resource \"%s\" multiple times!", resourceName.c_str());
|
||||
return;
|
||||
}
|
||||
|
||||
m_Preloading = true;
|
||||
LOG_INFO("Preloading resource \"%s\"", resourceName.c_str());
|
||||
CreateResource(resourceType, resourceName, nullptr);
|
||||
m_Preloading = false;
|
||||
}
|
||||
|
||||
Resource* ResourceManager::Load(std::string resourceType, std::string resourceName, Resource* parent /*= nullptr*/)
|
||||
{
|
||||
auto it = m_ResourceCache.find(std::make_pair(resourceType, resourceName));
|
||||
if (it != m_ResourceCache.end()) {
|
||||
return it->second;
|
||||
}
|
||||
|
||||
if (m_Preloading) {
|
||||
LOG_INFO("Preloading resource \"%s\"", resourceName.c_str());
|
||||
} else {
|
||||
LOG_WARNING("Hot-loading resource \"%s\"", resourceName.c_str());
|
||||
}
|
||||
|
||||
return CreateResource(resourceType, resourceName, parent);
|
||||
}
|
||||
|
||||
Resource* ResourceManager::CreateResource(std::string resourceType, std::string resourceName, Resource* parent)
|
||||
{
|
||||
auto facIt = m_FactoryFunctions.find(resourceType);
|
||||
if (facIt == m_FactoryFunctions.end()) {
|
||||
LOG_ERROR("Failed to load resource \"%s\" of type \"%s\": type not registered", resourceName.c_str(), resourceType.c_str());
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
// Call the factory function
|
||||
Resource* resource = facIt->second(resourceName);
|
||||
// Store IDs
|
||||
resource->TypeID = GetTypeID(resourceType);
|
||||
resource->ResourceID = GetNewResourceID(resource->TypeID);
|
||||
// Cache
|
||||
m_ResourceCache[std::make_pair(resourceType, resourceName)] = resource;
|
||||
m_ResourceFromName[resourceName] = resource;
|
||||
if (parent != nullptr) {
|
||||
m_ResourceParents[resource] = parent;
|
||||
}
|
||||
if (!boost::filesystem::is_directory(resourceName)) {
|
||||
LOG_DEBUG("Adding watch for %s", resourceName.c_str());
|
||||
m_FileWatcher.AddWatch(resourceName, fileWatcherCallback);
|
||||
}
|
||||
return resource;
|
||||
}
|
||||
Reference in New Issue
Block a user