OgreMemoryAllocatorConfig.h File Reference

This file configures Ogre's memory allocators. More...

#include "OgrePrerequisites.h"
#include "OgreMemoryAllocatedObject.h"
#include "OgreMemorySTLAllocator.h"
#include "OgreMemoryStdAlloc.h"

Go to the source code of this file.

Namespaces

namespace  Ogre

Classes

class  Ogre::CategorisedAllocPolicy< Cat >
class  Ogre::CategorisedAlignAllocPolicy< Cat, align >

Defines

#define OGRE_MALLOC(bytes, category)   ::Ogre::CategorisedAllocPolicy<category>::allocateBytes(bytes)
 Allocate a block of raw memory, and indicate the category of usage.
#define OGRE_ALLOC_T(T, count, category)   static_cast<T*>(::Ogre::CategorisedAllocPolicy<category>::allocateBytes(sizeof(T)*(count)))
 Allocate a block of memory for a primitive type, and indicate the category of usage.
#define OGRE_FREE(ptr, category)   ::Ogre::CategorisedAllocPolicy<category>::deallocateBytes(ptr)
 Free the memory allocated with OGRE_MALLOC or OGRE_ALLOC_T. Category is required to be restated to ensure the matching policy is used.
#define OGRE_NEW_T(T, category)   new (::Ogre::CategorisedAllocPolicy<category>::allocateBytes(sizeof(T))) T
 Allocate space for one primitive type, external type or non-virtual type with constructor parameters.
#define OGRE_NEW_ARRAY_T(T, count, category)   ::Ogre::constructN(static_cast<T*>(::Ogre::CategorisedAllocPolicy<category>::allocateBytes(sizeof(T)*(count))), count)
 Allocate a block of memory for 'count' primitive types - do not use for classes that inherit from AllocatedObject.
#define OGRE_DELETE_T(ptr, T, category)   if(ptr){(ptr)->~T(); ::Ogre::CategorisedAllocPolicy<category>::deallocateBytes(ptr);}
 Free the memory allocated with OGRE_NEW_T. Category is required to be restated to ensure the matching policy is used.
#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(ptr);}
 Free the memory allocated with OGRE_NEW_ARRAY_T. Category is required to be restated to ensure the matching policy is used, count and type to call destructor.
#define OGRE_MALLOC_SIMD(bytes, category)   ::Ogre::CategorisedAlignAllocPolicy<category>::allocateBytes(bytes)
 Allocate a block of raw memory aligned to SIMD boundaries, and indicate the category of usage.
#define OGRE_MALLOC_ALIGN(bytes, category, align)   ::Ogre::CategorisedAlignAllocPolicy<category, align>::allocateBytes(bytes)
 Allocate a block of raw memory aligned to user defined boundaries, and indicate the category of usage.
#define OGRE_ALLOC_T_SIMD(T, count, category)   static_cast<T*>(::Ogre::CategorisedAlignAllocPolicy<category>::allocateBytes(sizeof(T)*(count)))
 Allocate a block of memory for a primitive type aligned to SIMD boundaries, and indicate the category of usage.
#define OGRE_ALLOC_T_ALIGN(T, count, category, align)   static_cast<T*>(::Ogre::CategorisedAlignAllocPolicy<category, align>::allocateBytes(sizeof(T)*(count)))
 Allocate a block of memory for a primitive type aligned to user defined boundaries, and indicate the category of usage.
#define OGRE_FREE_SIMD(ptr, category)   ::Ogre::CategorisedAlignAllocPolicy<category>::deallocateBytes(ptr)
 Free the memory allocated with either OGRE_MALLOC_SIMD or OGRE_ALLOC_T_SIMD. Category is required to be restated to ensure the matching policy is used.
#define OGRE_FREE_ALIGN(ptr, category, align)   ::Ogre::CategorisedAlignAllocPolicy<category, align>::deallocateBytes(ptr)
 Free the memory allocated with either OGRE_MALLOC_ALIGN or OGRE_ALLOC_T_ALIGN. Category is required to be restated to ensure the matching policy is used.
#define OGRE_NEW_T_SIMD(T, category)   new (::Ogre::CategorisedAlignAllocPolicy<category>::allocateBytes(sizeof(T))) T
 Allocate space for one primitive type, external type or non-virtual type aligned to SIMD boundaries.
