OgreResourceGroupManager.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 _ResourceGroupManager_H__
#define _ResourceGroupManager_H__

#include "OgrePrerequisites.h"
#include "OgreSingleton.h"
#include "OgreCommon.h"
#include "OgreDataStream.h"
#include "OgreResource.h"
#include "OgreArchive.h"

namespace Ogre {

    class _OgreExport ResourceGroupListener
    {
    public:
        virtual ~ResourceGroupListener() {}

        virtual void resourceGroupScriptingStarted(const String& groupName, size_t scriptCount) = 0;
        virtual void scriptParseStarted(const String& scriptName) = 0;
        virtual void scriptParseEnded(void) = 0;
        virtual void resourceGroupScriptingEnded(const String& groupName) = 0;

        virtual void resourceGroupLoadStarted(const String& groupName, size_t resourceCount) = 0;
        virtual void resourceLoadStarted(const ResourcePtr& resource) = 0;
        virtual void resourceLoadEnded(void) = 0;
        virtual void worldGeometryStageStarted(const String& description) = 0;
        virtual void worldGeometryStageEnded(void) = 0;

        virtual void resourceGroupLoadEnded(const String& groupName) = 0;

    };
    class _OgreExport ResourceGroupManager : public Singleton<ResourceGroupManager>
    {
    public:
        OGRE_AUTO_MUTEX // public to allow external locking
        static String DEFAULT_RESOURCE_GROUP_NAME;
        static String INTERNAL_RESOURCE_GROUP_NAME;
        static String BOOTSTRAP_RESOURCE_GROUP_NAME;
        static String AUTODETECT_RESOURCE_GROUP_NAME;
        static size_t RESOURCE_SYSTEM_NUM_REFERENCE_COUNTS;
        struct ResourceDeclaration
        {
            String resourceName;
            String resourceType;
            ManualResourceLoader* loader;
            NameValuePairList parameters;
        };
        typedef std::list<ResourceDeclaration> ResourceDeclarationList;
    protected:
        typedef std::map<String, ResourceManager*> ResourceManagerMap;
        ResourceManagerMap mResourceManagerMap;

        typedef std::multimap<Real, ScriptLoader*> ScriptLoaderOrderMap;
        ScriptLoaderOrderMap mScriptLoaderOrderMap;

        typedef std::vector<ResourceGroupListener*> ResourceGroupListenerList;
        ResourceGroupListenerList mResourceGroupListenerList;

        typedef std::map<String, Archive*> ResourceLocationIndex;

        struct ResourceLocation
        {
            Archive* archive;
            bool recursive;
        };
        typedef std::list<ResourceLocation*> LocationList;
        typedef std::list<ResourcePtr> LoadUnloadResourceList;
        struct ResourceGroup
        {
            OGRE_AUTO_MUTEX
            String name;
            bool initialised;
            LocationList locationList;
            ResourceLocationIndex resourceIndexCaseSensitive;
            ResourceLocationIndex resourceIndexCaseInsensitive;
            ResourceDeclarationList resourceDeclarations;
            // Group by loading order of the type (defined by ResourceManager)
            // (e.g. skeletons and materials before meshes)
            typedef std::map<Real, LoadUnloadResourceList*> LoadResourceOrderMap;
            LoadResourceOrderMap loadResourceOrderMap;
            String worldGeometry;
            SceneManager* worldGeometrySceneManager;
        };
        typedef std::map<String, ResourceGroup*> ResourceGroupMap;
        ResourceGroupMap mResourceGroupMap;

        String mWorldGroupName;

        void parseResourceGroupScripts(ResourceGroup* grp);
        void createDeclaredResources(ResourceGroup* grp);
        void addCreatedResource(ResourcePtr& res, ResourceGroup& group);
        ResourceGroup* getResourceGroup(const String& name);
        void dropGroupContents(ResourceGroup* grp);
        void deleteGroup(ResourceGroup* grp);
        ResourceGroup* findGroupContainingResourceImpl(const String& filename);
        void fireResourceGroupScriptingStarted(const String& groupName, size_t scriptCount);
        void fireScriptStarted(const String& scriptName);
        void fireScriptEnded(void);
        void fireResourceGroupScriptingEnded(const String& groupName);
        void fireResourceGroupLoadStarted(const String& groupName, size_t resourceCount);
        void fireResourceStarted(const ResourcePtr& resource);
        void fireResourceEnded(void);
        void fireResourceGroupLoadEnded(const String& groupName);



