More porting to allocators

CamelotCore/Include/CmInput.h

@@ -22,7 +22,7 @@ namespace CamelotEngine
 
 
 		void initClipRect(Rect& clipRect);
-		void registerInputHandler(InputHandler* inputHandler);
+		void registerInputHandler(InputHandlerPtr inputHandler);
 
 		/**
 		 * @brief	Called every frame. Should only be called by Application.
@@ -44,7 +44,7 @@ namespace CamelotEngine
 		float getVerticalAxis() const;
 
 	private:
-		InputHandler* mInputHandler;
+		InputHandlerPtr mInputHandler;
 
 		float mSmoothHorizontalAxis;
 		float mSmoothVerticalAxis;

CamelotCore/Include/CmMaterialRTTI.h

@@ -176,7 +176,11 @@ namespace CamelotEngine
 		}
 
 		virtual UINT32 getRTTIId() { return TID_MaterialParamFloat; }
-		virtual std::shared_ptr<IReflectable> newRTTIObject() { return std::shared_ptr<IReflectable>(new MaterialFloatParam()); }
+		virtual std::shared_ptr<IReflectable> newRTTIObject() 
+		{ 
+			return std::shared_ptr<IReflectable>(CM_NEW(MaterialFloatParam, ScratchAlloc) MaterialFloatParam(),
+				&MemAllocDeleter<MaterialFloatParam, ScratchAlloc>::deleter); 
+		}
 	};
 
 	class CM_EXPORT MaterialVec2ParamRTTI : public RTTIType<MaterialVec2Param, IReflectable, MaterialVec2ParamRTTI>
@@ -205,7 +209,11 @@ namespace CamelotEngine
 		}
 
 		virtual UINT32 getRTTIId() { return TID_MaterialParamVec2; }
-		virtual std::shared_ptr<IReflectable> newRTTIObject() { return std::shared_ptr<IReflectable>(new MaterialVec2Param()); }
+		virtual std::shared_ptr<IReflectable> newRTTIObject() 
+		{ 
+			return std::shared_ptr<IReflectable>(CM_NEW(MaterialVec2Param, ScratchAlloc) MaterialVec2Param(),
+				&MemAllocDeleter<MaterialVec2Param, ScratchAlloc>::deleter); 
+		}
 	};
 
 	class CM_EXPORT MaterialVec3ParamRTTI : public RTTIType<MaterialVec3Param, IReflectable, MaterialVec3ParamRTTI>
@@ -234,7 +242,11 @@ namespace CamelotEngine
 		}
 
 		virtual UINT32 getRTTIId() { return TID_MaterialParamVec3; }
-		virtual std::shared_ptr<IReflectable> newRTTIObject() { return std::shared_ptr<IReflectable>(new MaterialVec3Param()); }
+		virtual std::shared_ptr<IReflectable> newRTTIObject() 
+		{ 
+			return std::shared_ptr<IReflectable>(CM_NEW(MaterialVec3Param, ScratchAlloc) MaterialVec3Param(),
+				&MemAllocDeleter<MaterialVec3Param, ScratchAlloc>::deleter); 
+		}
 	};
 
 	class CM_EXPORT MaterialVec4ParamRTTI : public RTTIType<MaterialVec4Param, IReflectable, MaterialVec4ParamRTTI>
@@ -263,7 +275,11 @@ namespace CamelotEngine
 		}
 
 		virtual UINT32 getRTTIId() { return TID_MaterialParamVec4; }
-		virtual std::shared_ptr<IReflectable> newRTTIObject() { return std::shared_ptr<IReflectable>(new MaterialVec4Param()); }
+		virtual std::shared_ptr<IReflectable> newRTTIObject() 
+		{
+			return std::shared_ptr<IReflectable>(CM_NEW(MaterialVec4Param, ScratchAlloc) MaterialVec4Param(),
+				&MemAllocDeleter<MaterialVec4Param, ScratchAlloc>::deleter); 
+		}
 	};
 
 	class CM_EXPORT MaterialMat3ParamRTTI : public RTTIType<MaterialMat3Param, IReflectable, MaterialMat3ParamRTTI>
@@ -292,7 +308,11 @@ namespace CamelotEngine
 		}
 
 		virtual UINT32 getRTTIId() { return TID_MaterialParamMat3; }
-		virtual std::shared_ptr<IReflectable> newRTTIObject() { return std::shared_ptr<IReflectable>(new MaterialMat3Param()); }
+		virtual std::shared_ptr<IReflectable> newRTTIObject() 
+		{ 
+			return std::shared_ptr<IReflectable>(CM_NEW(MaterialMat3Param, ScratchAlloc) MaterialMat3Param(),
+				&MemAllocDeleter<MaterialMat3Param, ScratchAlloc>::deleter); 
+		}
 	};
 
 	class CM_EXPORT MaterialMat4ParamRTTI : public RTTIType<MaterialMat4Param, IReflectable, MaterialMat4ParamRTTI>
@@ -321,7 +341,11 @@ namespace CamelotEngine
 		}
 
 		virtual UINT32 getRTTIId() { return TID_MaterialParamMat4; }
-		virtual std::shared_ptr<IReflectable> newRTTIObject() { return std::shared_ptr<IReflectable>(new MaterialMat4Param()); }
+		virtual std::shared_ptr<IReflectable> newRTTIObject() 
+		{ 
+			return std::shared_ptr<IReflectable>(CM_NEW(MaterialMat4Param, ScratchAlloc) MaterialMat4Param(),
+				&MemAllocDeleter<MaterialMat4Param, ScratchAlloc>::deleter); 
+		}
 	};
 
 	class CM_EXPORT MaterialStructParamRTTI : public RTTIType<MaterialStructParam, IReflectable, MaterialStructParamRTTI>
@@ -365,7 +389,11 @@ namespace CamelotEngine
 		}
 
 		virtual UINT32 getRTTIId() { return TID_MaterialParamStruct; }
-		virtual std::shared_ptr<IReflectable> newRTTIObject() { return std::shared_ptr<IReflectable>(new MaterialStructParam()); }
+		virtual std::shared_ptr<IReflectable> newRTTIObject() 
+		{ 
+			return std::shared_ptr<IReflectable>(CM_NEW(MaterialStructParam, ScratchAlloc) MaterialStructParam(),
+				&MemAllocDeleter<MaterialStructParam, ScratchAlloc>::deleter);
+		}
 	};
 
 	class CM_EXPORT MaterialTextureParamRTTI : public RTTIType<MaterialTextureParam, IReflectable, MaterialTextureParamRTTI>
@@ -390,7 +418,11 @@ namespace CamelotEngine
 		}
 
 		virtual UINT32 getRTTIId() { return TID_MaterialParamTexture; }
-		virtual std::shared_ptr<IReflectable> newRTTIObject() { return std::shared_ptr<IReflectable>(new MaterialTextureParam()); }
+		virtual std::shared_ptr<IReflectable> newRTTIObject() 
+		{ 
+			return std::shared_ptr<IReflectable>(CM_NEW(MaterialTextureParam, ScratchAlloc) MaterialTextureParam(),
+				&MemAllocDeleter<MaterialTextureParam, ScratchAlloc>::deleter);
+		}
 	};
 
 	class CM_EXPORT MaterialSamplerStateParamRTTI : public RTTIType<MaterialSamplerStateParam, IReflectable, MaterialSamplerStateParamRTTI>
@@ -415,7 +447,11 @@ namespace CamelotEngine
 		}
 
 		virtual UINT32 getRTTIId() { return TID_MaterialParamSamplerState; }
-		virtual std::shared_ptr<IReflectable> newRTTIObject() { return std::shared_ptr<IReflectable>(new MaterialSamplerStateParam()); }
+		virtual std::shared_ptr<IReflectable> newRTTIObject() 
+		{ 
+			return std::shared_ptr<IReflectable>(CM_NEW(MaterialSamplerStateParam, ScratchAlloc) MaterialSamplerStateParam(),
+				&MemAllocDeleter<MaterialSamplerStateParam, ScratchAlloc>::deleter);
+		}
 	};
 
 	class CM_EXPORT MaterialParamsRTTI : public RTTIType<MaterialParams, IReflectable, MaterialParamsRTTI>
@@ -503,7 +539,11 @@ namespace CamelotEngine
 		}
 
 		virtual UINT32 getRTTIId() { return TID_MaterialParams; }
-		virtual std::shared_ptr<IReflectable> newRTTIObject() { return std::shared_ptr<IReflectable>(new MaterialParams()); }
+		virtual std::shared_ptr<IReflectable> newRTTIObject() 
+		{ 
+			return std::shared_ptr<IReflectable>(CM_NEW(MaterialParams, ScratchAlloc) MaterialParams(),
+				&MemAllocDeleter<MaterialParams, ScratchAlloc>::deleter);
+		}
 	};
 
 	class CM_EXPORT MaterialRTTI : public RTTIType<Material, Resource, MaterialRTTI>

CamelotCore/Include/CmPrerequisites.h

@@ -233,6 +233,7 @@ namespace CamelotEngine
 	typedef std::shared_ptr<Font> FontPtr;
 	typedef std::shared_ptr<TextSprite> TextSpritePtr;
 	typedef std::shared_ptr<Overlay> OverlayPtr;
+	typedef std::shared_ptr<InputHandler> InputHandlerPtr;
 }
 
 /************************************************************************/

