Add support for external resource allocator

src/ResourceLoader.cpp

@@ -36,8 +36,9 @@ namespace crown
 {
 
 //-----------------------------------------------------------------------------
-ResourceLoader::ResourceLoader(ResourceManager* resource_manager, Filesystem* filesystem) :
+ResourceLoader::ResourceLoader(ResourceManager* resource_manager, Allocator& resource_allocator, Filesystem* filesystem) :
 	m_resource_manager(resource_manager),
+	m_resource_allocator(&resource_allocator),
 	m_filesystem(filesystem),
 	m_resource_archive(filesystem),
 	m_resources(m_allocator)
@@ -63,9 +64,9 @@ void ResourceLoader::load(ResourceId name)
 }
 
 //-----------------------------------------------------------------------------
-void ResourceLoader::unload(ResourceId name)
+void ResourceLoader::unload(ResourceId name, void* resource)
 {
-	// do something
+	unload_by_type(name, resource);
 }
 
 //-----------------------------------------------------------------------------
@@ -93,16 +94,36 @@ void* ResourceLoader::load_by_type(ResourceId name)
 
 	if (name.type == m_texture_hash)
 	{
-		return TextureResource::load(&m_resource_archive, name);
+		return TextureResource::load(*m_resource_allocator, &m_resource_archive, name);
 	}
 
 	if (name.type == m_txt_hash)
 	{
-		return TextResource::load(&m_resource_archive, name);
+		return TextResource::load(*m_resource_allocator, &m_resource_archive, name);
 	}
 
 	return NULL;
 }
 
-} // namespace crown
+//-----------------------------------------------------------------------------
+void ResourceLoader::unload_by_type(ResourceId name, void* resource)
+{
+	if (name.type == m_config_hash)
+	{
+		return;
+	}
 
+	if (name.type == m_texture_hash)
+	{
+		TextureResource::unload(*m_resource_allocator, (TextureResource*)resource);
+	}
+
+	if (name.type == m_txt_hash)
+	{
+		TextResource::unload(*m_resource_allocator, (TextResource*)resource);
+	}
+
+	return;
+}
+
+} // namespace crown

src/ResourceLoader.h

@@ -34,27 +34,30 @@ namespace crown
 {
 
 class ResourceManager;
+class Allocator;
 class Filesystem;
 
 class ResourceLoader
 {
 public:
 
-						ResourceLoader(ResourceManager* resource_manager, Filesystem* filesystem);
+						ResourceLoader(ResourceManager* resource_manager, Allocator& resource_allocator, Filesystem* filesystem);
 						~ResourceLoader();
 
 	void				load(ResourceId name);
-	void				unload(ResourceId name);
+	void				unload(ResourceId name, void* resource);
 
 	void				flush();
 
 private:
 
 	void*				load_by_type(ResourceId name);
+	void				unload_by_type(ResourceId name, void* resource);
 
 private:
 
 	ResourceManager*	m_resource_manager;
+	Allocator*			m_resource_allocator;
 	Filesystem*			m_filesystem;
 
 	ResourceArchive		m_resource_archive;

src/ResourceManager.cpp

@@ -31,12 +31,15 @@ OTHER DEALINGS IN THE SOFTWARE.
 #include "Path.h"
 #include <algorithm>
 
+#include "TextureResource.h"
+
 namespace crown
 {
 
 //-----------------------------------------------------------------------------
-ResourceManager::ResourceManager(Filesystem* filesystem) :
-	m_resource_loader(this, filesystem),
+ResourceManager::ResourceManager(Allocator& resource_allocator, Filesystem* filesystem) :
+	m_resource_allocator(&resource_allocator),
+	m_resource_loader(this, resource_allocator, filesystem),
 	m_resources(m_allocator)
 {
 }
@@ -103,12 +106,12 @@ void ResourceManager::unload(ResourceId name)
 	
 	entry.references--;
 	
-	if (entry.references == 0)
+	if (entry.references == 0 && entry.state == RS_LOADED)
 	{
+		m_resource_loader.unload(name, entry.resource);
+
 		entry.state = RS_UNLOADED;
 		entry.resource = NULL;
-
-		m_resource_loader.unload(name);
 	}
 }
 
@@ -126,7 +129,7 @@ void ResourceManager::reload(ResourceId name)
 }
 
 //-----------------------------------------------------------------------------
-bool ResourceManager::has(ResourceId name)
+bool ResourceManager::has(ResourceId name) const
 {
 	if (m_resources.size() > name.index)
 	{
@@ -137,7 +140,7 @@ bool ResourceManager::has(ResourceId name)
 }
 
 //-----------------------------------------------------------------------------
-void* ResourceManager::data(ResourceId name)
+const void* ResourceManager::data(ResourceId name) const
 {
 	assert(has(name));
 	
@@ -145,13 +148,21 @@ void* ResourceManager::data(ResourceId name)
 }
 
 //-----------------------------------------------------------------------------
-bool ResourceManager::is_loaded(ResourceId name)
+bool ResourceManager::is_loaded(ResourceId name) const
 {
 	assert(has(name));
 
 	return m_resources[name.index].state == RS_LOADED;
 }
 
+//-----------------------------------------------------------------------------
+uint32_t ResourceManager::references(ResourceId name) const
+{
+	assert(has(name));
+
+	return m_resources[name.index].references;
+}
+
 //-----------------------------------------------------------------------------
 void ResourceManager::loading(ResourceId name)
 {
@@ -167,6 +178,11 @@ void ResourceManager::online(ResourceId name, void* resource)
 
 	ResourceEntry& entry = m_resources[name.index];
 
+	if (name.type == hash::fnv1a_32("tga", 3))
+	{
+		TextureResource::online((TextureResource*)resource);
+	}
+
 	entry.resource = resource;
 	entry.state = RS_LOADED;
 }

src/ResourceManager.h

@@ -63,7 +63,7 @@ class ResourceManager
 {
 public:
 
-							ResourceManager(Filesystem* filesystem);
+							ResourceManager(Allocator& resource_allocator, Filesystem* filesystem);
 							~ResourceManager();
 
 	/// Loads the resource by @name and returns its ResourceId.
@@ -87,18 +87,21 @@ public:
 	/// Note that having a resource does not mean that the resource is
 	/// available for using; instead, you have to check is_loaded() to
 	/// obtain the resource availability status.
-	bool					has(ResourceId name);
+	bool					has(ResourceId name) const;
 
 	/// Returns the data associated with the @name resource.
 	/// The resource data contains resource-specific metadata
 	/// and the actual resource data. In order to correctly use
 	/// it, you have to know which type of data @name refers to
 	/// and cast accordingly.
-	void*					data(ResourceId name);
+	const void*				data(ResourceId name) const;
 	
 	/// Returns whether the @name resource is loaded (i.e. whether
 	/// you can use the data associated with it).
-	bool					is_loaded(ResourceId name);
+	bool					is_loaded(ResourceId name) const;
+
+	// Returns the number of references of the @name resource
+	uint32_t				references(ResourceId name) const;
 	
 	/// Forces the loading of all of the queued resource load requests.
 	void					flush() { m_resource_loader.flush(); }
@@ -110,6 +113,7 @@ private:
 
 private:
 
+	Allocator*				m_resource_allocator;
 	ResourceLoader			m_resource_loader;
 	MallocAllocator			m_allocator;
 	List<ResourceEntry>		m_resources;
@@ -118,4 +122,3 @@ private:
 };
 
 } // namespace crown
-