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-2011 Torus Knot Software Ltd

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
-----------------------------------------------------------------------------
*/
#ifndef _ResourceGroupManager_H__
#define _ResourceGroupManager_H__

#include "OgrePrerequisites.h"
#include "OgreSingleton.h"
#include "OgreCommon.h"
#include "OgreDataStream.h"
#include "OgreResource.h"
#include "OgreArchive.h"
#include "OgreIteratorWrappers.h"
#include <ctime>

// If X11/Xlib.h gets included before this header (for example it happens when
// including wxWidgets and FLTK), Status is defined as an int which we don't
// want as we have an enum named Status.
#ifdef Status
#undef Status
#endif

namespace Ogre {

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

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

        virtual void scriptParseEnded(const String& scriptName, bool skipped) = 0;
        virtual void resourceGroupScriptingEnded(const String& groupName) = 0;

        virtual void resourceGroupPrepareStarted(const String& groupName, size_t resourceCount)
                { (void)groupName; (void)resourceCount; }

        virtual void resourcePrepareStarted(const ResourcePtr& resource)
                { (void)resource; }

        virtual void resourcePrepareEnded(void) {}
        virtual void worldGeometryPrepareStageStarted(const String& description)
        { (void)description; }

        virtual void worldGeometryPrepareStageEnded(void) {}
        virtual void resourceGroupPrepareEnded(const String& groupName)
        { (void)groupName; }

        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 ResourceLoadingListener
    {
    public:
        virtual ~ResourceLoadingListener() {}

        virtual DataStreamPtr resourceLoading(const String &name, const String &group, Resource *resource) = 0;

        virtual void resourceStreamOpened(const String &name, const String &group, Resource *resource, DataStreamPtr& dataStream) = 0;

        virtual bool resourceCollision(Resource *resource, ResourceManager *resourceManager) = 0;
    };

    class _OgreExport ResourceGroupManager : public Singleton<ResourceGroupManager>, public ResourceAlloc
    {
    public:
        OGRE_AUTO_MUTEX // public to allow external locking
        static String DEFAULT_RESOURCE_GROUP_NAME;
        static String INTERNAL_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 list<ResourceDeclaration>::type ResourceDeclarationList;
        typedef map<String, ResourceManager*>::type ResourceManagerMap;
        typedef MapIterator<ResourceManagerMap> ResourceManagerIterator;
        struct ResourceLocation
        {
            Archive* archive;
            bool recursive;
        };
        typedef list<ResourceLocation*>::type LocationList;

    protected:
        ResourceManagerMap mResourceManagerMap;

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

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

        ResourceLoadingListener *mLoadingListener;

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

        typedef list<ResourcePtr>::type LoadUnloadResourceList;
        struct ResourceGroup
        {
            enum Status
            {
                UNINITIALSED = 0,
                INITIALISING = 1,
                INITIALISED = 2,
                LOADING = 3,
                LOADED = 4
            };
            OGRE_AUTO_MUTEX
            OGRE_MUTEX(statusMutex)
            String name;
            Status groupStatus;
            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 map<Real, LoadUnloadResourceList*>::type LoadResourceOrderMap;
            LoadResourceOrderMap loadResourceOrderMap;
            String worldGeometry;
            SceneManager* worldGeometrySceneManager;
            // in global pool flag - if true the resource will be loaded even a different   group was requested in the load method as a parameter.
            bool inGlobalPool;

            void addToIndex(const String& filename, Archive* arch);
            void removeFromIndex(const String& filename, Archive* arch);
            void removeFromIndex(Archive* arch);

        };
        typedef map<String, ResourceGroup*>::type 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, bool &skipScript);
        void fireScriptEnded(const String& scriptName, bool skipped);
        void fireResourceGroupScriptingEnded(const String& groupName);
        void fireResourceGroupLoadStarted(const String& groupName, size_t resourceCount);
        void fireResourceLoadStarted(const ResourcePtr& resource);
        void fireResourceLoadEnded(void);
        void fireResourceGroupLoadEnded(const String& groupName);
        void fireResourceGroupPrepareStarted(const String& groupName, size_t resourceCount);
        void fireResourcePrepareStarted(const ResourcePtr& resource);
        void fireResourcePrepareEnded(void);
        void fireResourceGroupPrepareEnded(const String& groupName);

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

        void createResourceGroup(const String& name, const bool inGlobalPool = true);


        void initialiseResourceGroup(const String& name);

        void initialiseAllResourceGroups(void);

        void prepareResourceGroup(const String& name, bool prepareMainResources = true, 
            bool prepareWorldGeom = true);

        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);

        bool isResourceGroupInitialised(const String& name);

        bool isResourceGroupLoaded(const String& name);

        /*** Verify if a resource group exists
        @param name The name of the resource group to look for
        */
        bool resourceGroupExists(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);
        bool resourceLocationExists(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, bool dirs = false);

        FileInfoListPtr listResourceFileInfo(const String& groupName, bool dirs = false);

        StringVectorPtr findResourceNames(const String& groupName, const String& pattern,
            bool dirs = false);

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

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

        const String& findGroupContainingResource(const String& filename);

        FileInfoListPtr findResourceFileInfo(const String& group, const String& pattern,
            bool dirs = false);

        time_t resourceModifiedTime(const String& group, const String& filename); 
        StringVectorPtr listResourceLocations(const String& groupName);

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

        time_t resourceModifiedTime(ResourceGroup* group, const String& filename); 

        DataStreamPtr createResource(const String& filename, const String& groupName = DEFAULT_RESOURCE_GROUP_NAME, 
            bool overwrite = false, const String& locationPattern = StringUtil::BLANK);

        void deleteResource(const String& filename, const String& groupName = DEFAULT_RESOURCE_GROUP_NAME, 
            const String& locationPattern = StringUtil::BLANK);

        void deleteMatchingResources(const String& filePattern, const String& groupName = DEFAULT_RESOURCE_GROUP_NAME, 
            const String& locationPattern = StringUtil::BLANK);

        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);

        bool isResourceGroupInGlobalPool(const String& name);

        void shutdownAll(void);


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

        void _unregisterResourceManager(const String& resourceType);

        ResourceManagerIterator getResourceManagerIterator()
        { return ResourceManagerIterator(
            mResourceManagerMap.begin(), mResourceManagerMap.end()); }

        void _registerScriptLoader(ScriptLoader* su);

        void _unregisterScriptLoader(ScriptLoader* su);

        ScriptLoader *_findScriptLoader(const String &pattern);

        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);

        const LocationList& getResourceLocationList(const String& groupName);

        void setLoadingListener(ResourceLoadingListener *listener);
        ResourceLoadingListener *getLoadingListener();

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

    };
}

#endif