#define OGRE_NEW_ARRAY_T_SIMD(T, count, category)   ::Ogre::constructN(static_cast<T*>(::Ogre::CategorisedAlignAllocPolicy<category>::allocateBytes(sizeof(T)*(count))), count)
 Allocate a block of memory for 'count' primitive types aligned to SIMD boundaries - do not use for classes that inherit from AllocatedObject.
#define OGRE_DELETE_T_SIMD(ptr, T, category)   if(ptr){(ptr)->~T(); ::Ogre::CategorisedAlignAllocPolicy<category>::deallocateBytes(ptr);}
 Free the memory allocated with OGRE_NEW_T_SIMD. Category is required to be restated to ensure the matching policy is used.
#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);}
 Free the memory allocated with OGRE_NEW_ARRAY_T_SIMD. Category is required to be restated to ensure the matching policy is used, count and type to call destructor.
#define OGRE_NEW_T_ALIGN(T, category, align)   new (::Ogre::CategorisedAlignAllocPolicy<category, align>::allocateBytes(sizeof(T))) T
 Allocate space for one primitive type, external type or non-virtual type aligned to user defined boundaries.
#define OGRE_NEW_ARRAY_T_ALIGN(T, count, category, align)   ::Ogre::constructN(static_cast<T*>(::Ogre::CategorisedAlignAllocPolicy<category, align>::allocateBytes(sizeof(T)*(count))), count)
 Allocate a block of memory for 'count' primitive types aligned to user defined boundaries - do not use for classes that inherit from AllocatedObject.
#define OGRE_DELETE_T_ALIGN(ptr, T, category, align)   if(ptr){(ptr)->~T(); ::Ogre::CategorisedAlignAllocPolicy<category, align>::deallocateBytes(ptr);}
 Free the memory allocated with OGRE_NEW_T_ALIGN. Category is required to be restated to ensure the matching policy is used.
#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);}
 Free the memory allocated with OGRE_NEW_ARRAY_T_ALIGN. Category is required to be restated to ensure the matching policy is used, count and type to call destructor.
#define OGRE_NEW   new
#define OGRE_DELETE   delete

Typedefs