CamelotCore/Source/CmHighLevelGpuProgramManager.cpp

@@ -90,13 +90,13 @@ namespace CamelotEngine {
 	//-----------------------------------------------------------------------
 	HighLevelGpuProgramManager::HighLevelGpuProgramManager()
 	{
-		mNullFactory = new NullProgramFactory();
+		mNullFactory = CM_NEW(NullProgramFactory, GenAlloc) NullProgramFactory();
 		addFactory(mNullFactory);
 	}
 	//-----------------------------------------------------------------------
 	HighLevelGpuProgramManager::~HighLevelGpuProgramManager()
 	{
-		delete mNullFactory;
+		CM_DELETE((NullProgramFactory*)mNullFactory, NullProgramFactory, GenAlloc);
 	}
     //---------------------------------------------------------------------------
 	void HighLevelGpuProgramManager::addFactory(HighLevelGpuProgramFactory* factory)

CamelotCore/Source/CmInput.cpp

@@ -15,9 +15,9 @@ namespace CamelotEngine
 		:mSmoothHorizontalAxis(0.0f), mSmoothVerticalAxis(0.0f), mCurrentBufferIdx(0), mMouseLastRel(0, 0),
 		mUsingClipRect(false), mClipRect(0, 0, 0, 0), mInputHandler(nullptr)
 	{ 
-		mHorizontalHistoryBuffer = new float[HISTORY_BUFFER_SIZE];
-		mVerticalHistoryBuffer = new float[HISTORY_BUFFER_SIZE];
-		mTimesHistoryBuffer = new float[HISTORY_BUFFER_SIZE];
+		mHorizontalHistoryBuffer = CM_NEW_ARRAY(float, HISTORY_BUFFER_SIZE, GenAlloc);
+		mVerticalHistoryBuffer = CM_NEW_ARRAY(float, HISTORY_BUFFER_SIZE, GenAlloc);
+		mTimesHistoryBuffer = CM_NEW_ARRAY(float, HISTORY_BUFFER_SIZE, GenAlloc);
 
 		for(int i = 0; i < HISTORY_BUFFER_SIZE; i++)
 		{
@@ -29,9 +29,9 @@ namespace CamelotEngine
 
 	Input::~Input()
 	{
-		delete[] mHorizontalHistoryBuffer;
-		delete[] mVerticalHistoryBuffer;
-		delete[] mTimesHistoryBuffer;
+		CM_DELETE_ARRAY(mHorizontalHistoryBuffer, float, HISTORY_BUFFER_SIZE, GenAlloc);
+		CM_DELETE_ARRAY(mVerticalHistoryBuffer, float, HISTORY_BUFFER_SIZE, GenAlloc);
+		CM_DELETE_ARRAY(mTimesHistoryBuffer, float, HISTORY_BUFFER_SIZE, GenAlloc);
 	}
 
 	void Input::initClipRect(Rect& clipRect)
@@ -41,13 +41,10 @@ namespace CamelotEngine
 		mUsingClipRect = (clipRect.width > 0 && clipRect.height > 0);
 	}
 
-	void Input::registerInputHandler(InputHandler* inputHandler)
+	void Input::registerInputHandler(InputHandlerPtr inputHandler)
 	{
 		if(mInputHandler != inputHandler)
 		{
-			if(mInputHandler != nullptr)
-				delete mInputHandler;
-
 			mInputHandler = inputHandler;
 
 			if(mInputHandler != nullptr)

CamelotCore/Source/CmTextSprite.cpp

@@ -84,14 +84,14 @@ namespace CamelotEngine
 		~TextLine()
 		{
 			for(auto iter = mWords.begin(); iter != mWords.end(); ++iter)
-				delete *iter;
+				CM_DELETE(*iter, TextWord, ScratchAlloc);
 		}
 
 		void add(const CHAR_DESC& charDesc)
 		{
 			if(mLastWord == nullptr)
 			{
-				TextWord* newWord = new TextWord(charDesc.charId == SPACE_CHAR);
+				TextWord* newWord = CM_NEW(TextWord, ScratchAlloc) TextWord(charDesc.charId == SPACE_CHAR);
 				mLastWord = newWord;
 
 				mWords.push_back(mLastWord);
@@ -104,7 +104,7 @@ namespace CamelotEngine
 				{
 					if(mLastWord->isSpacer())
 					{
-						TextWord* newWord = new TextWord(false);
+						TextWord* newWord = CM_NEW(TextWord, ScratchAlloc) TextWord(false);
 						mLastWord = newWord;
 
 						mWords.push_back(mLastWord);
@@ -114,7 +114,7 @@ namespace CamelotEngine
 				}
 				else
 				{
-					TextWord* newWord = new TextWord(true); // Each space is counted as its own word, to make certain operations easier
+					TextWord* newWord = CM_NEW(TextWord, ScratchAlloc) TextWord(true); // Each space is counted as its own word, to make certain operations easier
 					mLastWord = newWord;
 
 					mWords.push_back(mLastWord);
@@ -263,7 +263,7 @@ namespace CamelotEngine
 		bool heightIsLimited = mHeight > 0;
 		bool widthIsLimited = mWidth > 0;
 
-		TextLine* curLine = new TextLine();
+		TextLine* curLine = CM_NEW(TextLine, ScratchAlloc) TextLine();
 		vector<TextLine*>::type textLines;
 		textLines.push_back(curLine);
 
@@ -281,7 +281,7 @@ namespace CamelotEngine
 				if(heightIsLimited && (curHeight + fontData->fontDesc.lineHeight * 2) > mHeight)
 					break; // Max height reached
 
-				curLine = new TextLine();
+				curLine = CM_NEW(TextLine, ScratchAlloc) TextLine();
 				textLines.push_back(curLine);
 				curHeight += fontData->fontDesc.lineHeight;
 
@@ -314,7 +314,7 @@ namespace CamelotEngine
 					if(heightIsLimited && (curHeight + fontData->fontDesc.lineHeight * 2) > mHeight)
 						break;
 
-					curLine = new TextLine();
+					curLine = CM_NEW(TextLine, ScratchAlloc) TextLine();
 					textLines.push_back(curLine);
 					curHeight += fontData->fontDesc.lineHeight;
 
@@ -381,13 +381,16 @@ namespace CamelotEngine
 			UINT32 newNumQuads = newRenderElemSizes[texPage];
 			if(newNumQuads != cachedElem.numQuads)
 			{
-				if(cachedElem.vertices != nullptr) delete[] cachedElem.vertices;
-				if(cachedElem.uvs != nullptr) delete[] cachedElem.uvs;
-				if(cachedElem.indexes != nullptr) delete[] cachedElem.indexes;
+				UINT32 oldVertexCount = cachedElem.numQuads * 4;
+				UINT32 oldIndexCount = cachedElem.numQuads * 6;
 
-				cachedElem.vertices = new Vector2[newNumQuads * 4];
-				cachedElem.uvs = new Vector2[newNumQuads * 4];
-				cachedElem.indexes = new UINT32[newNumQuads * 6];
+				if(cachedElem.vertices != nullptr) CM_DELETE_ARRAY(cachedElem.vertices, Vector2, oldVertexCount, ScratchAlloc);
+				if(cachedElem.uvs != nullptr) CM_DELETE_ARRAY(cachedElem.uvs, Vector2, oldVertexCount, ScratchAlloc);
+				if(cachedElem.indexes != nullptr) CM_DELETE_ARRAY(cachedElem.indexes, UINT32, oldIndexCount, ScratchAlloc);
+
+				cachedElem.vertices = CM_NEW_ARRAY(Vector2, newNumQuads * 4, ScratchAlloc);
+				cachedElem.uvs = CM_NEW_ARRAY(Vector2, newNumQuads * 4, ScratchAlloc);
+				cachedElem.indexes = CM_NEW_ARRAY(UINT32, newNumQuads * 6, ScratchAlloc);
 				cachedElem.numQuads = newNumQuads;
 			}
 
@@ -405,7 +408,7 @@ namespace CamelotEngine
 			textLines[i]->fillBuffer(mCachedRenderElements, faceOffsets, *fontData);
 
 		for(size_t i = 0; i < textLines.size(); i++)
-			delete textLines[i];
+			CM_DELETE(textLines[i], TextLine, ScratchAlloc);
 
 		if(isClipRectangleValid())
 		{

CamelotForwardRenderer/Source/CmForwardRendererFactory.cpp

@@ -6,7 +6,7 @@ namespace CamelotEngine
 {
 	RendererPtr ForwardRendererFactory::create()
 	{
-		return RendererPtr(new ForwardRenderer());
+		return RendererPtr(CM_NEW(ForwardRenderer, GenAlloc) ForwardRenderer(), &MemAllocDeleter<ForwardRenderer, GenAlloc>::deleter);
 	}
 
 	const std::string& ForwardRendererFactory::name() const

CamelotForwardRenderer/Source/CmForwardRendererPlugin.cpp

@@ -11,6 +11,8 @@ namespace CamelotEngine
 
 	extern "C" CM_FWDRND_EXPORT void loadPlugin()
 	{
-		RendererManager::instance().registerFactory(RendererFactoryPtr(new ForwardRendererFactory()));
+		RendererManager::instance().registerFactory(
+			RendererFactoryPtr(CM_NEW(ForwardRendererFactory, GenAlloc) ForwardRendererFactory(),
+			&MemAllocDeleter<ForwardRendererFactory, GenAlloc>::deleter));
 	}
 }

CamelotOISInput/Source/CmOISPlugin.cpp

@@ -16,7 +16,7 @@ namespace CamelotEngine
 		// TODO - Window handles in Windows are 64 bits when compiled as x64, but OIS only accepts a 32bit value. Is this okay?
 		UINT32 windowId = (UINT32)gApplication().getAppWindowId();
 
-		InputHandlerOIS* inputHandler = new InputHandlerOIS(windowId);
-		gInput().registerInputHandler(inputHandler);
+		InputHandlerOIS* inputHandler = CM_NEW(InputHandlerOIS, GenAlloc) InputHandlerOIS(windowId);
+		gInput().registerInputHandler(InputHandlerPtr(inputHandler, &MemAllocDeleter<InputHandlerOIS, GenAlloc>::deleter));
 	}
 }

CamelotUtility/Include/CmRTTIType.h

@@ -8,6 +8,7 @@
 #include <boost/bind.hpp>
 #include <boost/type_traits.hpp>
 #include <boost/static_assert.hpp>
+#include <boost/preprocessor/punctuation/comma.hpp>
 
 #include "CmPrerequisitesUtil.h"
 #include "CmManagedDataBlock.h"
@@ -568,7 +569,8 @@ namespace CamelotEngine
 		template<class ObjectType, class DataType>
 		void addPlainField(const std::string& name, UINT32 uniqueId, boost::any getter, boost::any setter, UINT64 flags)
 		{
-			RTTIPlainField<DataType, ObjectType>* newField = new RTTIPlainField<DataType, ObjectType>();
+			RTTIPlainField<DataType, ObjectType>* newField = 
+				CM_NEW(RTTIPlainField<DataType BOOST_PP_COMMA() ObjectType>, GenAlloc) RTTIPlainField<DataType, ObjectType>();
 			newField->initSingle(name, uniqueId, getter, setter, flags);
 			addNewField(newField);
 		}
@@ -579,7 +581,8 @@ namespace CamelotEngine
 			BOOST_STATIC_ASSERT_MSG((boost::is_base_of<CamelotEngine::IReflectable, DataType>::value), 
 				"Invalid data type for complex field. It needs to derive from CamelotEngine::IReflectable.");
 
-			RTTIReflectableField<DataType, ObjectType>* newField = new RTTIReflectableField<DataType, ObjectType>();
+			RTTIReflectableField<DataType, ObjectType>* newField = 
+				CM_NEW(RTTIReflectableField<DataType BOOST_PP_COMMA() ObjectType>, GenAlloc) RTTIReflectableField<DataType, ObjectType>();
 			newField->initSingle(name, uniqueId, getter, setter, flags);
 			addNewField(newField);
 		}
@@ -593,7 +596,8 @@ namespace CamelotEngine
 			if((flags & RTTI_Flag_WeakRef) == 0)
 				checkForCircularReferences<DataType>();
 
-			RTTIReflectablePtrField<DataType, ObjectType>* newField = new RTTIReflectablePtrField<DataType, ObjectType>();
+			RTTIReflectablePtrField<DataType, ObjectType>* newField = 
+				CM_NEW(RTTIReflectablePtrField<DataType BOOST_PP_COMMA() ObjectType>, GenAlloc) RTTIReflectablePtrField<DataType, ObjectType>();
 			newField->initSingle(name, uniqueId, getter, setter, flags);
 			addNewField(newField);
 		}
@@ -602,7 +606,8 @@ namespace CamelotEngine
 		void addPlainArrayField(const std::string& name, UINT32 uniqueId, boost::any getter, boost::any getSize, 
 			boost::any setter, boost::any setSize, UINT64 flags)
 		{
-			RTTIPlainField<DataType, ObjectType>* newField = new RTTIPlainField<DataType, ObjectType>();
+			RTTIPlainField<DataType, ObjectType>* newField = 
+				CM_NEW(RTTIPlainField<DataType BOOST_PP_COMMA() ObjectType>, GenAlloc) RTTIPlainField<DataType, ObjectType>();
 			newField->initArray(name, uniqueId, getter, getSize, setter, setSize, flags);
 			addNewField(newField);
 		}	
@@ -614,7 +619,8 @@ namespace CamelotEngine
 			BOOST_STATIC_ASSERT_MSG((boost::is_base_of<CamelotEngine::IReflectable, DataType>::value), 
 				"Invalid data type for complex field. It needs to derive from CamelotEngine::IReflectable.");
 
-			RTTIReflectableField<DataType, ObjectType>* newField = new RTTIReflectableField<DataType, ObjectType>();
+			RTTIReflectableField<DataType, ObjectType>* newField = 
+				CM_NEW(RTTIReflectableField<DataType BOOST_PP_COMMA() ObjectType>, GenAlloc) RTTIReflectableField<DataType, ObjectType>();
 			newField->initArray(name, uniqueId, getter, getSize, setter, setSize, flags);
 			addNewField(newField);
 		}
@@ -629,7 +635,8 @@ namespace CamelotEngine
 			if((flags & RTTI_Flag_WeakRef) == 0)
 				checkForCircularReferences<DataType>();
 
-			RTTIReflectablePtrField<DataType, ObjectType>* newField = new RTTIReflectablePtrField<DataType, ObjectType>();
+			RTTIReflectablePtrField<DataType, ObjectType>* newField = 
+				CM_NEW(RTTIReflectablePtrField<DataType BOOST_PP_COMMA() ObjectType>, GenAlloc) RTTIReflectablePtrField<DataType, ObjectType>();
 			newField->initArray(name, uniqueId, getter, getSize, setter, setSize, flags);
 			addNewField(newField);
 		}
@@ -637,7 +644,8 @@ namespace CamelotEngine
 		template<class ObjectType>
 		void addDataBlockField(const std::string& name, UINT32 uniqueId, boost::any getter, boost::any setter, UINT64 flags)
 		{
-			RTTIManagedDataBlockField<ManagedDataBlock, ObjectType>* newField = new RTTIManagedDataBlockField<ManagedDataBlock, ObjectType>();
+			RTTIManagedDataBlockField<ManagedDataBlock, ObjectType>* newField = 
+				CM_NEW(RTTIManagedDataBlockField<ManagedDataBlock BOOST_PP_COMMA() ObjectType>, GenAlloc) RTTIManagedDataBlockField<ManagedDataBlock, ObjectType>();
 			newField->initSingle(name, uniqueId, getter,  setter, flags);
 			addNewField(newField);
 		}	

CamelotUtility/Source/CmDebug.cpp

@@ -49,14 +49,14 @@ namespace CamelotEngine
 		UINT32 bytesPerPixel = PixelUtil::getNumElemBytes(pixelData.format);
 
 		UINT32 bmpDataSize = BitmapWriter::getBMPSize(pixelData.getWidth(), pixelData.getHeight(), bytesPerPixel);
-		UINT8* bmpBuffer = new UINT8[bmpDataSize];
+		UINT8* bmpBuffer = CM_NEW_ARRAY(UINT8, bmpDataSize, ScratchAlloc);
 
 		BitmapWriter::rawPixelsToBMP((UINT8*)pixelData.data, bmpBuffer, pixelData.getWidth(), pixelData.getHeight(), bytesPerPixel);
 
 		ds->write(bmpBuffer, bmpDataSize);
 		ds->close();
 
-		delete [] bmpBuffer;
+		CM_DELETE_ARRAY(bmpBuffer, UINT8, bmpDataSize, ScratchAlloc);
 	}
 
 	CM_UTILITY_EXPORT Debug& gDebug()

CamelotUtility/Source/CmDynLibManager.cpp

@@ -44,7 +44,7 @@ namespace CamelotEngine
 		}
 		else
 		{
-	        DynLib* pLib = new DynLib(filename);
+	        DynLib* pLib = CM_NEW(DynLib, GenAlloc) DynLib(filename);
 			pLib->load();        
         	mLibList[filename] = pLib;
 	        return pLib;
@@ -59,7 +59,7 @@ namespace CamelotEngine
 			mLibList.erase(i);
 		}
 		lib->unload();
-		delete lib;
+		CM_DELETE(lib, DynLib, GenAlloc);
 	}
 	//-----------------------------------------------------------------------
     DynLibManager::~DynLibManager()
