OgreMemoryAllocatorConfig.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 __MemoryAllocatorConfig_H__
#define __MemoryAllocatorConfig_H__
#include "OgreMemoryAllocatedObject.h"
#include "OgreHeaderPrefix.h"
namespace Ogre
{
enum MemoryCategory
{
MEMCATEGORY_GENERAL = 0,
MEMCATEGORY_GEOMETRY = 1,
MEMCATEGORY_ANIMATION = 2,
MEMCATEGORY_SCENE_CONTROL = 3,
MEMCATEGORY_SCENE_OBJECTS = 4,
MEMCATEGORY_RESOURCE = 5,
MEMCATEGORY_SCRIPTING = 6,
MEMCATEGORY_RENDERSYS = 7,
// sentinel value, do not use
MEMCATEGORY_COUNT = 8
};
}
#include "OgreMemoryAllocatedObject.h"
#include "OgreMemorySTLAllocator.h"
#if OGRE_MEMORY_ALLOCATOR == OGRE_MEMORY_ALLOCATOR_NEDPOOLING
# include "OgreMemoryNedPooling.h"
namespace Ogre
{
// configure default allocators based on the options above
// notice how we're not using the memory categories here but still roughing them out
// in your allocators you might choose to create different policies per category
// configurable category, for general malloc
// notice how we ignore the category here, you could specialise
template <MemoryCategory Cat> class CategorisedAllocPolicy : public NedPoolingPolicy{};
template <MemoryCategory Cat, size_t align = 0> class CategorisedAlignAllocPolicy : public NedPoolingAlignedPolicy<align>{};
}
#elif OGRE_MEMORY_ALLOCATOR == OGRE_MEMORY_ALLOCATOR_NED
# include "OgreMemoryNedAlloc.h"
namespace Ogre
{
// configure default allocators based on the options above
// notice how we're not using the memory categories here but still roughing them out
// in your allocators you might choose to create different policies per category
// configurable category, for general malloc
// notice how we ignore the category here, you could specialise
template <MemoryCategory Cat> class CategorisedAllocPolicy : public NedAllocPolicy{};
template <MemoryCategory Cat, size_t align = 0> class CategorisedAlignAllocPolicy : public NedAlignedAllocPolicy<align>{};
}
#elif OGRE_MEMORY_ALLOCATOR == OGRE_MEMORY_ALLOCATOR_STD
# include "OgreMemoryStdAlloc.h"
namespace Ogre
{
// configure default allocators based on the options above
// notice how we're not using the memory categories here but still roughing them out
// in your allocators you might choose to create different policies per category
// configurable category, for general malloc
// notice how we ignore the category here
template <MemoryCategory Cat> class CategorisedAllocPolicy : public StdAllocPolicy{};
template <MemoryCategory Cat, size_t align = 0> class CategorisedAlignAllocPolicy : public StdAlignedAllocPolicy<align>{};
// if you wanted to specialise the allocation per category, here's how it might work:
// template <> class CategorisedAllocPolicy<MEMCATEGORY_SCENE_OBJECTS> : public YourSceneObjectAllocPolicy{};
// template <size_t align> class CategorisedAlignAllocPolicy<MEMCATEGORY_SCENE_OBJECTS, align> : public YourSceneObjectAllocPolicy<align>{};
}
#else
// your allocators here?
#endif
namespace Ogre
{
// Useful shortcuts
typedef CategorisedAllocPolicy<Ogre::MEMCATEGORY_GENERAL> GeneralAllocPolicy;
typedef CategorisedAllocPolicy<Ogre::MEMCATEGORY_GEOMETRY> GeometryAllocPolicy;
typedef CategorisedAllocPolicy<Ogre::MEMCATEGORY_ANIMATION> AnimationAllocPolicy;
typedef CategorisedAllocPolicy<Ogre::MEMCATEGORY_SCENE_CONTROL> SceneCtlAllocPolicy;
typedef CategorisedAllocPolicy<Ogre::MEMCATEGORY_SCENE_OBJECTS> SceneObjAllocPolicy;
typedef CategorisedAllocPolicy<Ogre::MEMCATEGORY_RESOURCE> ResourceAllocPolicy;
typedef CategorisedAllocPolicy<Ogre::MEMCATEGORY_SCRIPTING> ScriptingAllocPolicy;
typedef CategorisedAllocPolicy<Ogre::MEMCATEGORY_RENDERSYS> RenderSysAllocPolicy;
// Now define all the base classes for each allocation
typedef AllocatedObject<GeneralAllocPolicy> GeneralAllocatedObject;
typedef AllocatedObject<GeometryAllocPolicy> GeometryAllocatedObject;
typedef AllocatedObject<AnimationAllocPolicy> AnimationAllocatedObject;
typedef AllocatedObject<SceneCtlAllocPolicy> SceneCtlAllocatedObject;
typedef AllocatedObject<SceneObjAllocPolicy> SceneObjAllocatedObject;
typedef AllocatedObject<ResourceAllocPolicy> ResourceAllocatedObject;
typedef AllocatedObject<ScriptingAllocPolicy> ScriptingAllocatedObject;
typedef AllocatedObject<RenderSysAllocPolicy> RenderSysAllocatedObject;
// Per-class allocators defined here
// NOTE: small, non-virtual classes should not subclass an allocator
// the virtual function table could double their size and make them less efficient
// use primitive or STL allocators / deallocators for those
typedef ScriptingAllocatedObject AbstractNodeAlloc;
typedef AnimationAllocatedObject AnimableAlloc;
typedef AnimationAllocatedObject AnimationAlloc;
typedef GeneralAllocatedObject ArchiveAlloc;
typedef GeometryAllocatedObject BatchedGeometryAlloc;
typedef RenderSysAllocatedObject BufferAlloc;
typedef GeneralAllocatedObject CodecAlloc;
typedef ResourceAllocatedObject CompositorInstAlloc;
typedef GeneralAllocatedObject ConfigAlloc;
typedef GeneralAllocatedObject ControllerAlloc;
typedef GeometryAllocatedObject DebugGeomAlloc;
typedef GeneralAllocatedObject DynLibAlloc;
typedef GeometryAllocatedObject EdgeDataAlloc;
typedef GeneralAllocatedObject FactoryAlloc;
typedef SceneObjAllocatedObject FXAlloc;
typedef GeneralAllocatedObject ImageAlloc;
typedef GeometryAllocatedObject IndexDataAlloc;
typedef GeneralAllocatedObject LogAlloc;
typedef SceneObjAllocatedObject MovableAlloc;
typedef SceneCtlAllocatedObject NodeAlloc;
typedef SceneObjAllocatedObject OverlayAlloc;
typedef RenderSysAllocatedObject GpuParamsAlloc;
typedef ResourceAllocatedObject PassAlloc;
typedef GeometryAllocatedObject PatchAlloc;
typedef GeneralAllocatedObject PluginAlloc;
typedef GeneralAllocatedObject ProfilerAlloc;
typedef GeometryAllocatedObject ProgMeshAlloc;
typedef SceneCtlAllocatedObject RenderQueueAlloc;
typedef RenderSysAllocatedObject RenderSysAlloc;
typedef GeneralAllocatedObject RootAlloc;
typedef ResourceAllocatedObject ResourceAlloc;
typedef GeneralAllocatedObject SerializerAlloc;
typedef SceneCtlAllocatedObject SceneMgtAlloc;
typedef ScriptingAllocatedObject ScriptCompilerAlloc;
typedef ScriptingAllocatedObject ScriptTranslatorAlloc;
typedef SceneCtlAllocatedObject ShadowDataAlloc;
typedef GeneralAllocatedObject StreamAlloc;
typedef SceneObjAllocatedObject SubEntityAlloc;
typedef ResourceAllocatedObject SubMeshAlloc;
typedef ResourceAllocatedObject TechniqueAlloc;
typedef GeneralAllocatedObject TimerAlloc;
typedef ResourceAllocatedObject TextureUnitStateAlloc;
typedef GeneralAllocatedObject UtilityAlloc;
typedef GeometryAllocatedObject VertexDataAlloc;
typedef RenderSysAllocatedObject ViewportAlloc;
typedef SceneCtlAllocatedObject LodAlloc;
typedef GeneralAllocatedObject FileSystemLayerAlloc;
// Containers (by-value only)
// Will be of the form:
// typedef STLAllocator<T, DefaultAllocPolicy, Category> TAlloc;
// for use in vector<T, TAlloc>::type
}
// Util functions
namespace Ogre
{
template<typename T>
T* constructN(T* basePtr, size_t count)
{
for (size_t i = 0; i < count; ++i)
{
new ((void*)(basePtr+i)) T();
}
return basePtr;
}
}
// define macros
#if OGRE_DEBUG_MODE
# define OGRE_MALLOC(bytes, category) ::Ogre::CategorisedAllocPolicy<category>::allocateBytes(bytes, __FILE__, __LINE__, __FUNCTION__)
# define OGRE_ALLOC_T(T, count, category) static_cast<T*>(::Ogre::CategorisedAllocPolicy<category>::allocateBytes(sizeof(T)*(count), __FILE__, __LINE__, __FUNCTION__))
# define OGRE_FREE(ptr, category) ::Ogre::CategorisedAllocPolicy<category>::deallocateBytes((void*)ptr)
# define OGRE_NEW_T(T, category) new (::Ogre::CategorisedAllocPolicy<category>::allocateBytes(sizeof(T), __FILE__, __LINE__, __FUNCTION__)) T
# define OGRE_NEW_ARRAY_T(T, count, category) ::Ogre::constructN(static_cast<T*>(::Ogre::CategorisedAllocPolicy<category>::allocateBytes(sizeof(T)*(count), __FILE__, __LINE__, __FUNCTION__)), count)
# define OGRE_DELETE_T(ptr, T, category) if(ptr){(ptr)->~T(); ::Ogre::CategorisedAllocPolicy<category>::deallocateBytes((void*)ptr);}
# define OGRE_DELETE_ARRAY_T(ptr, T, count, category) if(ptr){for (size_t b = 0; b < count; ++b) { (ptr)[b].~T();} ::Ogre::CategorisedAllocPolicy<category>::deallocateBytes((void*)ptr);}
// aligned allocation
# define OGRE_MALLOC_SIMD(bytes, category) ::Ogre::CategorisedAlignAllocPolicy<category>::allocateBytes(bytes, __FILE__, __LINE__, __FUNCTION__)
# define OGRE_MALLOC_ALIGN(bytes, category, align) ::Ogre::CategorisedAlignAllocPolicy<category, align>::allocateBytes(bytes, __FILE__, __LINE__, __FUNCTION__)
# define OGRE_ALLOC_T_SIMD(T, count, category) static_cast<T*>(::Ogre::CategorisedAlignAllocPolicy<category>::allocateBytes(sizeof(T)*(count), __FILE__, __LINE__, __FUNCTION__))
# define OGRE_ALLOC_T_ALIGN(T, count, category, align) static_cast<T*>(::Ogre::CategorisedAlignAllocPolicy<category, align>::allocateBytes(sizeof(T)*(count), __FILE__, __LINE__, __FUNCTION__))
# define OGRE_FREE_SIMD(ptr, category) ::Ogre::CategorisedAlignAllocPolicy<category>::deallocateBytes(ptr)
# define OGRE_FREE_ALIGN(ptr, category, align) ::Ogre::CategorisedAlignAllocPolicy<category, align>::deallocateBytes(ptr)
# define OGRE_NEW_T_SIMD(T, category) new (::Ogre::CategorisedAlignAllocPolicy<category>::allocateBytes(sizeof(T), __FILE__, __LINE__, __FUNCTION__)) T
# define OGRE_NEW_ARRAY_T_SIMD(T, count, category) ::Ogre::constructN(static_cast<T*>(::Ogre::CategorisedAlignAllocPolicy<category>::allocateBytes(sizeof(T)*(count), __FILE__, __LINE__, __FUNCTION__)), count)
# define OGRE_DELETE_T_SIMD(ptr, T, category) if(ptr){(ptr)->~T(); ::Ogre::CategorisedAlignAllocPolicy<category>::deallocateBytes(ptr);}
# define OGRE_DELETE_ARRAY_T_SIMD(ptr, T, count, category) if(ptr){for (size_t b = 0; b < count; ++b) { (ptr)[b].~T();} ::Ogre::CategorisedAlignAllocPolicy<category>::deallocateBytes(ptr);}
# define OGRE_NEW_T_ALIGN(T, category, align) new (::Ogre::CategorisedAlignAllocPolicy<category, align>::allocateBytes(sizeof(T), __FILE__, __LINE__, __FUNCTION__)) T
# define OGRE_NEW_ARRAY_T_ALIGN(T, count, category, align) ::Ogre::constructN(static_cast<T*>(::Ogre::CategorisedAlignAllocPolicy<category, align>::allocateBytes(sizeof(T)*(count), __FILE__, __LINE__, __FUNCTION__)), count)
# define OGRE_DELETE_T_ALIGN(ptr, T, category, align) if(ptr){(ptr)->~T(); ::Ogre::CategorisedAlignAllocPolicy<category, align>::deallocateBytes(ptr);}
# define OGRE_DELETE_ARRAY_T_ALIGN(ptr, T, count, category, align) if(ptr){for (size_t _b = 0; _b < count; ++_b) { (ptr)[_b].~T();} ::Ogre::CategorisedAlignAllocPolicy<category, align>::deallocateBytes(ptr);}
// new / delete for classes deriving from AllocatedObject (alignment determined by per-class policy)
// Also hooks up the file/line/function params
// Can only be used with classes that derive from AllocatedObject since customised new/delete needed
# define OGRE_NEW new (__FILE__, __LINE__, __FUNCTION__)
# define OGRE_DELETE delete
#else // !OGRE_DEBUG_MODE
# define OGRE_MALLOC(bytes, category) ::Ogre::CategorisedAllocPolicy<category>::allocateBytes(bytes)
# define OGRE_ALLOC_T(T, count, category) static_cast<T*>(::Ogre::CategorisedAllocPolicy<category>::allocateBytes(sizeof(T)*(count)))
# define OGRE_FREE(ptr, category) ::Ogre::CategorisedAllocPolicy<category>::deallocateBytes((void*)ptr)
# define OGRE_NEW_T(T, category) new (::Ogre::CategorisedAllocPolicy<category>::allocateBytes(sizeof(T))) T
# define OGRE_NEW_ARRAY_T(T, count, category) ::Ogre::constructN(static_cast<T*>(::Ogre::CategorisedAllocPolicy<category>::allocateBytes(sizeof(T)*(count))), count)
# define OGRE_DELETE_T(ptr, T, category) if(ptr){(ptr)->~T(); ::Ogre::CategorisedAllocPolicy<category>::deallocateBytes((void*)ptr);}
# define OGRE_DELETE_ARRAY_T(ptr, T, count, category) if(ptr){for (size_t b = 0; b < count; ++b) { (ptr)[b].~T();} ::Ogre::CategorisedAllocPolicy<category>::deallocateBytes((void*)ptr);}
// aligned allocation
# define OGRE_MALLOC_SIMD(bytes, category) ::Ogre::CategorisedAlignAllocPolicy<category>::allocateBytes(bytes)
# define OGRE_MALLOC_ALIGN(bytes, category, align) ::Ogre::CategorisedAlignAllocPolicy<category, align>::allocateBytes(bytes)
# define OGRE_ALLOC_T_SIMD(T, count, category) static_cast<T*>(::Ogre::CategorisedAlignAllocPolicy<category>::allocateBytes(sizeof(T)*(count)))
# define OGRE_ALLOC_T_ALIGN(T, count, category, align) static_cast<T*>(::Ogre::CategorisedAlignAllocPolicy<category, align>::allocateBytes(sizeof(T)*(count)))
# define OGRE_FREE_SIMD(ptr, category) ::Ogre::CategorisedAlignAllocPolicy<category>::deallocateBytes((void*)ptr)
# define OGRE_FREE_ALIGN(ptr, category, align) ::Ogre::CategorisedAlignAllocPolicy<category, align>::deallocateBytes((void*)ptr)
# define OGRE_NEW_T_SIMD(T, category) new (::Ogre::CategorisedAlignAllocPolicy<category>::allocateBytes(sizeof(T))) T
# define OGRE_NEW_ARRAY_T_SIMD(T, count, category) ::Ogre::constructN(static_cast<T*>(::Ogre::CategorisedAlignAllocPolicy<category>::allocateBytes(sizeof(T)*(count))), count)
# define OGRE_DELETE_T_SIMD(ptr, T, category) if(ptr){(ptr)->~T(); ::Ogre::CategorisedAlignAllocPolicy<category>::deallocateBytes((void*)ptr);}
# define OGRE_DELETE_ARRAY_T_SIMD(ptr, T, count, category) if(ptr){for (size_t b = 0; b < count; ++b) { (ptr)[b].~T();} ::Ogre::CategorisedAlignAllocPolicy<category>::deallocateBytes((void*)ptr);}
# define OGRE_NEW_T_ALIGN(T, category, align) new (::Ogre::CategorisedAlignAllocPolicy<category, align>::allocateBytes(sizeof(T))) T
# define OGRE_NEW_ARRAY_T_ALIGN(T, count, category, align) ::Ogre::constructN(static_cast<T*>(::Ogre::CategorisedAlignAllocPolicy<category, align>::allocateBytes(sizeof(T)*(count))), count)
# define OGRE_DELETE_T_ALIGN(ptr, T, category, align) if(ptr){(ptr)->~T(); ::Ogre::CategorisedAlignAllocPolicy<category, align>::deallocateBytes((void*)ptr);}
# define OGRE_DELETE_ARRAY_T_ALIGN(ptr, T, count, category, align) if(ptr){for (size_t _b = 0; _b < count; ++_b) { (ptr)[_b].~T();} ::Ogre::CategorisedAlignAllocPolicy<category, align>::deallocateBytes((void*)ptr);}
// new / delete for classes deriving from AllocatedObject (alignment determined by per-class policy)
# define OGRE_NEW new
# define OGRE_DELETE delete
#endif // OGRE_DEBUG_MODE
namespace Ogre
{
template<typename T>
void deletePtr(T* ptr)
{
OGRE_DELETE ptr;
}
}
#include "OgreHeaderSuffix.h"
#endif
Ogre::MEMCATEGORY_SCRIPTING
Scripting.
Definition: OgreMemoryAllocatorConfig.h:174
Ogre::RootAlloc
GeneralAllocatedObject RootAlloc
Definition: OgreMemoryAllocatorConfig.h:303
Ogre::AnimableAlloc
AnimationAllocatedObject AnimableAlloc
Definition: OgreMemoryAllocatorConfig.h:275
Ogre::ProfilerAlloc
GeneralAllocatedObject ProfilerAlloc
Definition: OgreMemoryAllocatorConfig.h:299
Ogre::ResourceAllocPolicy
CategorisedAllocPolicy< Ogre::MEMCATEGORY_RESOURCE > ResourceAllocPolicy
Definition: OgreMemoryAllocatorConfig.h:255
Ogre::BufferAlloc
RenderSysAllocatedObject BufferAlloc
Definition: OgreMemoryAllocatorConfig.h:279
Ogre::GeometryAllocatedObject
AllocatedObject< GeometryAllocPolicy > GeometryAllocatedObject
Definition: OgreMemoryAllocatorConfig.h:261
OGRE_DELETE
#define OGRE_DELETE
Definition: OgreMemoryAllocatorConfig.h:474
Ogre::GeneralAllocatedObject
AllocatedObject< GeneralAllocPolicy > GeneralAllocatedObject
Definition: OgreMemoryAllocatorConfig.h:260
Ogre::CategorisedAlignAllocPolicy
Definition: OgreMemoryAllocatorConfig.h:202
Ogre::SceneMgtAlloc
SceneCtlAllocatedObject SceneMgtAlloc
Definition: OgreMemoryAllocatorConfig.h:306
Ogre::RenderSysAllocPolicy
CategorisedAllocPolicy< Ogre::MEMCATEGORY_RENDERSYS > RenderSysAllocPolicy
Definition: OgreMemoryAllocatorConfig.h:257
Ogre::MEMCATEGORY_SCENE_CONTROL
Nodes, control data.
Definition: OgreMemoryAllocatorConfig.h:168
Ogre::ControllerAlloc
GeneralAllocatedObject ControllerAlloc
Definition: OgreMemoryAllocatorConfig.h:283
Ogre::FileSystemLayerAlloc
GeneralAllocatedObject FileSystemLayerAlloc
Definition: OgreMemoryAllocatorConfig.h:320
Ogre::PassAlloc
ResourceAllocatedObject PassAlloc
Definition: OgreMemoryAllocatorConfig.h:296
Ogre::AnimationAllocPolicy
CategorisedAllocPolicy< Ogre::MEMCATEGORY_ANIMATION > AnimationAllocPolicy
Definition: OgreMemoryAllocatorConfig.h:252
Ogre::StdAllocPolicy
A "standard" allocation policy for use with AllocatedObject and STLAllocator.
Definition: OgreMemoryStdAlloc.h:56
Ogre::ImageAlloc
GeneralAllocatedObject ImageAlloc
Definition: OgreMemoryAllocatorConfig.h:289
Ogre::ShadowDataAlloc
SceneCtlAllocatedObject ShadowDataAlloc
Definition: OgreMemoryAllocatorConfig.h:309
Ogre::AbstractNodeAlloc
ScriptingAllocatedObject AbstractNodeAlloc
Definition: OgreMemoryAllocatorConfig.h:274
Ogre::GpuParamsAlloc
RenderSysAllocatedObject GpuParamsAlloc
Definition: OgreMemoryAllocatorConfig.h:295
Ogre::BatchedGeometryAlloc
GeometryAllocatedObject BatchedGeometryAlloc
Definition: OgreMemoryAllocatorConfig.h:278
Ogre::SubMeshAlloc
ResourceAllocatedObject SubMeshAlloc
Definition: OgreMemoryAllocatorConfig.h:312
Ogre::RenderSysAllocatedObject
AllocatedObject< RenderSysAllocPolicy > RenderSysAllocatedObject
Definition: OgreMemoryAllocatorConfig.h:267
Ogre::RenderSysAlloc
RenderSysAllocatedObject RenderSysAlloc
Definition: OgreMemoryAllocatorConfig.h:302
Ogre::AnimationAlloc
AnimationAllocatedObject AnimationAlloc
Definition: OgreMemoryAllocatorConfig.h:276
Ogre::MEMCATEGORY_GEOMETRY
Geometry held in main memory.
Definition: OgreMemoryAllocatorConfig.h:164
Ogre::MEMCATEGORY_RENDERSYS
Rendersystem structures.
Definition: OgreMemoryAllocatorConfig.h:176
Ogre::NedPoolingPolicy
An allocation policy for use with AllocatedObject and STLAllocator.
Definition: OgreMemoryNedPooling.h:67
Ogre::ScriptTranslatorAlloc
ScriptingAllocatedObject ScriptTranslatorAlloc
Definition: OgreMemoryAllocatorConfig.h:308
Ogre::ScriptingAllocatedObject
AllocatedObject< ScriptingAllocPolicy > ScriptingAllocatedObject
Definition: OgreMemoryAllocatorConfig.h:266
Ogre::VertexDataAlloc
GeometryAllocatedObject VertexDataAlloc
Definition: OgreMemoryAllocatorConfig.h:317
Ogre::FXAlloc
SceneObjAllocatedObject FXAlloc
Definition: OgreMemoryAllocatorConfig.h:288
Ogre::ResourceAllocatedObject
AllocatedObject< ResourceAllocPolicy > ResourceAllocatedObject
Definition: OgreMemoryAllocatorConfig.h:265
Ogre::ResourceAlloc
ResourceAllocatedObject ResourceAlloc
Definition: OgreMemoryAllocatorConfig.h:304
Ogre::SceneCtlAllocPolicy
CategorisedAllocPolicy< Ogre::MEMCATEGORY_SCENE_CONTROL > SceneCtlAllocPolicy
Definition: OgreMemoryAllocatorConfig.h:253
Ogre::MEMCATEGORY_ANIMATION
Animation data like tracks, bone matrices.
Definition: OgreMemoryAllocatorConfig.h:166
Ogre::TimerAlloc
GeneralAllocatedObject TimerAlloc
Definition: OgreMemoryAllocatorConfig.h:314
Ogre::PatchAlloc
GeometryAllocatedObject PatchAlloc
Definition: OgreMemoryAllocatorConfig.h:297
Ogre::SerializerAlloc
GeneralAllocatedObject SerializerAlloc
Definition: OgreMemoryAllocatorConfig.h:305
OgreMemoryNedPooling.h
Ogre::IndexDataAlloc
GeometryAllocatedObject IndexDataAlloc
Definition: OgreMemoryAllocatorConfig.h:290
Ogre::GeneralAllocPolicy
CategorisedAllocPolicy< Ogre::MEMCATEGORY_GENERAL > GeneralAllocPolicy
Definition: OgreMemoryAllocatorConfig.h:250
Ogre::TechniqueAlloc
ResourceAllocatedObject TechniqueAlloc
Definition: OgreMemoryAllocatorConfig.h:313
OgreMemoryAllocatedObject.h
Ogre::CodecAlloc
GeneralAllocatedObject CodecAlloc
Definition: OgreMemoryAllocatorConfig.h:280
Ogre::MEMCATEGORY_GENERAL
General purpose.
Definition: OgreMemoryAllocatorConfig.h:162
Ogre::NedAlignedAllocPolicy
An allocation policy for use with AllocatedObject and STLAllocator, which aligns memory at a given bo...
Definition: OgreMemoryNedAlloc.h:103
Ogre::ConfigAlloc
GeneralAllocatedObject ConfigAlloc
Definition: OgreMemoryAllocatorConfig.h:282
Ogre::ViewportAlloc
RenderSysAllocatedObject ViewportAlloc
Definition: OgreMemoryAllocatorConfig.h:318
OgreMemorySTLAllocator.h
Ogre::ProgMeshAlloc
GeometryAllocatedObject ProgMeshAlloc
Definition: OgreMemoryAllocatorConfig.h:300
Ogre::ScriptingAllocPolicy
CategorisedAllocPolicy< Ogre::MEMCATEGORY_SCRIPTING > ScriptingAllocPolicy
Definition: OgreMemoryAllocatorConfig.h:256
Ogre::SubEntityAlloc
SceneObjAllocatedObject SubEntityAlloc
Definition: OgreMemoryAllocatorConfig.h:311
Ogre::MovableAlloc
SceneObjAllocatedObject MovableAlloc
Definition: OgreMemoryAllocatorConfig.h:292
Ogre::DebugGeomAlloc
GeometryAllocatedObject DebugGeomAlloc
Definition: OgreMemoryAllocatorConfig.h:284
Ogre::SceneObjAllocatedObject
AllocatedObject< SceneObjAllocPolicy > SceneObjAllocatedObject
Definition: OgreMemoryAllocatorConfig.h:264
Ogre::NedAllocPolicy
An allocation policy for use with AllocatedObject and STLAllocator.
Definition: OgreMemoryNedAlloc.h:66
Ogre::EdgeDataAlloc
GeometryAllocatedObject EdgeDataAlloc
Definition: OgreMemoryAllocatorConfig.h:286
Ogre::FactoryAlloc
GeneralAllocatedObject FactoryAlloc
Definition: OgreMemoryAllocatorConfig.h:287
Ogre::constructN
T * constructN(T *basePtr, size_t count)
Utility function for constructing an array of objects with placement new, without using new[] (which ...
Definition: OgreMemoryAllocatorConfig.h:346
Ogre::TextureUnitStateAlloc
ResourceAllocatedObject TextureUnitStateAlloc
Definition: OgreMemoryAllocatorConfig.h:315
Ogre::ScriptCompilerAlloc
ScriptingAllocatedObject ScriptCompilerAlloc
Definition: OgreMemoryAllocatorConfig.h:307
OgreHeaderSuffix.h
OgreMemoryNedAlloc.h
Ogre::MEMCATEGORY_COUNT
Definition: OgreMemoryAllocatorConfig.h:180
Ogre::SceneObjAllocPolicy
CategorisedAllocPolicy< Ogre::MEMCATEGORY_SCENE_OBJECTS > SceneObjAllocPolicy
Definition: OgreMemoryAllocatorConfig.h:254
Ogre::ArchiveAlloc
GeneralAllocatedObject ArchiveAlloc
Definition: OgreMemoryAllocatorConfig.h:277
Ogre
Definition: OgreAndroidLogListener.h:34
Ogre::MemoryCategory
MemoryCategory
A set of categories that indicate the purpose of a chunk of memory being allocated.
Definition: OgreMemoryAllocatorConfig.h:159
Ogre::deletePtr
void deletePtr(T *ptr)
Function which invokes OGRE_DELETE on a given pointer.
Definition: OgreMemoryAllocatorConfig.h:486
Ogre::DynLibAlloc
GeneralAllocatedObject DynLibAlloc
Definition: OgreMemoryAllocatorConfig.h:285
OgreHeaderPrefix.h
Ogre::UtilityAlloc
GeneralAllocatedObject UtilityAlloc
Definition: OgreMemoryAllocatorConfig.h:316
Ogre::CompositorInstAlloc
ResourceAllocatedObject CompositorInstAlloc
Definition: OgreMemoryAllocatorConfig.h:281
Ogre::LodAlloc
SceneCtlAllocatedObject LodAlloc
Definition: OgreMemoryAllocatorConfig.h:319
Ogre::SceneCtlAllocatedObject
AllocatedObject< SceneCtlAllocPolicy > SceneCtlAllocatedObject
Definition: OgreMemoryAllocatorConfig.h:263
Ogre::RenderQueueAlloc
SceneCtlAllocatedObject RenderQueueAlloc
Definition: OgreMemoryAllocatorConfig.h:301
Ogre::StreamAlloc
GeneralAllocatedObject StreamAlloc
Definition: OgreMemoryAllocatorConfig.h:310
Ogre::CategorisedAllocPolicy
Definition: OgreMemoryAllocatorConfig.h:201
Ogre::MEMCATEGORY_SCENE_OBJECTS
Scene object instances.
Definition: OgreMemoryAllocatorConfig.h:170
Ogre::AnimationAllocatedObject
AllocatedObject< AnimationAllocPolicy > AnimationAllocatedObject
Definition: OgreMemoryAllocatorConfig.h:262
Ogre::LogAlloc
GeneralAllocatedObject LogAlloc
Definition: OgreMemoryAllocatorConfig.h:291
Ogre::OverlayAlloc
SceneObjAllocatedObject OverlayAlloc
Definition: OgreMemoryAllocatorConfig.h:294
Ogre::NodeAlloc
SceneCtlAllocatedObject NodeAlloc
Definition: OgreMemoryAllocatorConfig.h:293
Ogre::StdAlignedAllocPolicy
A "standard" allocation policy for use with AllocatedObject and STLAllocator, which aligns memory at ...
Definition: OgreMemoryStdAlloc.h:107
Ogre::GeometryAllocPolicy
CategorisedAllocPolicy< Ogre::MEMCATEGORY_GEOMETRY > GeometryAllocPolicy
Definition: OgreMemoryAllocatorConfig.h:251
Ogre::PluginAlloc
GeneralAllocatedObject PluginAlloc
Definition: OgreMemoryAllocatorConfig.h:298
Ogre::AllocatedObject
Superclass for all objects that wish to use custom memory allocators when their new / delete operator...
Definition: OgreMemoryAllocatedObject.h:58
Ogre::MEMCATEGORY_RESOURCE
Other resources.
Definition: OgreMemoryAllocatorConfig.h:172
Ogre::NedPoolingAlignedPolicy
An allocation policy for use with AllocatedObject and STLAllocator, which aligns memory at a given bo...
Definition: OgreMemoryNedPooling.h:105
OgreMemoryStdAlloc.h

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