typedef
CategorisedAllocPolicy
< MEMCATEGORY_GENERAL > 
Ogre::GeneralAllocPolicy
typedef
CategorisedAllocPolicy
< MEMCATEGORY_GEOMETRY > 
Ogre::GeometryAllocPolicy
typedef
CategorisedAllocPolicy
< MEMCATEGORY_ANIMATION > 
Ogre::AnimationAllocPolicy
typedef
CategorisedAllocPolicy
< MEMCATEGORY_SCENE_CONTROL > 
Ogre::SceneCtlAllocPolicy
typedef
CategorisedAllocPolicy
< MEMCATEGORY_SCENE_OBJECTS > 
Ogre::SceneObjAllocPolicy
typedef
CategorisedAllocPolicy
< MEMCATEGORY_RESOURCE > 
Ogre::ResourceAllocPolicy
typedef
CategorisedAllocPolicy
< MEMCATEGORY_SCRIPTING > 
Ogre::ScriptingAllocPolicy
typedef
CategorisedAllocPolicy
< MEMCATEGORY_RENDERSYS > 
Ogre::RenderSysAllocPolicy
typedef
AllocatedObject
< GeneralAllocPolicy > 
Ogre::GeneralAllocatedObject
typedef
AllocatedObject
< GeometryAllocPolicy > 
Ogre::GeometryAllocatedObject
typedef
AllocatedObject
< AnimationAllocPolicy > 
Ogre::AnimationAllocatedObject
typedef
AllocatedObject
< SceneCtlAllocPolicy > 
Ogre::SceneCtlAllocatedObject
typedef
AllocatedObject
< SceneObjAllocPolicy > 
Ogre::SceneObjAllocatedObject
typedef
AllocatedObject
< ResourceAllocPolicy > 
Ogre::ResourceAllocatedObject
typedef
AllocatedObject
< ScriptingAllocPolicy > 
Ogre::ScriptingAllocatedObject
typedef
AllocatedObject
< RenderSysAllocPolicy > 
Ogre::RenderSysAllocatedObject
typedef
ScriptingAllocatedObject 
Ogre::AbstractNodeAlloc
typedef
AnimationAllocatedObject 
Ogre::AnimableAlloc
typedef
AnimationAllocatedObject 
Ogre::AnimationAlloc
typedef
GeneralAllocatedObject 
Ogre::ArchiveAlloc
typedef
GeometryAllocatedObject 
Ogre::BatchedGeometryAlloc
typedef
RenderSysAllocatedObject 
Ogre::BufferAlloc
typedef
GeneralAllocatedObject 
Ogre::CodecAlloc
typedef
ResourceAllocatedObject 
Ogre::CompositorInstAlloc
typedef
GeneralAllocatedObject 
Ogre::ConfigAlloc
typedef
GeneralAllocatedObject 
Ogre::ControllerAlloc
typedef
GeometryAllocatedObject 
Ogre::DebugGeomAlloc
typedef
GeneralAllocatedObject 
Ogre::DynLibAlloc
typedef
GeometryAllocatedObject 
Ogre::EdgeDataAlloc
typedef
GeneralAllocatedObject 
Ogre::FactoryAlloc
typedef
SceneObjAllocatedObject 
Ogre::FXAlloc
typedef
GeneralAllocatedObject 
Ogre::ImageAlloc
typedef
GeometryAllocatedObject 
Ogre::IndexDataAlloc
typedef
GeneralAllocatedObject 
Ogre::LogAlloc
typedef
SceneObjAllocatedObject 
Ogre::MovableAlloc
typedef
SceneCtlAllocatedObject 
Ogre::NodeAlloc
typedef
SceneObjAllocatedObject 
Ogre::OverlayAlloc
typedef
RenderSysAllocatedObject 
Ogre::GpuParamsAlloc
typedef
ResourceAllocatedObject 
Ogre::PassAlloc
typedef
GeometryAllocatedObject 
Ogre::PatchAlloc
typedef
GeneralAllocatedObject 
Ogre::ProfilerAlloc
typedef
GeometryAllocatedObject 
Ogre::ProgMeshAlloc
typedef
SceneCtlAllocatedObject 
Ogre::RenderQueueAlloc
typedef
RenderSysAllocatedObject 
Ogre::RenderSysAlloc
typedef
GeneralAllocatedObject 
Ogre::RootAlloc
typedef
ResourceAllocatedObject 
Ogre::ResourceAlloc
typedef
GeneralAllocatedObject 
Ogre::SerializerAlloc
typedef
SceneCtlAllocatedObject 
Ogre::SceneMgtAlloc
typedef
ScriptingAllocatedObject 
Ogre::ScriptCompilerAlloc
typedef
ScriptingAllocatedObject 
Ogre::ScriptTranslatorAlloc
typedef
SceneCtlAllocatedObject 
Ogre::ShadowDataAlloc
typedef
GeneralAllocatedObject 
Ogre::StreamAlloc
typedef
SceneObjAllocatedObject 
Ogre::SubEntityAlloc
typedef
ResourceAllocatedObject 
Ogre::SubMeshAlloc
typedef
ResourceAllocatedObject 
Ogre::TechniqueAlloc
typedef
GeneralAllocatedObject 
Ogre::TimerAlloc
typedef
ResourceAllocatedObject 
Ogre::TextureUnitStateAlloc
typedef
GeneralAllocatedObject 
Ogre::UtilityAlloc
typedef
GeometryAllocatedObject 
Ogre::VertexDataAlloc
typedef
RenderSysAllocatedObject 
Ogre::ViewportAlloc

Enumerations

enum  Ogre::MemoryCategory {
  Ogre::MEMCATEGORY_GENERAL = 0, Ogre::MEMCATEGORY_GEOMETRY = 1, Ogre::MEMCATEGORY_ANIMATION = 2, Ogre::MEMCATEGORY_SCENE_CONTROL = 3,
  Ogre::MEMCATEGORY_SCENE_OBJECTS = 4, Ogre::MEMCATEGORY_RESOURCE = 5, Ogre::MEMCATEGORY_SCRIPTING = 6, Ogre::MEMCATEGORY_RENDERSYS = 7,
  Ogre::MEMCATEGORY_COUNT = 8
}
 A set of categories that indicate the purpose of a chunk of memory being allocated. More...

Functions