@@ -68,7 +68,7 @@ namespace CamelotEngine
         for( DynLibList::iterator it = mLibList.begin(); it != mLibList.end(); ++it )
         {
             it->second->unload();
-            delete it->second;
+			CM_DELETE(it->second, DynLib, GenAlloc);
         }
 
         // Empty the list

CamelotUtility/Source/CmFileSystem.cpp

@@ -45,13 +45,13 @@ namespace CamelotEngine
 		if (!readOnly)
 		{
 			mode |= std::ios::out;
-			rwStream = new std::fstream();
+			rwStream = CM_NEW(std::fstream, ScratchAlloc) std::fstream();
 			rwStream->open(fullPath.c_str(), mode);
 			baseStream = rwStream;
 		}
 		else
 		{
-			roStream = new std::ifstream();
+			roStream = CM_NEW(std::ifstream, ScratchAlloc) std::ifstream();
 			roStream->open(fullPath.c_str(), mode);
 			baseStream = roStream;
 		}
@@ -60,10 +60,10 @@ namespace CamelotEngine
 		if (baseStream->fail())
 		{
 			if(roStream != nullptr)
-				delete roStream;
+				CM_DELETE(roStream, std::ifstream, ScratchAlloc);
 
 			if(rwStream != nullptr)
-				delete rwStream;
+				CM_DELETE(rwStream, std::fstream, ScratchAlloc);
 
 			CM_EXCEPT(FileNotFoundException, "Cannot open file: " + fullPath);
 		}
