ruby-ogre 0.0.1-x86-linux

data/deps/include/OGRE/OgreMemoryAllocatedObject.h

@@ -0,0 +1,129 @@
+/*
+-----------------------------------------------------------------------------
+This source file is part of OGRE
+(Object-oriented Graphics Rendering Engine)
+For the latest info, see http://www.ogre3d.org/
+
+Copyright (c) 2000-2012 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 __AllocatedObject_H__
+#define __AllocatedObject_H__
+
+#include "OgrePrerequisites.h"
+
+// Anything that has done a #define new <blah> will screw operator new definitions up
+// so undefine
+#ifdef new
+#  undef new
+#endif
+#ifdef delete
+#  undef delete
+#endif
+
+namespace Ogre
+{
+	/** \addtogroup Core
+	*  @{
+	*/
+	/** \addtogroup Memory
+	*  @{
+	*/
+	/** Superclass for all objects that wish to use custom memory allocators
+		when their new / delete operators are called.
+		Requires a template parameter identifying the memory allocator policy 
+		to use (e.g. see StdAllocPolicy). 
+	*/
+	template <class Alloc>
+	class _OgreExport AllocatedObject
+	{
+	public:
+		explicit AllocatedObject()
+		{ }
+
+		~AllocatedObject()
+		{ }
+
+		/// operator new, with debug line info
+		void* operator new(size_t sz, const char* file, int line, const char* func)
+		{
+			return Alloc::allocateBytes(sz, file, line, func);
+		}
+
+		void* operator new(size_t sz)
+		{
+			return Alloc::allocateBytes(sz);
+		}
+
+		/// placement operator new
+		void* operator new(size_t sz, void* ptr)
+		{
+			(void) sz;
+			return ptr;
+		}
+
+		/// array operator new, with debug line info
+		void* operator new[] ( size_t sz, const char* file, int line, const char* func )
+		{
+			return Alloc::allocateBytes(sz, file, line, func);
+		}
+
+		void* operator new[] ( size_t sz )
+		{
+			return Alloc::allocateBytes(sz);
+		}
+
+		void operator delete( void* ptr )
+		{
+			Alloc::deallocateBytes(ptr);
+		}
+
+		// Corresponding operator for placement delete (second param same as the first)
+		void operator delete( void* ptr, void* )
+		{
+			Alloc::deallocateBytes(ptr);
+		}
+
+		// only called if there is an exception in corresponding 'new'
+		void operator delete( void* ptr, const char* , int , const char*  )
+		{
+			Alloc::deallocateBytes(ptr);
+		}
+
+		void operator delete[] ( void* ptr )
+		{
+			Alloc::deallocateBytes(ptr);
+		}
+
+
+		void operator delete[] ( void* ptr, const char* , int , const char*  )
+		{
+			Alloc::deallocateBytes(ptr);
+		}
+	};
+
+
+	/** @} */
+	/** @} */
+
+}
+#endif

data/deps/include/OGRE/OgreMemoryAllocatorConfig.h