template<typename T>
T * Ogre::constructN (T *basePtr, size_t count)
 Utility function for constructing an array of objects with placement new, without using new[] (which allocates an undocumented amount of extra memory and so isn't appropriate for custom allocators).


Detailed Description

This file configures Ogre's memory allocators.

You can modify this file to alter the allocation routines used for Ogre's main objects.

When customising memory allocation, all you need to do is provide one or more custom allocation policy classes. These classes need to implement:

    // Allocate bytes - file/line/func information should be optional, 
    // will be provided when available but not everywhere (e.g. release mode, STL allocations)
    static inline void* allocateBytes(size_t count, const char* file = 0, int line = 0, const char* func = 0);
    // Free bytes
    static inline void deallocateBytes(void* ptr);
    // Return the max number of bytes available to be allocated in a single allocation
    static inline size_t getMaxAllocationSize();

Policies are then used as implementations for the wrapper classes and macros which call them. AllocatedObject for example provides the hooks to override the new and delete operators for a class and redirect the functionality to the policy. STLAllocator is a class which is provided to STL containers in order to hook up allocation of the containers members to the allocation policy.

In addition to linking allocations to policies, this class also defines a number of macros to allow debugging information to be passed along with allocations, such as the file and line number they originate from. It's important to realise that we do not redefine the 'new' and 'delete' symbols with macros, because that's very difficult to consistently do when other libraries are also trying to do the same thing; instead we use dedicated 'OGRE_' prefixed macros. See OGRE_NEW and related items.
The base macros you can use are listed below, in order of preference and with their conditions stated: Here are some examples:
    AllocatedClass* obj = OGRE_NEW AllocatedClass();
    OGRE_DELETE obj;
    AllocatedClass* array = OGRE_NEW AllocatedClass[10];
    OGRE_DELETE [] obj;
    ExternalClass* obj = OGRE_NEW_T(ExternalClass, MEMCATEGORY_GENERAL)(constructorArgs);
    OGRE_DELETE_T(obj, ExternalClass, MEMCATEGORY_GENERAL);
    ExternalClass* obj = OGRE_NEW_ARRAY_T(ExternalClass, 10, MEMCATEGORY_GENERAL);
    OGRE_DELETE_ARRAY_T(obj, NonVirtualClass, 10, MEMCATEGORY_GENERAL);
    long* pLong = OGRE_ALLOC_T(long, 10, MEMCATEGORY_GENERAL);
    OGRE_FREE(pLong, MEMCATEGORY_GENERAL);
    long* pLong = OGRE_NEW_T(long, MEMCATEGORY_GENERAL)(0);
    OGRE_FREE(pLong, MEMCATEGORY_GENERAL);
    void* pVoid = OGRE_MALLOC(1024, MEMCATEGORY_GENERAL);
    OGRE_FREE(pVoid, MEMCATEGORY_GENERAL);
OGRE_ALLOC_T is also the route to go for allocating real primitive types like int & float. You free the memory using OGRE_FREE, and both variants have SIMD and custom alignment variants.

Definition in file OgreMemoryAllocatorConfig.h.


Define Documentation

#define OGRE_ALLOC_T ( T,
count,
category   )     static_cast<T*>(::Ogre::CategorisedAllocPolicy<category>::allocateBytes(sizeof(T)*(count)))

Allocate a block of memory for a primitive type, and indicate the category of usage.

Definition at line 375 of file OgreMemoryAllocatorConfig.h.

Referenced by Ogre::AxisAlignedBox::getAllCorners(), and Ogre::VertexCacheProfiler::VertexCacheProfiler().

#define OGRE_ALLOC_T_ALIGN ( T,
count,
category,
align   )     static_cast<T*>(::Ogre::CategorisedAlignAllocPolicy<category, align>::allocateBytes(sizeof(T)*(count)))

Allocate a block of memory for a primitive type aligned to user defined boundaries, and indicate the category of usage.

Definition at line 396 of file OgreMemoryAllocatorConfig.h.

#define OGRE_ALLOC_T_SIMD ( T,
count,
category   )     static_cast<T*>(::Ogre::CategorisedAlignAllocPolicy<category>::allocateBytes(sizeof(T)*(count)))

Allocate a block of memory for a primitive type aligned to SIMD boundaries, and indicate the category of usage.