@@ -73,14 +73,14 @@ namespace CamelotEngine
 		if (rwStream)
 		{
 			// use the writeable stream 
-			stream = new FileDataStream(fullPath, rwStream, (size_t)tagStat.st_size, true);
+			stream = CM_NEW(FileDataStream, ScratchAlloc) FileDataStream(fullPath, rwStream, (size_t)tagStat.st_size, true);
 		}
 		else
 		{
 			// read-only stream
-			stream = new FileDataStream(fullPath, roStream, (size_t)tagStat.st_size, true);
+			stream = CM_NEW(FileDataStream, ScratchAlloc) FileDataStream(fullPath, roStream, (size_t)tagStat.st_size, true);
 		}
-		return DataStreamPtr(stream);
+		return DataStreamPtr(stream, &MemAllocDeleter<FileDataStream, ScratchAlloc>::deleter);
 	}
 
 	DataStreamPtr FileSystem::create(const String& fullPath)
@@ -88,21 +88,21 @@ namespace CamelotEngine
 		// Always open in binary mode
 		// Also, always include reading
 		std::ios::openmode mode = std::ios::out | std::ios::binary;
-		std::fstream* rwStream = new std::fstream();
+		std::fstream* rwStream = CM_NEW(std::fstream, ScratchAlloc) std::fstream();
 		rwStream->open(fullPath.c_str(), mode);
 
 		// Should check ensure open succeeded, in case fail for some reason.
 		if (rwStream->fail())
 		{
 			if(rwStream != nullptr)
-				delete rwStream;
+				CM_DELETE(rwStream, std::fstream, ScratchAlloc); ;
 
 			CM_EXCEPT(FileNotFoundException, "Cannot open file: " + fullPath);
 		}
 
 		/// Construct return stream, tell it to delete on destroy
-		FileDataStream* stream = new FileDataStream(fullPath, rwStream, 0, true);
-		return DataStreamPtr(stream);
+		FileDataStream* stream = CM_NEW(FileDataStream, ScratchAlloc) FileDataStream(fullPath, rwStream, 0, true);
+		return DataStreamPtr(stream, &MemAllocDeleter<FileDataStream, ScratchAlloc>::deleter);
 	}
 
 	void FileSystem::remove(const String& fullPath)

CamelotUtility/Source/CmRTTIType.cpp

@@ -9,7 +9,7 @@ namespace CamelotEngine
 	RTTITypeBase::~RTTITypeBase() 
 	{
 		for(auto iter = mFields.begin(); iter != mFields.end(); ++iter)
-			delete *iter;
+			CM_DELETE(*iter, RTTIField, GenAlloc);
 
 		mFields.clear();
 	}