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-2013 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>
#include "OgreHeaderPrefix.h"
// 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;
virtual void resourceCreated(const ResourcePtr& resource)
{ (void)resource; }
virtual void resourceRemove(const ResourcePtr& resource)
{ (void)resource; }
};
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);
void fireResourceCreated(const ResourcePtr& resource);
void fireResourceRemove(const ResourcePtr& resource);
time_t resourceModifiedTime(ResourceGroup* group, const String& filename);
bool resourceExists(ResourceGroup* group, const String& filename);
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, bool readOnly = true);
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 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);
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);
};
}
#include "OgreHeaderSuffix.h"
#endif
Ogre::ResourceGroupManager::ResourceGroup::LoadResourceOrderMap
map< Real, LoadUnloadResourceList * >::type LoadResourceOrderMap
Created resources which are ready to be loaded / unloaded.
Definition: OgreResourceGroupManager.h:344
Ogre::ResourceGroupListener::resourcePrepareEnded
virtual void resourcePrepareEnded(void)
This event is fired when the resource has been prepared.
Definition: OgreResourceGroupManager.h:132
Ogre::ResourceGroupManager::ScriptLoaderOrderMap
multimap< Real, ScriptLoader * >::type ScriptLoaderOrderMap
Map of loading order (Real) to ScriptLoader, used to order script parsing.
Definition: OgreResourceGroupManager.h:301
Ogre::ResourceGroupManager::mLoadingListener
ResourceLoadingListener * mLoadingListener
Definition: OgreResourceGroupManager.h:307
Ogre::ResourceGroupListener::resourceCreated
virtual void resourceCreated(const ResourcePtr &resource)
This event is fired when a resource was just created.
Definition: OgreResourceGroupManager.h:179
Ogre::ResourceGroupManager::mWorldGroupName
String mWorldGroupName
Group name for world resources.
Definition: OgreResourceGroupManager.h:363
_OgreExport
#define _OgreExport
Definition: OgrePlatform.h:257
Ogre::ScriptLoader
Abstract class defining the interface used by classes which wish to perform script loading to define ...
Definition: OgreScriptLoader.h:59
Ogre::ResourceGroupManager::ResourceDeclaration::resourceName
String resourceName
Definition: OgreResourceGroupManager.h:276
Ogre::list
Definition: OgrePrerequisites.h:505
Ogre::ResourceGroupManager::RESOURCE_SYSTEM_NUM_REFERENCE_COUNTS
static size_t RESOURCE_SYSTEM_NUM_REFERENCE_COUNTS
The number of reference counts held per resource by the resource system.
Definition: OgreResourceGroupManager.h:272
OgreResource.h
Ogre::ResourceGroupManager::setWorldResourceGroupName
void setWorldResourceGroupName(const String &groupName)
Sets the resource group that &#39;world&#39; resources will use.
Definition: OgreResourceGroupManager.h:918
Ogre::ResourceGroupManager::ResourceGroup::loadResourceOrderMap
LoadResourceOrderMap loadResourceOrderMap
Definition: OgreResourceGroupManager.h:345
Ogre::ResourceGroupManager::mResourceGroupListenerList
ResourceGroupListenerList mResourceGroupListenerList
Definition: OgreResourceGroupManager.h:305
Ogre::ResourceGroupManager::ResourceGroup::locationList
LocationList locationList
List of possible locations to search.
Definition: OgreResourceGroupManager.h:334
Ogre::ResourceGroupManager::ResourceGroup::worldGeometry
String worldGeometry
Linked world geometry, as passed to setWorldGeometry.
Definition: OgreResourceGroupManager.h:347
Ogre::MapIterator
Concrete IteratorWrapper for nonconst access to the underlying key-value container.
Definition: OgreIteratorWrapper.h:319
Ogre::ResourceGroupManager::ResourceGroup::inGlobalPool
bool inGlobalPool
Definition: OgreResourceGroupManager.h:351
Ogre::ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME
static String AUTODETECT_RESOURCE_GROUP_NAME
Special resource group name which causes resource group to be automatically determined based on searc...
Definition: OgreResourceGroupManager.h:270
Ogre::ResourceGroupManager::ResourceDeclarationList
list< ResourceDeclaration >::type ResourceDeclarationList
List of resource declarations.
Definition: OgreResourceGroupManager.h:282
Ogre::StringVector
vector< String >::type StringVector
Definition: OgreStringVector.h:45
Ogre::Resource
Abstract class representing a loadable resource (e.g.
Definition: OgreResource.h:79
OGRE_MUTEX
#define OGRE_MUTEX(name)
Definition: OgreThreadDefinesBoost.h:47
Ogre::ManualResourceLoader
Interface describing a manual resource loader.
Definition: OgreResource.h:514
Ogre::ResourceGroupManager::ResourceManagerIterator
MapIterator< ResourceManagerMap > ResourceManagerIterator
Definition: OgreResourceGroupManager.h:284
Ogre::ResourceGroupManager::ResourceManagerMap
map< String, ResourceManager * >::type ResourceManagerMap
Definition: OgreResourceGroupManager.h:283
OgreDataStream.h
Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME
static String DEFAULT_RESOURCE_GROUP_NAME
Default resource group name.
Definition: OgreResourceGroupManager.h:266
Ogre::ResourceGroupManager::getResourceManagerIterator
ResourceManagerIterator getResourceManagerIterator()
Get an iterator over the registered resource managers.
Definition: OgreResourceGroupManager.h:979
Ogre::ResourceGroupManager::LoadUnloadResourceList
list< ResourcePtr >::type LoadUnloadResourceList
List of resources which can be loaded / unloaded.
Definition: OgreResourceGroupManager.h:313
Ogre::ResourceGroupManager::ResourceGroup::OGRE_AUTO_MUTEX
OGRE_AUTO_MUTEX
General mutex for dealing with group content.
Definition: OgreResourceGroupManager.h:326
OgreCommon.h
Ogre::ResourceGroupManager::ResourceGroup::groupStatus
Status groupStatus
Group status.
Definition: OgreResourceGroupManager.h:332
Ogre::ResourceGroupManager::mScriptLoaderOrderMap
ScriptLoaderOrderMap mScriptLoaderOrderMap
Definition: OgreResourceGroupManager.h:302
OgreSingleton.h
Ogre::ResourceGroupListener
This abstract class defines an interface which is called back during resource group loading to indica...
Definition: OgreResourceGroupManager.h:86
OgrePrerequisites.h
Ogre::ResourceGroupManager::ResourceDeclaration::resourceType
String resourceType
Definition: OgreResourceGroupManager.h:277
Ogre::ResourceGroupManager::ResourceGroup::resourceIndexCaseSensitive
ResourceLocationIndex resourceIndexCaseSensitive
Index of resource names to locations, built for speedy access (case sensitive archives) ...
Definition: OgreResourceGroupManager.h:336
Ogre::ResourceGroupManager::ResourceGroup
Resource group entry.
Definition: OgreResourceGroupManager.h:315
Ogre::ResourceGroupListener::worldGeometryPrepareStageEnded
virtual void worldGeometryPrepareStageEnded(void)
This event is fired when a stage of preparing linked world geometry has been completed.
Definition: OgreResourceGroupManager.h:145
Ogre::ResourceGroupManager::mResourceGroupMap
ResourceGroupMap mResourceGroupMap
Definition: OgreResourceGroupManager.h:360
Ogre::NameValuePairList
map< String, String >::type NameValuePairList
Name / value parameter pair (first = name, second = value)
Definition: OgreCommon.h:550
Ogre::ResourceGroupManager::ResourceGroup::worldGeometrySceneManager
SceneManager * worldGeometrySceneManager
Scene manager to use with linked world geometry.
Definition: OgreResourceGroupManager.h:349
Ogre::String
_StringBase String
Definition: OgrePrerequisites.h:439
Ogre::ResourceGroupManager::OGRE_AUTO_MUTEX
OGRE_AUTO_MUTEX
Definition: OgreResourceGroupManager.h:264
Ogre::ResourceGroupManager::INTERNAL_RESOURCE_GROUP_NAME
static String INTERNAL_RESOURCE_GROUP_NAME
Internal resource group name (should be used by OGRE internal only)
Definition: OgreResourceGroupManager.h:268
Ogre::ResourceGroupManager::ResourceGroup::resourceIndexCaseInsensitive
ResourceLocationIndex resourceIndexCaseInsensitive
Index of resource names to locations, built for speedy access (case insensitive archives) ...
Definition: OgreResourceGroupManager.h:338
OgreHeaderSuffix.h
Ogre::ResourceGroupManager::ResourceGroup::Status
Status
Definition: OgreResourceGroupManager.h:317
Ogre::ResourceGroupManager::mResourceManagerMap
ResourceManagerMap mResourceManagerMap
Map of resource types (strings) to ResourceManagers, used to notify them to load / unload group conte...
Definition: OgreResourceGroupManager.h:298
Ogre::ResourceManager
Defines a generic resource handler.
Definition: OgreResourceManager.h:122
Ogre::ResourceGroupManager::ResourceGroupMap
map< String, ResourceGroup * >::type ResourceGroupMap
Map from resource group names to groups.
Definition: OgreResourceGroupManager.h:359
Ogre::ResourceGroupListener::resourceGroupPrepareStarted
virtual void resourceGroupPrepareStarted(const String &groupName, size_t resourceCount)
This event is fired when a resource group begins preparing.
Definition: OgreResourceGroupManager.h:121
OgreIteratorWrappers.h
Ogre::ResourceGroupManager::ResourceGroup::resourceDeclarations
ResourceDeclarationList resourceDeclarations
Pre-declared resources, ready to be created.
Definition: OgreResourceGroupManager.h:340
Ogre::ResourceGroupListener::~ResourceGroupListener
virtual ~ResourceGroupListener()
Definition: OgreResourceGroupManager.h:89
Ogre
Definition: OgreAndroidLogListener.h:34
Ogre::ResourceGroupManager
This singleton class manages the list of resource groups, and notifying the various resource managers...
Definition: OgreResourceGroupManager.h:261
Ogre::ResourceGroupManager::ResourceGroupListenerList
vector< ResourceGroupListener * >::type ResourceGroupListenerList
Definition: OgreResourceGroupManager.h:304
Ogre::SharedPtr< Resource >
Ogre::ResourceGroupManager::ResourceGroup::name
String name
Group name.
Definition: OgreResourceGroupManager.h:330
Ogre::ResourceLoadingListener::~ResourceLoadingListener
virtual ~ResourceLoadingListener()
Definition: OgreResourceGroupManager.h:196
Ogre::vector
Definition: OgrePrerequisites.h:491
OgreHeaderPrefix.h
Ogre::ResourceGroupManager::ResourceDeclaration
Nested struct defining a resource declaration.
Definition: OgreResourceGroupManager.h:274
OgreArchive.h
Ogre::ResourceGroupManager::ResourceLocation
Resource location entry.
Definition: OgreResourceGroupManager.h:286
Ogre::ResourceGroupListener::resourceGroupPrepareEnded
virtual void resourceGroupPrepareEnded(const String &groupName)
This event is fired when a resource group finished preparing.
Definition: OgreResourceGroupManager.h:147
Ogre::ResourceGroupManager::LocationList
list< ResourceLocation * >::type LocationList
List of possible file locations.
Definition: OgreResourceGroupManager.h:294
Ogre::ResourceGroupManager::ResourceDeclaration::parameters
NameValuePairList parameters
Definition: OgreResourceGroupManager.h:279
Ogre::Singleton
Template class for creating single-instance global classes.
Definition: OgreSingleton.h:64
Ogre::Archive
Archive-handling class.
Definition: OgreArchive.h:88
Ogre::map
Definition: OgrePrerequisites.h:533
Ogre::ResourceGroupManager::ResourceDeclaration::loader
ManualResourceLoader * loader
Definition: OgreResourceGroupManager.h:278
Ogre::ResourceGroupListener::worldGeometryPrepareStageStarted
virtual void worldGeometryPrepareStageStarted(const String &description)
This event is fired when a stage of preparing linked world geometry is about to start.
Definition: OgreResourceGroupManager.h:138
Ogre::ResourceGroupManager::ResourceLocation::archive
Archive * archive
Pointer to the archive which is the destination.
Definition: OgreResourceGroupManager.h:289
Ogre::ResourceGroupListener::resourceRemove
virtual void resourceRemove(const ResourcePtr &resource)
This event is fired when a resource is about to be removed.
Definition: OgreResourceGroupManager.h:184
Ogre::SceneManager
Manages the organisation and rendering of a &#39;scene&#39; i.e.
Definition: OgreSceneManager.h:143
Ogre::ResourceGroupListener::resourcePrepareStarted
virtual void resourcePrepareStarted(const ResourcePtr &resource)
This event is fired when a declared resource is about to be prepared.
Definition: OgreResourceGroupManager.h:127
Ogre::ResourceGroupManager::mCurrentGroup
ResourceGroup * mCurrentGroup
Stored current group - optimisation for when bulk loading a group.
Definition: OgreResourceGroupManager.h:424
Ogre::StringUtil::BLANK
static const String BLANK
Constant blank string, useful for returning by ref where local does not exist.
Definition: OgreString.h:196
Ogre::ResourceGroupManager::ResourceLocation::recursive
bool recursive
Whether this location was added recursively.
Definition: OgreResourceGroupManager.h:291
Ogre::AllocatedObject
Superclass for all objects that wish to use custom memory allocators when their new / delete operator...
Definition: OgreMemoryAllocatedObject.h:58
Ogre::ResourceGroupManager::getWorldResourceGroupName
const String & getWorldResourceGroupName(void) const
Gets the resource group that &#39;world&#39; resources will use.
Definition: OgreResourceGroupManager.h:921
Ogre::ResourceLoadingListener
Definition: OgreResourceGroupManager.h:193
Ogre::ResourceGroupManager::ResourceLocationIndex
map< String, Archive * >::type ResourceLocationIndex
Resource index entry, resourcename->location.
Definition: OgreResourceGroupManager.h:310
Ogre::multimap
Definition: OgrePrerequisites.h:547

Copyright © 2012 Torus Knot Software Ltd
This work is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.