Hello,
I've been wondering whats the best way of handling different "pools" of resources in a 3d game? Let me explain a bitt more what my problem is. I already have a generic "resource cache"-class:
template<typename Key, typename Resource>
class Resources
{
public:
typedef std::map<Key, Resource*> ResourceMap;
~Resources(void)
{
for(ResourceMap::iterator ii = m_mResources.begin(); ii != m_mResources.end(); ++ii)
{
delete ii->second;
}
}
void Add(const Key& stName, Resource& resource)
{
m_mResources[stName] = &resource;
}
Resource* Get(const Key& key) const
{
if(Has(key))
return m_mResources.at(key);
else
return nullptr;
}
bool Has(const Key& key) const
{
return m_mResources.count(key) == 1;
}
size_t Size(void) const
{
return m_mResources.size();
}
const ResourceMap& Map(void) const
{
return m_mResources;
}
const Key* Key(const Resource* pResource) const
{
for(ResourceMap::const_iterator ii = m_mResources.cbegin(); ii != m_mResources.cend(); ++ii)
{
if(ii->second == pResource)
return &ii->first;
}
return nullptr;
}
void Clear(void)
{
for(ResourceMap::const_iterator ii = m_mResources.cbegin(); ii != m_mResources.cend(); ++ii)
{
delete ii->second;
}
m_mResources.clear();
}
private:
ResourceMap m_mResources;
};
This is used for my textures, material, etc... . Right now I've had one of each of those, passing around where needed. Now I've ran into an issue. I've developed a small level editor for my current 3d tower defense game. This means, there are two "virtual" pool of resources: The ones loaded at the begin of the game (gbuffer, level editor textures), and the ones loaded per level (each level has its own resources). On loading of a level, I'd want to throw away the resources of the last level. How would I do that? I've got multiple ideas, which I'd like to know what you'd prefer, or how you've been doing this so far:
- Really have two different Resource<XXX> for the whole game and the editor/level. On instances where I need to access both, I'd have to check both of them. On level loading, I'd simply clear the levels resource pool.
- Give each resource a identifier, which pool it belongs to. Coded into the resource class, so I can Clear(pools).
- Same as above, only that identifier is stored in the actual resource (textures, meshes, effects), and does not exist for the Resource-class itself.
- Store a list of resources keys that belong to the game. Check on those on level loading, and prevent them from being thrown away.
- Simply discard everything on level load and reload game and level resources.
- Something completely different?
So, which one of those methods would you prefer, or what have you done in the past? Any suggestion would be great! Note that I don't care much/have time for implementing a smart-ptr or similar system for now, got to hand in the game in 6 days to come as part of an assignment, just want to get the "basic" things right here.