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.