Definition at line 394 of file OgreMemoryAllocatorConfig.h.

#define OGRE_DELETE   delete

Definition at line 421 of file OgreMemoryAllocatorConfig.h.

Referenced by Ogre::RenderQueueGroup::clear(), Ogre::SharedPtr< Ogre::PatchMesh >::destroy(), Ogre::ZipArchiveFactory::destroyInstance(), Ogre::StaticGeometry::OptimisedSubMeshGeometry::~OptimisedSubMeshGeometry(), and Ogre::RenderQueueGroup::~RenderQueueGroup().

#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(ptr);}

Free the memory allocated with OGRE_NEW_ARRAY_T. Category is required to be restated to ensure the matching policy is used, count and type to call destructor.

Definition at line 386 of file OgreMemoryAllocatorConfig.h.

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

Free the memory allocated with OGRE_NEW_ARRAY_T_ALIGN. Category is required to be restated to ensure the matching policy is used, count and type to call destructor.

Definition at line 417 of file OgreMemoryAllocatorConfig.h.

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

Free the memory allocated with OGRE_NEW_ARRAY_T_SIMD. Category is required to be restated to ensure the matching policy is used, count and type to call destructor.

Definition at line 409 of file OgreMemoryAllocatorConfig.h.

#define OGRE_DELETE_T ( ptr,
T,
category   )     if(ptr){(ptr)->~T(); ::Ogre::CategorisedAllocPolicy<category>::deallocateBytes(ptr);}

Free the memory allocated with OGRE_NEW_T. Category is required to be restated to ensure the matching policy is used.

Definition at line 384 of file OgreMemoryAllocatorConfig.h.

Referenced by Ogre::SharedPtr< Ogre::PatchMesh >::destroy(), and Ogre::Any::~Any().

#define OGRE_DELETE_T_ALIGN ( ptr,
T,
category,
align   )     if(ptr){(ptr)->~T(); ::Ogre::CategorisedAlignAllocPolicy<category, align>::deallocateBytes(ptr);}

Free the memory allocated with OGRE_NEW_T_ALIGN. Category is required to be restated to ensure the matching policy is used.

Definition at line 415 of file OgreMemoryAllocatorConfig.h.

#define OGRE_DELETE_T_SIMD ( ptr,
T,
category   )     if(ptr){(ptr)->~T(); ::Ogre::CategorisedAlignAllocPolicy<category>::deallocateBytes(ptr);}

Free the memory allocated with OGRE_NEW_T_SIMD. Category is required to be restated to ensure the matching policy is used.

Definition at line 407 of file OgreMemoryAllocatorConfig.h.

#define OGRE_FREE ( ptr,
category   )     ::Ogre::CategorisedAllocPolicy<category>::deallocateBytes(ptr)

Free the memory allocated with OGRE_MALLOC or OGRE_ALLOC_T. Category is required to be restated to ensure the matching policy is used.

Definition at line 377 of file OgreMemoryAllocatorConfig.h.

Referenced by Ogre::SharedPtr< Ogre::PatchMesh >::destroy(), Ogre::AxisAlignedBox::~AxisAlignedBox(), and Ogre::VertexCacheProfiler::~VertexCacheProfiler().

#define OGRE_FREE_ALIGN ( ptr,
category,
align   )     ::Ogre::CategorisedAlignAllocPolicy<category, align>::deallocateBytes(ptr)

Free the memory allocated with either OGRE_MALLOC_ALIGN or OGRE_ALLOC_T_ALIGN. Category is required to be restated to ensure the matching policy is used.

Definition at line 400 of file OgreMemoryAllocatorConfig.h.

#define OGRE_FREE_SIMD ( ptr,
category   )     ::Ogre::CategorisedAlignAllocPolicy<category>::deallocateBytes(ptr)

Free the memory allocated with either OGRE_MALLOC_SIMD or OGRE_ALLOC_T_SIMD. Category is required to be restated to ensure the matching policy is used.

Definition at line 398 of file OgreMemoryAllocatorConfig.h.

#define OGRE_MALLOC ( bytes,
category   )     ::Ogre::CategorisedAllocPolicy<category>::allocateBytes(bytes)

Allocate a block of raw memory, and indicate the category of usage.