        ResourceGroup* mCurrentGroup;
    public:
        ResourceGroupManager();
        virtual ~ResourceGroupManager();

        void createResourceGroup(const String& name);


        void initialiseResourceGroup(const String& name);

        void initialiseAllResourceGroups(void);

        void loadResourceGroup(const String& name, bool loadMainResources = true, 
            bool loadWorldGeom = true);

        void unloadResourceGroup(const String& name, bool reloadableOnly = true);

        void unloadUnreferencedResourcesInGroup(const String& name, 
            bool reloadableOnly = true);

        void clearResourceGroup(const String& name);
        
        void destroyResourceGroup(const String& name);

        void addResourceLocation(const String& name, const String& locType, 
            const String& resGroup = DEFAULT_RESOURCE_GROUP_NAME, bool recursive = false);
        void removeResourceLocation(const String& name, 
            const String& resGroup = DEFAULT_RESOURCE_GROUP_NAME);

        void declareResource(const String& name, const String& resourceType,
            const String& groupName = DEFAULT_RESOURCE_GROUP_NAME,
            const NameValuePairList& loadParameters = NameValuePairList());
        void declareResource(const String& name, const String& resourceType,
            const String& groupName, ManualResourceLoader* loader,
            const NameValuePairList& loadParameters = NameValuePairList());
        void undeclareResource(const String& name, const String& groupName);

        DataStreamPtr openResource(const String& resourceName, 
            const String& groupName = DEFAULT_RESOURCE_GROUP_NAME,
            bool searchGroupsIfNotFound = true, Resource* resourceBeingLoaded = 0);

        DataStreamListPtr openResources(const String& pattern, 
            const String& groupName = DEFAULT_RESOURCE_GROUP_NAME);
        
        StringVectorPtr listResourceNames(const String& groupName);

        FileInfoListPtr listResourceFileInfo(const String& groupName);

        StringVectorPtr findResourceNames(const String& groupName, const String& pattern);

        bool resourceExists(const String& group, const String& filename);

        bool resourceExists(ResourceGroup* group, const String& filename);
        const String& findGroupContainingResource(const String& filename);

        FileInfoListPtr findResourceFileInfo(const String& group, const String& pattern);

        
        void addResourceGroupListener(ResourceGroupListener* l);
        void removeResourceGroupListener(ResourceGroupListener* l);

        void setWorldResourceGroupName(const String& groupName) {mWorldGroupName = groupName;}

        const String& getWorldResourceGroupName(void) const { return mWorldGroupName; }

        void linkWorldGeometryToResourceGroup(const String& group, 
            const String& worldGeometry, SceneManager* sceneManager);

        void unlinkWorldGeometryFromResourceGroup(const String& group);

        void shutdownAll(void);


        void _registerResourceManager(const String& resourceType, ResourceManager* rm);

        void _unregisterResourceManager(const String& resourceType);


        void _registerScriptLoader(ScriptLoader* su);

        void _unregisterScriptLoader(ScriptLoader* su);

        ResourceManager* _getResourceManager(const String& resourceType);

        void _notifyResourceCreated(ResourcePtr& res);

        void _notifyResourceRemoved(ResourcePtr& res);

        void _notifyResourceGroupChanged(const String& oldGroup, Resource* res);

        void _notifyAllResourcesRemoved(ResourceManager* manager);

        void _notifyWorldGeometryStageStarted(const String& description);
        void _notifyWorldGeometryStageEnded(void);

        StringVector getResourceGroups(void);
        ResourceDeclarationList getResourceDeclarationList(const String& groupName);

        static ResourceGroupManager& getSingleton(void);
        static ResourceGroupManager* getSingletonPtr(void);

    };
}

#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