OGRE  1.9.0
OgreResourceManager.h
Go to the documentation of this file.
1/*
2-----------------------------------------------------------------------------
3This source file is part of OGRE
4 (Object-oriented Graphics Rendering Engine)
5For the latest info, see http://www.ogre3d.org/
6
7Copyright (c) 2000-2014 Torus Knot Software Ltd
8
9Permission is hereby granted, free of charge, to any person obtaining a copy
10of this software and associated documentation files (the "Software"), to deal
11in the Software without restriction, including without limitation the rights
12to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
13copies of the Software, and to permit persons to whom the Software is
14furnished to do so, subject to the following conditions:
15
16The above copyright notice and this permission notice shall be included in
17all copies or substantial portions of the Software.
18
19THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
22AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25THE SOFTWARE.
26-----------------------------------------------------------------------------
27*/
28#ifndef _ResourceManager_H__
29#define _ResourceManager_H__
30
31#include "OgrePrerequisites.h"
32
33#include "OgreResource.h"
36#include "OgreCommon.h"
37#include "OgreDataStream.h"
38#include "OgreStringVector.h"
39#include "OgreScriptLoader.h"
40#include "OgreHeaderPrefix.h"
41
42namespace Ogre {
43
46 template <typename T>
47 class Pool
48 {
49 protected:
50 typedef typename list<T>::type ItemList;
53 public:
54 Pool() {}
55 virtual ~Pool() {}
56
60 virtual std::pair<bool, T> removeItem()
61 {
63 std::pair<bool, T> ret;
64 if (mItems.empty())
65 {
66 ret.first = false;
67 }
68 else
69 {
70 ret.first = true;
71 ret.second = mItems.front();
72 mItems.pop_front();
73 }
74 return ret;
75 }
76
79 virtual void addItem(const T& i)
80 {
82 mItems.push_front(i);
83 }
85 virtual void clear()
86 {
88 mItems.clear();
89 }
90 };
91
123 {
124 public:
125 OGRE_AUTO_MUTEX; // public to allow external locking
128
148 virtual ResourcePtr createResource(const String& name, const String& group,
149 bool isManual = false, ManualResourceLoader* loader = 0,
150 const NameValuePairList* createParams = 0);
151
152 typedef std::pair<ResourcePtr, bool> ResourceCreateOrRetrieveResult;
167 const String& group, bool isManual = false,
168 ManualResourceLoader* loader = 0,
169 const NameValuePairList* createParams = 0);
170
178 virtual void setMemoryBudget(size_t bytes);
179
182 virtual size_t getMemoryBudget(void) const;
183
185 virtual size_t getMemoryUsage(void) const { return mMemoryUsage.get(); }
186
193 virtual void unload(const String& name);
194
201 virtual void unload(ResourceHandle handle);
202
215 virtual void unloadAll(bool reloadableOnly = true);
216
228 virtual void reloadAll(bool reloadableOnly = true);
229
244 virtual void unloadUnreferencedResources(bool reloadableOnly = true);
245
259 virtual void reloadUnreferencedResources(bool reloadableOnly = true);
260
278 virtual void remove(ResourcePtr& r);
279
297 virtual void remove(const String& name);
298
316 virtual void remove(ResourceHandle handle);
331 virtual void removeAll(void);
332
347 virtual void removeUnreferencedResources(bool reloadableOnly = true);
348
351 virtual ResourcePtr getResourceByName(const String& name, const String& groupName = ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME);
355
357 virtual bool resourceExists(const String& name)
358 {
359 return !getResourceByName(name).isNull();
360 }
362 virtual bool resourceExists(ResourceHandle handle)
363 {
364 return !getByHandle(handle).isNull();
365 }
366
371
375 virtual void _notifyResourceLoaded(Resource* res);
376
381
397 virtual ResourcePtr prepare(const String& name,
398 const String& group, bool isManual = false,
399 ManualResourceLoader* loader = 0, const NameValuePairList* loadParams = 0,
400 bool backgroundThread = false);
401
417 virtual ResourcePtr load(const String& name,
418 const String& group, bool isManual = false,
419 ManualResourceLoader* loader = 0, const NameValuePairList* loadParams = 0,
420 bool backgroundThread = false);
421
437 virtual const StringVector& getScriptPatterns(void) const { return mScriptPatterns; }
438
452 virtual void parseScript(DataStreamPtr& stream, const String& groupName)
453 { (void)stream; (void)groupName; }
454
461 virtual Real getLoadingOrder(void) const { return mLoadOrder; }
462
464 const String& getResourceType(void) const { return mResourceType; }
465
467 virtual void setVerbose(bool v) { mVerbose = v; }
468
470 virtual bool getVerbose(void) { return mVerbose; }
471
478 class _OgreExport ResourcePool : public Pool<ResourcePtr>, public ResourceAlloc
479 {
480 protected:
482 public:
483 ResourcePool(const String& name);
486 const String& getName() const;
487 void clear();
488 };
489
495 void destroyResourcePool(const String& name);
498
499
500
501
502 protected:
503
506
528 virtual Resource* createImpl(const String& name, ResourceHandle handle,
529 const String& group, bool isManual, ManualResourceLoader* loader,
530 const NameValuePairList* createParams) = 0;
532 virtual void addImpl( ResourcePtr& res );
534 virtual void removeImpl( ResourcePtr& res );
537 virtual void checkUsage(void);
538
539
540 public:
541 typedef HashMap< String, ResourcePtr > ResourceMap;
542 typedef HashMap< String, ResourceMap > ResourceWithGroupMap;
544 protected:
551
553
554 // IMPORTANT - all subclasses must populate the fields below
555
562
563 public:
570 {
571 return ResourceMapIterator(mResourcesByHandle.begin(), mResourcesByHandle.end());
572 }
573
574 protected:
577 };
578
582}
583
584#include "OgreHeaderSuffix.h"
585
586#endif
#define _OgreExport
#define OGRE_LOCK_AUTO_MUTEX
Superclass for all objects that wish to use custom memory allocators when their new / delete operator...
Interface describing a manual resource loader.
Concrete IteratorWrapper for nonconst access to the underlying key-value container.
Template class describing a simple pool of items.
list< T >::type ItemList
virtual std::pair< bool, T > removeItem()
Get the next item from the pool.
virtual void addItem(const T &i)
Add a new item to the pool.
virtual void clear()
Clear the pool.
Definition of a pool of resources, which users can use to reuse similar resources many times without ...
const String & getName() const
Get the name of the pool.
Defines a generic resource handler.
void destroyResourcePool(const String &name)
Destroy a resource pool.
virtual void addImpl(ResourcePtr &res)
Add a newly created resource to the manager (note weak reference)
virtual const StringVector & getScriptPatterns(void) const
Gets the file patterns which should be used to find scripts for this ResourceManager.
ResourcePoolMap mResourcePoolMap
ResourcePool * getResourcePool(const String &name)
Create a resource pool, or reuse one that already exists.
virtual void reloadUnreferencedResources(bool reloadableOnly=true)
Caused all currently loaded but not referenced by any other object resources to be reloaded.
map< ResourceHandle, ResourcePtr >::type ResourceHandleMap
virtual ~ResourceManager()
virtual void unload(const String &name)
Unloads a single resource by name.
AtomicScalar< ResourceHandle > mNextHandle
In bytes.
ResourceWithGroupMap mResourcesWithGroup
virtual void _notifyResourceTouched(Resource *res)
Notify this manager that a resource which it manages has been 'touched', i.e.
virtual Real getLoadingOrder(void) const
Gets the relative loading order of resources of this type.
StringVector mScriptPatterns
Patterns to use to look for scripts if supported (e.g. *.overlay)
virtual ResourceCreateOrRetrieveResult createOrRetrieve(const String &name, const String &group, bool isManual=false, ManualResourceLoader *loader=0, const NameValuePairList *createParams=0)
Create a new resource, or retrieve an existing one with the same name if it already exists.
ResourceMapIterator getResourceIterator(void)
Returns an iterator over all resources in this manager.
MapIterator< ResourceHandleMap > ResourceMapIterator
virtual void _notifyResourceUnloaded(Resource *res)
Notify this manager that a resource which it manages has been unloaded.
const String & getResourceType(void) const
Gets a string identifying the type of resource this manager handles.
HashMap< String, ResourcePtr > ResourceMap
virtual ResourcePtr getResourceByName(const String &name, const String &groupName=ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME)
Retrieves a pointer to a resource by name, or null if the resource does not exist.
virtual void removeUnreferencedResources(bool reloadableOnly=true)
Remove all resources which are not referenced by any other object.
virtual void removeAll(void)
Removes all resources.
void destroyAllResourcePools()
destroy all pools
virtual void unloadUnreferencedResources(bool reloadableOnly=true)
Unload all resources which are not referenced by any other object.
virtual Resource * createImpl(const String &name, ResourceHandle handle, const String &group, bool isManual, ManualResourceLoader *loader, const NameValuePairList *createParams)=0
Create a new resource instance compatible with this manager (no custom parameters are populated at th...
virtual void removeImpl(ResourcePtr &res)
Remove a resource from this manager; remove it from the lists.
virtual void parseScript(DataStreamPtr &stream, const String &groupName)
Parse the definition of a set of resources from a script file.
virtual void checkUsage(void)
Checks memory usage and pages out if required.
virtual void reloadAll(bool reloadableOnly=true)
Caused all currently loaded resources to be reloaded.
virtual void remove(ResourcePtr &r)
Remove a single resource.
String mResourceType
String identifying the resource type this manager handles.
virtual void unload(ResourceHandle handle)
Unloads a single resource by handle.
virtual bool resourceExists(const String &name)
Returns whether the named resource exists in this manager.
virtual size_t getMemoryUsage(void) const
Gets the current memory usage, in bytes.
virtual void setVerbose(bool v)
Sets whether this manager and its resources habitually produce log output.
virtual void setMemoryBudget(size_t bytes)
Set a limit on the amount of memory this resource handler may use.
void destroyResourcePool(ResourcePool *pool)
Destroy a resource pool.
AtomicScalar< size_t > mMemoryUsage
virtual ResourcePtr getByHandle(ResourceHandle handle)
Retrieves a pointer to a resource by handle, or null if the resource does not exist.
virtual void remove(const String &name)
Remove a single resource by name.
virtual void remove(ResourceHandle handle)
Remove a single resource by handle.
virtual size_t getMemoryBudget(void) const
Get the limit on the amount of memory this resource handler may use.
virtual void unloadAll(bool reloadableOnly=true)
Unloads all resources.
virtual ResourcePtr createResource(const String &name, const String &group, bool isManual=false, ManualResourceLoader *loader=0, const NameValuePairList *createParams=0)
Creates a new blank resource, but does not immediately load it.
Real mLoadOrder
Loading order relative to other managers, higher is later.
virtual ResourcePtr load(const String &name, const String &group, bool isManual=false, ManualResourceLoader *loader=0, const NameValuePairList *loadParams=0, bool backgroundThread=false)
Generic load method, used to create a Resource specific to this ResourceManager without using one of ...
virtual bool resourceExists(ResourceHandle handle)
Returns whether a resource with the given handle exists in this manager.
ResourceHandle getNextHandle(void)
Allocates the next handle.
virtual ResourcePtr prepare(const String &name, const String &group, bool isManual=false, ManualResourceLoader *loader=0, const NameValuePairList *loadParams=0, bool backgroundThread=false)
Generic prepare method, used to create a Resource specific to this ResourceManager without using one ...
HashMap< String, ResourceMap > ResourceWithGroupMap
virtual void _notifyResourceLoaded(Resource *res)
Notify this manager that a resource which it manages has been loaded.
std::pair< ResourcePtr, bool > ResourceCreateOrRetrieveResult
ResourceHandleMap mResourcesByHandle
virtual bool getVerbose(void)
Gets whether this manager and its resources habitually produce log output.
map< String, ResourcePool * >::type ResourcePoolMap
Abstract class representing a loadable resource (e.g.
Abstract class defining the interface used by classes which wish to perform script loading to define ...
vector< String >::type StringVector
map< String, String >::type NameValuePairList
Name / value parameter pair (first = name, second = value)
Definition OgreCommon.h:550
float Real
Software floating point type.
unsigned long long int ResourceHandle
_StringBase String
std::list< T, A > type
std::map< K, V, P, A > type