Definition at line 373 of file OgreMemoryAllocatorConfig.h.

#define OGRE_MALLOC_ALIGN ( bytes,
category,
align   )     ::Ogre::CategorisedAlignAllocPolicy<category, align>::allocateBytes(bytes)

Allocate a block of raw memory aligned to user defined boundaries, and indicate the category of usage.

Definition at line 392 of file OgreMemoryAllocatorConfig.h.

#define OGRE_MALLOC_SIMD ( bytes,
category   )     ::Ogre::CategorisedAlignAllocPolicy<category>::allocateBytes(bytes)

Allocate a block of raw memory aligned to SIMD boundaries, and indicate the category of usage.

Definition at line 390 of file OgreMemoryAllocatorConfig.h.

#define OGRE_NEW   new

Definition at line 420 of file OgreMemoryAllocatorConfig.h.

Referenced by Ogre::RenderQueueGroup::addRenderable(), Ogre::SceneManager::createAutoParamDataSource(), Ogre::ZipArchiveFactory::createInstance(), Ogre::FileSystemArchiveFactory::createInstance(), Ogre::TextAreaOverlayElementFactory::createOverlayElement(), Ogre::BorderPanelOverlayElementFactory::createOverlayElement(), and Ogre::PanelOverlayElementFactory::createOverlayElement().

#define OGRE_NEW_ARRAY_T ( T,
count,
category   )     ::Ogre::constructN(static_cast<T*>(::Ogre::CategorisedAllocPolicy<category>::allocateBytes(sizeof(T)*(count))), count)

Allocate a block of memory for 'count' primitive types - do not use for classes that inherit from AllocatedObject.

Definition at line 382 of file OgreMemoryAllocatorConfig.h.

#define OGRE_NEW_ARRAY_T_ALIGN ( T,
count,
category,
align   )     ::Ogre::constructN(static_cast<T*>(::Ogre::CategorisedAlignAllocPolicy<category, align>::allocateBytes(sizeof(T)*(count))), count)

Allocate a block of memory for 'count' primitive types aligned to user defined boundaries - do not use for classes that inherit from AllocatedObject.

Definition at line 413 of file OgreMemoryAllocatorConfig.h.

#define OGRE_NEW_ARRAY_T_SIMD ( T,
count,
category   )     ::Ogre::constructN(static_cast<T*>(::Ogre::CategorisedAlignAllocPolicy<category>::allocateBytes(sizeof(T)*(count))), count)

Allocate a block of memory for 'count' primitive types aligned to SIMD boundaries - do not use for classes that inherit from AllocatedObject.

Definition at line 405 of file OgreMemoryAllocatorConfig.h.

#define OGRE_NEW_T ( T,
category   )     new (::Ogre::CategorisedAllocPolicy<category>::allocateBytes(sizeof(T))) T

Allocate space for one primitive type, external type or non-virtual type with constructor parameters.

Definition at line 380 of file OgreMemoryAllocatorConfig.h.

Referenced by Ogre::AnyNumeric::numholder< ValueType >::add(), Ogre::AnyNumeric::AnyNumeric(), Ogre::SharedPtr< Ogre::PatchMesh >::bind(), Ogre::AnyNumeric::numholder< ValueType >::clone(), Ogre::Any::holder< ValueType >::clone(), Ogre::AnyNumeric::numholder< ValueType >::divide(), Ogre::AnyNumeric::numholder< ValueType >::multiply(), and Ogre::AnyNumeric::numholder< ValueType >::subtract().

#define OGRE_NEW_T_ALIGN ( T,
category,
align   )     new (::Ogre::CategorisedAlignAllocPolicy<category, align>::allocateBytes(sizeof(T))) T

Allocate space for one primitive type, external type or non-virtual type aligned to user defined boundaries.

Definition at line 411 of file OgreMemoryAllocatorConfig.h.

#define OGRE_NEW_T_SIMD ( T,
category   )     new (::Ogre::CategorisedAlignAllocPolicy<category>::allocateBytes(sizeof(T))) T

Allocate space for one primitive type, external type or non-virtual type aligned to SIMD boundaries.

Definition at line 403 of file OgreMemoryAllocatorConfig.h.


Copyright © 2008 Torus Knot Software Ltd
Creative Commons License
This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Thu Aug 28 20:53:55 2008