OgreResourceManager.h

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OGRE
    (Object-oriented Graphics Rendering Engine)
For the latest info, see http://www.ogre3d.org/

Copyright (c) 2000-2005 The OGRE Team
Also see acknowledgements in Readme.html

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.

This program 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt.
-----------------------------------------------------------------------------
*/
#ifndef _ResourceManager_H__
#define _ResourceManager_H__

#include "OgrePrerequisites.h"

#include "OgreResource.h"
#include "OgreResourceGroupManager.h"
#include "OgreIteratorWrappers.h"
#include "OgreCommon.h"
#include "OgreDataStream.h"
#include "OgreStringVector.h"
#include "OgreScriptLoader.h"

namespace Ogre {

    class _OgreExport ResourceManager : public ScriptLoader
    {
    public:
        OGRE_AUTO_MUTEX // public to allow external locking
        ResourceManager();
        virtual ~ResourceManager();

        virtual ResourcePtr create(const String& name, const String& group, 
            bool isManual = false, ManualResourceLoader* loader = 0, 
            const NameValuePairList* createParams = 0);
        virtual void setMemoryBudget( size_t bytes);

        virtual size_t getMemoryBudget(void) const;

        virtual void unload(const String& name);
        
        virtual void unload(ResourceHandle handle);

        virtual void unloadAll(bool reloadableOnly = true);

        virtual void reloadAll(bool reloadableOnly = true);

        virtual void unloadUnreferencedResources(bool reloadableOnly = true);

        virtual void reloadUnreferencedResources(bool reloadableOnly = true);

        virtual void remove(ResourcePtr& r);

        virtual void remove(const String& name);
        
        virtual void remove(ResourceHandle handle);
        virtual void removeAll(void);

        virtual ResourcePtr getByName(const String& name);
        virtual ResourcePtr getByHandle(ResourceHandle handle);
        
        virtual bool resourceExists(const String& name)
        {
            return !getByName(name).isNull();
        }
        virtual bool resourceExists(ResourceHandle handle)
        {
            return !getByHandle(handle).isNull();
        }

        virtual void _notifyResourceTouched(Resource* res);

        virtual void _notifyResourceLoaded(Resource* res);

        virtual void _notifyResourceUnloaded(Resource* res);

        virtual ResourcePtr load(const String& name, 
            const String& group, bool isManual = false, 
            ManualResourceLoader* loader = 0, const NameValuePairList* loadParams = 0);

        virtual const StringVector& getScriptPatterns(void) const { return mScriptPatterns; }

        virtual void parseScript(DataStreamPtr& stream, const String& groupName) {}

        virtual Real getLoadingOrder(void) const { return mLoadOrder; }

        const String& getResourceType(void) const { return mResourceType; }

    protected:

        ResourceHandle getNextHandle(void);

        virtual Resource* createImpl(const String& name, ResourceHandle handle, 
            const String& group, bool isManual, ManualResourceLoader* loader, 
            const NameValuePairList* createParams) = 0;
        virtual void addImpl( ResourcePtr& res );
        virtual void removeImpl( ResourcePtr& res );
        virtual void checkUsage(void);
        virtual size_t getMemoryUsage(void) const { return mMemoryUsage; }


    public:
        typedef HashMap< String, ResourcePtr > ResourceMap;
        typedef std::map<ResourceHandle, ResourcePtr> ResourceHandleMap;
    protected:
        ResourceHandleMap mResourcesByHandle;
        ResourceMap mResources;
        ResourceHandle mNextHandle;
        size_t mMemoryBudget; // In bytes
        size_t mMemoryUsage; // In bytes

        // IMPORTANT - all subclasses must populate the fields below

        StringVector mScriptPatterns; 
        Real mLoadOrder; 
        String mResourceType; 

    public:
        typedef MapIterator<ResourceHandleMap> ResourceMapIterator;
        ResourceMapIterator getResourceIterator(void) 
        {
            return ResourceMapIterator(mResourcesByHandle.begin(), mResourcesByHandle.end());
        }

    

    };

}

#endif

---

Copyright © 2000-2005 by The OGRE Team

This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sun Mar 12 14:37:48 2006