@@ -0,0 +1,493 @@
+/*
+-----------------------------------------------------------------------------
+This source file is part of OGRE
+(Object-oriented Graphics Rendering Engine)
+For the latest info, see http://www.ogre3d.org/
+
+Copyright (c) 2000-2012 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" 
+
+/** \addtogroup Core
+*  @{
+*/
+/** \addtogroup Memory
+*  @{
+*/
+/** @file
+
+	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:
+
+	@code
+	// 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();
+	@endcode
+
+	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.
+	@par
+	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.
+	@par
+	The base macros you can use are listed below, in order of preference and 
+	with their conditions stated:
+	<ul>
+	<li>OGRE_NEW - use to allocate an object which have custom new/delete operators
+		to handle custom allocations, usually this means it's derived from Ogre::AllocatedObject. 
+		Free the memory using OGRE_DELETE. You can in fact use the regular new/delete
+		for these classes but you won't get any line number debugging if you do.
+		The memory category is automatically derived for these classes; for all other
+		allocations you have to specify it.
+	</li>
+	<li>OGRE_NEW_T - use to allocate a single class / struct that does not have custom
+		new/delete operators, either because it is non-virtual (Vector3, Quaternion),
+		or because it is from an external library (e.g. STL). You must
+		deallocate with OGRE_DELETE_T if you expect the destructor to be called. 
+		You may free the memory using OGRE_FREE if you are absolutely sure there
+		is no destructor to be called. 
+		These macros ensure that constructors and destructors are called correctly 
+		even though the memory originates externally (via placement new). Also note 
+		that you have to specify the type and memory category so that the correct 
+		allocator can be derived, when both allocating
+		and freeing.
+	</li>
+	<li>OGRE_NEW_ARRAY_T - as OGRE_NEW_T except with an extra parameter to construct
+		multiple instances in contiguous memory. Again constructors and destructors
+		are called. Free with OGRE_DELETE_ARRAY_T.
+	</li>
+	<li>OGRE_ALLOC_T - use to allocate a set of primitive types conveniently with type safety. 
+	This <i>can</i> also be used for classes and structs but it is <b>imperative</b> that
+	you understand that neither the constructor nor the destructor will be called. 
+	Sometimes you want this because it's more efficient just to grab/free a chunk of
+	memory without having to iterate over each element constructing / destructing.
+	Free the memory with OGRE_FREE. </li>
+	<li>OGRE_MALLOC - the most raw form of allocation, just a set of bytes. 
+		Use OGRE_FREE to release.</li>
+	<li>_SIMD and _ALIGN variants - all of the above have variations which allow
+		aligned memory allocations. The _SIMD versions align automatically to the
+		SIMD requirements of your platform, the _ALIGN variants allow user-defined
+		alignment to be specified. </li>
+	</ul>
+	Here are some examples:
+	@code
+	/// AllocatedObject subclass, with custom operator new / delete
+	AllocatedClass* obj = OGRE_NEW AllocatedClass();
+	OGRE_DELETE obj;
+	AllocatedClass* array = OGRE_NEW AllocatedClass[10];
+	OGRE_DELETE [] obj;
+	/// Non-virtual or external class, constructors / destructors called
+	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);
+	/// Primitive types
+	long* pLong = OGRE_ALLOC_T(long, 10, MEMCATEGORY_GENERAL);
+	OGRE_FREE(pLong, MEMCATEGORY_GENERAL);
+	/// Primitive type with constructor (you can mismatch OGRE_NEW_T and OGRE_FREE because no destructor)
+	long* pLong = OGRE_NEW_T(long, MEMCATEGORY_GENERAL)(0);
+	OGRE_FREE(pLong, MEMCATEGORY_GENERAL);
+	/// Raw memory
+	void* pVoid = OGRE_MALLOC(1024, MEMCATEGORY_GENERAL);
+	OGRE_FREE(pVoid, MEMCATEGORY_GENERAL);
+	@endcode
+	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.
+*/
+/** @} */
+/** @} */
+
+namespace Ogre
+{
+	/** \addtogroup Core
+	*  @{
+	*/
+	/** \addtogroup Memory
+	*  @{
+	*/
+
+	/** A set of categories that indicate the purpose of a chunk of memory
+	being allocated. 
+	These categories will be provided at allocation time in order to allow
+	the allocation policy to vary its behaviour if it wishes. This allows you
+	to use a single policy but still have variant behaviour. The level of 
+	control it gives you is at a higher level than assigning different 
+	policies to different classes, but is the only control you have over
+	general allocations that are primitive types.
+	*/
+	enum MemoryCategory
+	{
+		/// General purpose
+		MEMCATEGORY_GENERAL = 0,
+		/// Geometry held in main memory
+		MEMCATEGORY_GEOMETRY = 1, 
+		/// Animation data like tracks, bone matrices
+		MEMCATEGORY_ANIMATION = 2, 
+		/// Nodes, control data
+		MEMCATEGORY_SCENE_CONTROL = 3,
+		/// Scene object instances
+		MEMCATEGORY_SCENE_OBJECTS = 4,
+		/// Other resources
+		MEMCATEGORY_RESOURCE = 5,
+		/// Scripting
+		MEMCATEGORY_SCRIPTING = 6,
+		/// Rendersystem structures
+		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;
+
+	// 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
+{
+	/** \addtogroup Core
+	*  @{
+	*/
+	/** \addtogroup Memory
+	*  @{
+	*/
+
+	/** 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).
+	*/
+	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 
+
+/** \addtogroup Core
+*  @{
+*/
+/** \addtogroup Memory
+*  @{
+*/
+
+#if OGRE_DEBUG_MODE
+
+/// Allocate a block of raw memory, and indicate the category of usage
+#	define OGRE_MALLOC(bytes, category) ::Ogre::CategorisedAllocPolicy<category>::allocateBytes(bytes, __FILE__, __LINE__, __FUNCTION__)
+/// Allocate a block of memory for a primitive type, and indicate the category of usage
+#	define OGRE_ALLOC_T(T, count, category) static_cast<T*>(::Ogre::CategorisedAllocPolicy<category>::allocateBytes(sizeof(T)*(count), __FILE__, __LINE__, __FUNCTION__))
+/// 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_FREE(ptr, category) ::Ogre::CategorisedAllocPolicy<category>::deallocateBytes((void*)ptr)
+
+/// Allocate space for one primitive type, external type or non-virtual type with constructor parameters
+#	define OGRE_NEW_T(T, category) new (::Ogre::CategorisedAllocPolicy<category>::allocateBytes(sizeof(T), __FILE__, __LINE__, __FUNCTION__)) T
+/// Allocate a block of memory for 'count' primitive types - do not use for classes that inherit from AllocatedObject
+#	define OGRE_NEW_ARRAY_T(T, count, category) ::Ogre::constructN(static_cast<T*>(::Ogre::CategorisedAllocPolicy<category>::allocateBytes(sizeof(T)*(count), __FILE__, __LINE__, __FUNCTION__)), count) 
+/// Free the memory allocated with OGRE_NEW_T. Category is required to be restated to ensure the matching policy is used
+#	define OGRE_DELETE_T(ptr, T, category) if(ptr){(ptr)->~T(); ::Ogre::CategorisedAllocPolicy<category>::deallocateBytes((void*)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_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
+/// Allocate a block of raw memory aligned to SIMD boundaries, and indicate the category of usage
+#	define OGRE_MALLOC_SIMD(bytes, category) ::Ogre::CategorisedAlignAllocPolicy<category>::allocateBytes(bytes, __FILE__, __LINE__, __FUNCTION__)
+/// Allocate a block of raw memory aligned to user defined boundaries, and indicate the category of usage
+#	define OGRE_MALLOC_ALIGN(bytes, category, align) ::Ogre::CategorisedAlignAllocPolicy<category, align>::allocateBytes(bytes, __FILE__, __LINE__, __FUNCTION__)
+/// Allocate a block of memory for a primitive type aligned to SIMD 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), __FILE__, __LINE__, __FUNCTION__))
+/// Allocate a block of memory for a primitive type aligned to user defined 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), __FILE__, __LINE__, __FUNCTION__))
+/// 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_SIMD(ptr, category) ::Ogre::CategorisedAlignAllocPolicy<category>::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_FREE_ALIGN(ptr, category, align) ::Ogre::CategorisedAlignAllocPolicy<category, align>::deallocateBytes(ptr)
+
+/// Allocate space for one primitive type, external type or non-virtual type aligned to SIMD boundaries
+#	define OGRE_NEW_T_SIMD(T, category) new (::Ogre::CategorisedAlignAllocPolicy<category>::allocateBytes(sizeof(T), __FILE__, __LINE__, __FUNCTION__)) T
+/// Allocate a block of memory for 'count' primitive types aligned to SIMD boundaries - do not use for classes that inherit from AllocatedObject
+#	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) 
+/// 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_T_SIMD(ptr, T, category) if(ptr){(ptr)->~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_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);}
+/// Allocate space for one primitive type, external type or non-virtual type aligned to user defined boundaries
+#	define OGRE_NEW_T_ALIGN(T, category, align) new (::Ogre::CategorisedAlignAllocPolicy<category, align>::allocateBytes(sizeof(T), __FILE__, __LINE__, __FUNCTION__)) T
+/// 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_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) 
+/// 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_T_ALIGN(ptr, T, category, align) if(ptr){(ptr)->~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_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
+
+/// Allocate a block of raw memory, and indicate the category of usage
+#	define OGRE_MALLOC(bytes, category) ::Ogre::CategorisedAllocPolicy<category>::allocateBytes(bytes)
+/// Allocate a block of memory for a primitive type, and indicate the category of usage
+#	define OGRE_ALLOC_T(T, count, category) static_cast<T*>(::Ogre::CategorisedAllocPolicy<category>::allocateBytes(sizeof(T)*(count)))
+/// 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_FREE(ptr, category) ::Ogre::CategorisedAllocPolicy<category>::deallocateBytes((void*)ptr)
+
+/// Allocate space for one primitive type, external type or non-virtual type with constructor parameters
+#	define OGRE_NEW_T(T, category) new (::Ogre::CategorisedAllocPolicy<category>::allocateBytes(sizeof(T))) T
+/// Allocate a block of memory for 'count' primitive types - do not use for classes that inherit from AllocatedObject
+#	define OGRE_NEW_ARRAY_T(T, count, category) ::Ogre::constructN(static_cast<T*>(::Ogre::CategorisedAllocPolicy<category>::allocateBytes(sizeof(T)*(count))), count) 
+/// Free the memory allocated with OGRE_NEW_T. Category is required to be restated to ensure the matching policy is used
+#	define OGRE_DELETE_T(ptr, T, category) if(ptr){(ptr)->~T(); ::Ogre::CategorisedAllocPolicy<category>::deallocateBytes((void*)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_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
+/// Allocate a block of raw memory aligned to SIMD boundaries, and indicate the category of usage
+#	define OGRE_MALLOC_SIMD(bytes, category) ::Ogre::CategorisedAlignAllocPolicy<category>::allocateBytes(bytes)
+/// Allocate a block of raw memory aligned to user defined boundaries, and indicate the category of usage
+#	define OGRE_MALLOC_ALIGN(bytes, category, align) ::Ogre::CategorisedAlignAllocPolicy<category, align>::allocateBytes(bytes)
+/// Allocate a block of memory for a primitive type aligned to SIMD 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 user defined 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)))
+/// 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_SIMD(ptr, category) ::Ogre::CategorisedAlignAllocPolicy<category>::deallocateBytes((void*)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_FREE_ALIGN(ptr, category, align) ::Ogre::CategorisedAlignAllocPolicy<category, align>::deallocateBytes((void*)ptr)
+
+/// Allocate space for one primitive type, external type or non-virtual type aligned to SIMD boundaries
+#	define OGRE_NEW_T_SIMD(T, category) new (::Ogre::CategorisedAlignAllocPolicy<category>::allocateBytes(sizeof(T))) T
+/// Allocate a block of memory for 'count' primitive types aligned to SIMD boundaries - do not use for classes that inherit from AllocatedObject
+#	define OGRE_NEW_ARRAY_T_SIMD(T, count, category) ::Ogre::constructN(static_cast<T*>(::Ogre::CategorisedAlignAllocPolicy<category>::allocateBytes(sizeof(T)*(count))), count) 
+/// 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_T_SIMD(ptr, T, category) if(ptr){(ptr)->~T(); ::Ogre::CategorisedAlignAllocPolicy<category>::deallocateBytes((void*)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_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);}
+/// Allocate space for one primitive type, external type or non-virtual type aligned to user defined boundaries
+#	define OGRE_NEW_T_ALIGN(T, category, align) new (::Ogre::CategorisedAlignAllocPolicy<category, align>::allocateBytes(sizeof(T))) T
+/// 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_NEW_ARRAY_T_ALIGN(T, count, category, align) ::Ogre::constructN(static_cast<T*>(::Ogre::CategorisedAlignAllocPolicy<category, align>::allocateBytes(sizeof(T)*(count))), count) 
+/// 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_T_ALIGN(ptr, T, category, align) if(ptr){(ptr)->~T(); ::Ogre::CategorisedAlignAllocPolicy<category, align>::deallocateBytes((void*)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_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
+{
+	/** Function which invokes OGRE_DELETE on a given pointer. 
+	@remarks
+		Useful to pass custom deletion policies to external libraries (e. g. boost).
+	*/
+	template<typename T>
+	void deletePtr(T* ptr)
+	{
+		OGRE_DELETE ptr;
+	}
+}
+
+/** @} */
+/** @} */
+
+#endif