First batch of memory allocator porting from new/delete

CamelotClient/CamelotClient.cpp

@@ -85,7 +85,7 @@ int CALLBACK WinMain(
 		font = Importer::instance().import("C:\\arial.ttf", fontImportOptions);
 	}
 
-	//textSprite->setText(camera, "TESTfAV", font, 12);
+	textSprite->setText(camera, "TESTfAV", font, 12);
 
 #if defined DX9
 	///////////////// HLSL 9 SHADERS //////////////////////////

CamelotClient/CmTestTextSprite.cpp

@@ -20,12 +20,12 @@ namespace CamelotEngine
 	TestTextSprite::~TestTextSprite()
 	{
 		if(mSkin != nullptr)
-			delete mSkin;
+			CM_DELETE(mSkin, GUISkin, GUIAlloc);
 	}
 
 	void TestTextSprite::setText(const CameraPtr& camera, const String& text, FontHandle font, UINT32 fontSize)
 	{
-		mSkin = new GUISkin();
+		mSkin = CM_NEW(GUISkin, GUIAlloc) GUISkin();
 
 		OverlayManager::instance().attachOverlay(camera, this);		
 

CamelotCore/CamelotCore.vcxproj

@@ -176,6 +176,7 @@
     </Link>
   </ItemDefinitionGroup>
   <ItemGroup>
+    <ClInclude Include="Include\CmMemAllocCategories.h" />
     <ClInclude Include="Include\CmOverlay.h" />
     <ClInclude Include="Include\CmApplication.h" />
     <ClInclude Include="Include\CmBlendStateRTTI.h" />

CamelotCore/CamelotCore.vcxproj.filters

@@ -471,6 +471,9 @@
     <ClInclude Include="Include\CmOverlayManager.h">
       <Filter>Header Files\2D</Filter>
     </ClInclude>
+    <ClInclude Include="Include\CmMemAllocCategories.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Source\CamelotRenderer.cpp">

CamelotCore/Include/CmMemAllocCategories.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "CmMemoryAllocator.h"
+
+namespace CamelotEngine
+{
+	/**
+	 * @brief	Allocator used for various GUI elements.
+	 */
+	class GUIAlloc
+	{
+		
+	};
+
+	/**
+	 * @brief	Allocator used for allocating small amounts of temporary memory that
+	 * 			used and then quickly released
+	 */
+	class SmallScratchAlloc
+	{
+
+	};
+}
+

CamelotCore/Include/CmPrerequisites.h

@@ -84,6 +84,8 @@ THE SOFTWARE
 
 #endif
 
+#include "CmMemAllocCategories.h"
+
 namespace CamelotEngine {
 
 // Pre-declare classes

CamelotCore/Source/CmApplication.cpp

@@ -46,17 +46,17 @@ namespace CamelotEngine
 
 	void Application::startUp(const String& renderSystemName, const String& rendererName)
 	{
-		Time::startUp(new Time());
-		Input::startUp(new Input());
-		DynLibManager::startUp(new DynLibManager());
-		CoreGpuObjectManager::startUp(new CoreGpuObjectManager());
-		Resources::startUp(new Resources("D:\\CamelotResourceMetas"));
-		HighLevelGpuProgramManager::startUp(new HighLevelGpuProgramManager());
-
-		RenderSystemManager::startUp(new RenderSystemManager());
+		Time::startUp(CM_NEW(Time, GenAlloc) Time());
+		Input::startUp(CM_NEW(Input, GenAlloc) Input());
+		DynLibManager::startUp(CM_NEW(DynLibManager, GenAlloc) DynLibManager());
+		CoreGpuObjectManager::startUp(CM_NEW(CoreGpuObjectManager, GenAlloc) CoreGpuObjectManager());
+		Resources::startUp(CM_NEW(Resources, GenAlloc) Resources("D:\\CamelotResourceMetas"));
+		HighLevelGpuProgramManager::startUp(CM_NEW(HighLevelGpuProgramManager, GenAlloc) HighLevelGpuProgramManager());
+
+		RenderSystemManager::startUp(CM_NEW(RenderSystemManager, GenAlloc) RenderSystemManager());
 		RenderSystemManager::instance().setActive(renderSystemName);
 
-		RendererManager::startUp(new RendererManager());
+		RendererManager::startUp(CM_NEW(RendererManager, GenAlloc) RendererManager());
 
 		loadPlugin(rendererName);
 		RendererManager::instance().setActive("ForwardRenderer");
@@ -77,20 +77,20 @@ namespace CamelotEngine
 
 		mPrimaryRenderContext = renderSystem->createDeferredContext();
 
-		SceneManager::startUp(new SceneManager());
+		SceneManager::startUp(CM_NEW(SceneManager, GenAlloc) SceneManager());
 
-		MeshManager::startUp(new MeshManager());
-		MaterialManager::startUp(new MaterialManager());
-		FontManager::startUp(new FontManager());
+		MeshManager::startUp(CM_NEW(MeshManager, GenAlloc) MeshManager());
+		MaterialManager::startUp(CM_NEW(MaterialManager, GenAlloc) MaterialManager());
+		FontManager::startUp(CM_NEW(FontManager, GenAlloc) FontManager());
 
-		Importer::startUp(new Importer());
+		Importer::startUp(CM_NEW(Importer, GenAlloc) Importer());
 		loadPlugin("CamelotFreeImgImporter"); // TODO - Load this automatically somehow
 		loadPlugin("CamelotFBXImporter"); // TODO - Load this automatically somehow
 		loadPlugin("CamelotFontImporter"); // TODO - Load this automatically somehow
 
-		OverlayManager::startUp(new OverlayManager());
-		GUIMaterialManager::startUp(new GUIMaterialManager());
-		GUIManager::startUp(new GUIManager());
+		OverlayManager::startUp(CM_NEW(OverlayManager, GenAlloc) OverlayManager());
+		GUIMaterialManager::startUp(CM_NEW(GUIMaterialManager, GenAlloc) GUIMaterialManager());
+		GUIManager::startUp(CM_NEW(GUIManager, GenAlloc) GUIManager());
 
 		loadPlugin("CamelotOISInput"); // TODO - Load this automatically somehow
 	}

CamelotCore/Source/CmGUIWidget.cpp

@@ -23,7 +23,7 @@ namespace CamelotEngine
 
 		for(auto& elem : mElements)
 		{
-			delete elem;
+			CM_DELETE(elem, GUIElement, GUIAlloc);
 		}
 
 		mElements.clear();
@@ -31,7 +31,7 @@ namespace CamelotEngine
 
 	GUILabel* GUIWidget::addLabel(const String& text)
 	{
-		GUILabel* label = new GUILabel(this, text, getGUISkin());
+		GUILabel* label = CM_NEW(GUILabel, GUIAlloc) GUILabel(this, text, getGUISkin());
 		mElements.push_back(label);
 
 		return label;

CamelotCore/Source/CmRenderSystem.cpp

@@ -81,18 +81,18 @@ namespace CamelotEngine {
 
 		if(mCommandQueue != nullptr)
 		{
-			delete mCommandQueue;
+			CM_DELETE(mCommandQueue, CommandQueue, GenAlloc);
 			mCommandQueue = nullptr;
 		}
 
-		delete mCurrentCapabilities;
-		mCurrentCapabilities = 0;
+		CM_DELETE(mCurrentCapabilities, RenderSystemCapabilities, GenAlloc);
+		mCurrentCapabilities = nullptr;
     }
 	//-----------------------------------------------------------------------
 	void RenderSystem::initialize()
 	{
 		mRenderThreadId = CM_THREAD_CURRENT_ID;
-		mCommandQueue = new CommandQueue(CM_THREAD_CURRENT_ID, true);
+		mCommandQueue = CM_NEW(CommandQueue, GenAlloc) CommandQueue(CM_THREAD_CURRENT_ID, true);
 
 		initRenderThread();
 
@@ -273,7 +273,7 @@ namespace CamelotEngine {
 	void RenderSystem::initRenderThread()
 	{
 #if !CM_FORCE_SINGLETHREADED_RENDERING
-		mRenderThreadFunc = new RenderWorkerFunc(this);
+		mRenderThreadFunc = CM_NEW(RenderWorkerFunc, GenAlloc) RenderWorkerFunc(this);
 
 #if CM_THREAD_SUPPORT
 		CM_THREAD_CREATE(t, *mRenderThreadFunc);
@@ -344,6 +344,12 @@ namespace CamelotEngine {
 
 		mRenderThread = nullptr;
 		mRenderThreadId = CM_THREAD_CURRENT_ID;
+
+		if(mRenderThreadFunc != nullptr)
+		{
+			CM_DELETE(mRenderThreadFunc, RenderWorkerFunc, GenAlloc);
+			mRenderThreadFunc = nullptr;
+		}
 #endif
 
 		mRenderThreadStarted = false;

CamelotD3D11RenderSystem/Source/CmD3D11RenderSystem.cpp

@@ -68,7 +68,7 @@ namespace CamelotEngine
 		if(FAILED(hr))
 			CM_EXCEPT(RenderingAPIException, "Failed to create Direct3D11 DXGIFactory");
 
-		mDriverList = new D3D11DriverList(mDXGIFactory);
+		mDriverList = CM_NEW(D3D11DriverList, GenAlloc) D3D11DriverList(mDXGIFactory);
 		mActiveD3DDriver = mDriverList->item(0); // TODO: Always get first driver, for now
 
 		IDXGIAdapter* selectedAdapter = mActiveD3DDriver->getDeviceAdapter();
@@ -97,7 +97,7 @@ namespace CamelotEngine
 		if(FAILED(hr))         
 			CM_EXCEPT(RenderingAPIException, "Failed to create Direct3D11 object. D3D11CreateDeviceN returned this error code: " + toString(hr));
 
-		mDevice = new D3D11Device(device);
+		mDevice = CM_NEW(D3D11Device, GenAlloc) D3D11Device(device);
 
 		LARGE_INTEGER driverVersion;
 		if(SUCCEEDED(selectedAdapter->CheckInterfaceSupport(IID_ID3D10Device /* intentionally D3D10, not D3D11 */, &driverVersion)))
@@ -109,31 +109,31 @@ namespace CamelotEngine
 		}
 
 		// Create the texture manager for use by others		
-		TextureManager::startUp(new D3D11TextureManager());
+		TextureManager::startUp(CM_NEW(D3D11TextureManager, GenAlloc) D3D11TextureManager());
 
 		// Also create hardware buffer manager		
-		HardwareBufferManager::startUp(new D3D11HardwareBufferManager(*mDevice));
+		HardwareBufferManager::startUp(CM_NEW(D3D11HardwareBufferManager, GenAlloc) D3D11HardwareBufferManager(*mDevice));
 
 		// Create the GPU program manager		
-		GpuProgramManager::startUp(new D3D11GpuProgramManager(*mDevice));
+		GpuProgramManager::startUp(CM_NEW(D3D11GpuProgramManager, GenAlloc) D3D11GpuProgramManager(*mDevice));
 
 		// Create render window manager
-		RenderWindowManager::startUp(new D3D11RenderWindowManager(this));
+		RenderWindowManager::startUp(CM_NEW(D3D11RenderWindowManager, GenAlloc) D3D11RenderWindowManager(this));
 
 		// Create & register HLSL factory		
-		mHLSLFactory = new D3D11HLSLProgramFactory();
+		mHLSLFactory = CM_NEW(D3D11HLSLProgramFactory, GenAlloc) D3D11HLSLProgramFactory();
 
 		// Create render state manager
-		RenderStateManager::startUp(new D3D11RenderStateManager());
+		RenderStateManager::startUp(CM_NEW(D3D11RenderStateManager, GenAlloc) D3D11RenderStateManager());
 
 		mCurrentCapabilities = createRenderSystemCapabilities();
 
 		mCurrentCapabilities->addShaderProfile("hlsl");
 		HighLevelGpuProgramManager::instance().addFactory(mHLSLFactory);
 
-		mIAManager = new D3D11InputLayoutManager();
+		mIAManager = CM_NEW(D3D11InputLayoutManager, GenAlloc) D3D11InputLayoutManager();
 
-		BuiltinMaterialManager::startUp(new D3D11BuiltinMaterialManager());
+		BuiltinMaterialManager::startUp(CM_NEW(D3D11BuiltinMaterialManager, GenAlloc) D3D11BuiltinMaterialManager());
 
 		RenderSystem::initialize_internal();
 	}
@@ -142,8 +142,17 @@ namespace CamelotEngine
 	{
 		THROW_IF_NOT_RENDER_THREAD;
 
-		SAFE_DELETE(mIAManager);
-		SAFE_DELETE(mHLSLFactory);
+		if(mIAManager != nullptr)
+		{
+			CM_DELETE(mIAManager, D3D11InputLayoutManager, GenAlloc);
+			mIAManager = nullptr;
+		}
+
+		if(mHLSLFactory != nullptr)
+		{
+			CM_DELETE(mHLSLFactory, D3D11HLSLProgramFactory, GenAlloc);
+			mHLSLFactory = nullptr;
+		}
 
 		mActiveVertexDeclaration = nullptr;
 		mActiveVertexShader = nullptr;
@@ -156,8 +165,19 @@ namespace CamelotEngine
 		TextureManager::shutDown();
 
 		SAFE_RELEASE(mDXGIFactory);
-		SAFE_DELETE(mDevice);
-		SAFE_DELETE(mDriverList);
+
+		if(mDevice != nullptr)
+		{
+			CM_DELETE(mDevice, D3D11Device, GenAlloc);
+			mDevice = nullptr;
+		}
+
+		if(mDriverList != nullptr)
+		{
+			CM_DELETE(mDriverList, D3D11DriverList, GenAlloc);
+			mDriverList = nullptr;
+		}
+
 		mActiveD3DDriver = nullptr;
 
 		RenderSystem::destroy_internal();
@@ -557,13 +577,13 @@ namespace CamelotEngine
 		{
 			UINT32 maxRenderTargets = mCurrentCapabilities->getNumMultiRenderTargets();
 
-			ID3D11RenderTargetView** views = new ID3D11RenderTargetView*[maxRenderTargets];
+			ID3D11RenderTargetView** views = CM_NEW_ARRAY(ID3D11RenderTargetView*, maxRenderTargets, SmallScratchAlloc);
 			memset(views, 0, sizeof(ID3D11RenderTargetView*) * maxRenderTargets);
 
 			target->getCustomAttribute("RTV", views);
 			if (!views[0])
 			{
-				delete[] views;
+				CM_DELETE_ARRAY(views, ID3D11RenderTargetView*, maxRenderTargets, SmallScratchAlloc);
 				return;
 			}
 
@@ -579,7 +599,7 @@ namespace CamelotEngine
 					mDevice->getImmediateContext()->ClearRenderTargetView(views[i], clearColor);
 			}
 
-			delete[] views;
+			CM_DELETE_ARRAY(views, ID3D11RenderTargetView*, maxRenderTargets, SmallScratchAlloc);
 		}
 
 		// Clear depth stencil
@@ -610,12 +630,12 @@ namespace CamelotEngine
 
 		// Retrieve render surfaces
 		UINT32 maxRenderTargets = mCurrentCapabilities->getNumMultiRenderTargets();
-		ID3D11RenderTargetView** views = new ID3D11RenderTargetView*[maxRenderTargets];
+		ID3D11RenderTargetView** views = CM_NEW_ARRAY(ID3D11RenderTargetView*, maxRenderTargets, SmallScratchAlloc);
 		memset(views, 0, sizeof(ID3D11RenderTargetView*) * maxRenderTargets);
 		target->getCustomAttribute("RTV", views);
 		if (!views[0])
 		{
-			delete[] views;
+			CM_DELETE_ARRAY(views, ID3D11RenderTargetView*, maxRenderTargets, SmallScratchAlloc);
 			return;
 		}
 
@@ -628,7 +648,7 @@ namespace CamelotEngine
 		if (mDevice->hasError())
 			CM_EXCEPT(RenderingAPIException, "Failed to setRenderTarget : " + mDevice->getErrorDescription());
 
-		delete[] views;
+		CM_DELETE_ARRAY(views, ID3D11RenderTargetView*, maxRenderTargets, SmallScratchAlloc);
 	}
 
 	void D3D11RenderSystem::setClipPlanesImpl(const PlaneList& clipPlanes)
@@ -640,7 +660,7 @@ namespace CamelotEngine
 	{
 		THROW_IF_NOT_RENDER_THREAD;
 
-		RenderSystemCapabilities* rsc = new RenderSystemCapabilities();
+		RenderSystemCapabilities* rsc = CM_NEW(RenderSystemCapabilities, GenAlloc) RenderSystemCapabilities();
 
 		rsc->setDriverVersion(mDriverVersion);
 		rsc->setDeviceName(mActiveD3DDriver->getDriverDescription());

CamelotD3D11RenderSystem/Source/CmD3D11RenderSystemFactory.cpp

@@ -5,7 +5,7 @@ namespace CamelotEngine
 {
 	void D3D11RenderSystemFactory::create()
 	{
-		RenderSystem::startUp(new D3D11RenderSystem());
+		RenderSystem::startUp(CM_NEW(D3D11RenderSystem, GenAlloc) D3D11RenderSystem());
 	}
 
 	D3D11RenderSystemFactory::InitOnStart D3D11RenderSystemFactory::initOnStart;

CamelotD3D9Renderer/Include/CmD3D9RenderSystem.h

@@ -215,6 +215,7 @@ namespace CamelotEngine
 			IDirect3DBaseTexture9 *pVertexTex;
 		};
 
+		UINT32 mNumTexStages;
 		sD3DTextureStageDesc* mTexStageDesc;
 
 		D3D9DriverList* getDirect3DDrivers();

CamelotD3D9Renderer/Source/CmD3D9RenderSystem.cpp

@@ -92,6 +92,7 @@ namespace CamelotEngine
 	//---------------------------------------------------------------------
 	D3D9RenderSystem::D3D9RenderSystem( HINSTANCE hInstance )
 		: mTexStageDesc(nullptr)
+		, mNumTexStages(0)
 		, mCurrentDrawOperation(DOT_TRIANGLE_LIST)
 	{
 		// update singleton access pointer.
@@ -139,7 +140,7 @@ namespace CamelotEngine
 		THROW_IF_NOT_RENDER_THREAD;
 
 		// Create the resource manager.
-		mResourceManager = new D3D9ResourceManager();
+		mResourceManager = CM_NEW(D3D9ResourceManager, GenAlloc) D3D9ResourceManager();
 
 		// Create our Direct3D object
 		if( NULL == (mpD3D = Direct3DCreate9(D3D_SDK_VERSION)) )
@@ -160,30 +161,30 @@ namespace CamelotEngine
 		mDriverVersion.build = LOWORD(mActiveD3DDriver->getAdapterIdentifier().DriverVersion.LowPart);
 
 		// Create the device manager.
-		mDeviceManager = new D3D9DeviceManager();
+		mDeviceManager = CM_NEW(D3D9DeviceManager, GenAlloc) D3D9DeviceManager();
 
 		// Create the texture manager for use by others		
-		TextureManager::startUp(new D3D9TextureManager());
+		TextureManager::startUp(CM_NEW(D3D9TextureManager, GenAlloc) D3D9TextureManager());
 
 		// Also create hardware buffer manager		
-		HardwareBufferManager::startUp(new D3D9HardwareBufferManager());
+		HardwareBufferManager::startUp(CM_NEW(D3D9HardwareBufferManager, GenAlloc) D3D9HardwareBufferManager());
 
 		// Create the GPU program manager		
-		GpuProgramManager::startUp(new D3D9GpuProgramManager());
+		GpuProgramManager::startUp(CM_NEW(D3D9GpuProgramManager, GenAlloc) D3D9GpuProgramManager());
 
 		// Create & register HLSL factory		
-		mHLSLProgramFactory = new D3D9HLSLProgramFactory();
+		mHLSLProgramFactory = CM_NEW(D3D9HLSLProgramFactory, GenAlloc) D3D9HLSLProgramFactory();
 
 		// Create & register Cg factory		
-		mCgProgramFactory = new CgProgramFactory();
+		mCgProgramFactory = CM_NEW(CgProgramFactory, GenAlloc) CgProgramFactory();
 
 		// Create render window manager
-		RenderWindowManager::startUp(new D3D9RenderWindowManager(this));
+		RenderWindowManager::startUp(CM_NEW(D3D9RenderWindowManager, GenAlloc) D3D9RenderWindowManager(this));
 
 		// Create render state manager
-		RenderStateManager::startUp(new RenderStateManager());
+		RenderStateManager::startUp(CM_NEW(RenderStateManager, GenAlloc) RenderStateManager());
 
-		BuiltinMaterialManager::startUp(new D3D9BuiltinMaterialManager());
+		BuiltinMaterialManager::startUp(CM_NEW(D3D9BuiltinMaterialManager, GenAlloc) D3D9BuiltinMaterialManager());
 
 		// call superclass method
 		RenderSystem::initialize_internal();
@@ -193,15 +194,23 @@ namespace CamelotEngine
 	{
 		if(mTexStageDesc != nullptr)
 		{
-			delete[] mTexStageDesc;
+			CM_DELETE_ARRAY(mTexStageDesc, sD3DTextureStageDesc, mNumTexStages, GenAlloc);
 			mTexStageDesc = nullptr;
 		}
 
 		RenderSystem::destroy_internal();
 
-		SAFE_DELETE( mDeviceManager );
+		if(mDeviceManager != nullptr)
+		{
+			CM_DELETE(mDeviceManager, D3D9DeviceManager, GenAlloc);
+			mDeviceManager = nullptr;
+		}
 
-		SAFE_DELETE( mDriverList );
+		if(mDriverList != nullptr)
+		{
+			CM_DELETE(mDriverList, D3D9DriverList, GenAlloc);
+			mDriverList = nullptr;
+		}
 		mActiveD3DDriver = NULL;	
 
 		BuiltinMaterialManager::shutDown();
@@ -215,19 +224,24 @@ namespace CamelotEngine
 		if (mHLSLProgramFactory)
 		{
 			HighLevelGpuProgramManager::instance().removeFactory(mHLSLProgramFactory);
-			delete mHLSLProgramFactory;
+			CM_DELETE(mHLSLProgramFactory, D3D9HLSLProgramFactory, GenAlloc);
 			mHLSLProgramFactory = 0;
 		}
 
 		if(mCgProgramFactory)
 		{
 			HighLevelGpuProgramManager::instance().removeFactory(mCgProgramFactory);
-			delete mCgProgramFactory;
+			CM_DELETE(mCgProgramFactory, CgProgramFactory, GenAlloc);
 			mCgProgramFactory = 0;
 		}
 
 		SAFE_RELEASE( mpD3D );
-		SAFE_DELETE ( mResourceManager );
+
+		if(mResourceManager != nullptr)
+		{
+			CM_DELETE(mResourceManager, D3D9ResourceManager, GenAlloc);
+			mResourceManager = nullptr;
+		}
 
 		msD3D9RenderSystem = NULL;
 	}
@@ -1066,12 +1080,12 @@ namespace CamelotEngine
 
 		// Retrieve render surfaces
 		UINT32 maxRenderTargets = mCurrentCapabilities->getNumMultiRenderTargets();
-		IDirect3DSurface9** pBack = new IDirect3DSurface9*[maxRenderTargets];
+		IDirect3DSurface9** pBack = CM_NEW_ARRAY(IDirect3DSurface9*, maxRenderTargets, SmallScratchAlloc);
 		memset(pBack, 0, sizeof(IDirect3DSurface9*) * maxRenderTargets);
 		target->getCustomAttribute( "DDBACKBUFFER", pBack );
 		if (!pBack[0])
 		{
-			delete[] pBack;
+			CM_DELETE_ARRAY(pBack, IDirect3DSurface9*, maxRenderTargets, SmallScratchAlloc);
 			return;
 		}
 
@@ -1091,7 +1105,7 @@ namespace CamelotEngine
 			}
 		}
 
-		delete[] pBack;
+		CM_DELETE_ARRAY(pBack, IDirect3DSurface9*, maxRenderTargets, SmallScratchAlloc);
 
 		hr = getActiveD3D9Device()->SetDepthStencilSurface(pDepth);
 		if (FAILED(hr))
@@ -1538,7 +1552,7 @@ namespace CamelotEngine
 	D3D9DriverList* D3D9RenderSystem::getDirect3DDrivers()
 	{
 		if( !mDriverList )
-			mDriverList = new D3D9DriverList();
+			mDriverList = CM_NEW(D3D9DriverList, GenAlloc) D3D9DriverList();
 
 		return mDriverList;
 	}
@@ -1618,7 +1632,7 @@ namespace CamelotEngine
 	{			
 		RenderSystemCapabilities* rsc = mCurrentCapabilities;
 		if (rsc == NULL)
-			rsc = new RenderSystemCapabilities();
+			rsc = CM_NEW(RenderSystemCapabilities, GenAlloc) RenderSystemCapabilities();
 
 		rsc->setCategoryRelevant(CAPS_CATEGORY_D3D9, true);
 		rsc->setDriverVersion(mDriverVersion);
@@ -2233,11 +2247,11 @@ namespace CamelotEngine
 		if (caps->isShaderProfileSupported("cg"))
 			HighLevelGpuProgramManager::instance().addFactory(mCgProgramFactory);
 
-		UINT32 maxNumCombinedTextures = caps->getNumCombinedTextureUnits();
-		mTexStageDesc = new sD3DTextureStageDesc[maxNumCombinedTextures];
+		mNumTexStages = caps->getNumCombinedTextureUnits();
+		mTexStageDesc = CM_NEW_ARRAY(sD3DTextureStageDesc, mNumTexStages, GenAlloc);
 
 		// set stages desc. to defaults
-		for (UINT32 n = 0; n < maxNumCombinedTextures; n++)
+		for (UINT32 n = 0; n < mNumTexStages; n++)
 		{
 			mTexStageDesc[n].coordIndex = 0;
 			mTexStageDesc[n].texType = D3D9Mappings::D3D_TEX_TYPE_NORMAL;

CamelotD3D9Renderer/Source/CmD3D9RenderSystemFactory.cpp

@@ -11,7 +11,7 @@ namespace CamelotEngine
 		HINSTANCE hInst = GetModuleHandle( "CamelotD3D9RenderSystem.dll" );
 	#endif
 
-		RenderSystem::startUp(new D3D9RenderSystem(hInst));
+		RenderSystem::startUp(CM_NEW(D3D9RenderSystem, GenAlloc) D3D9RenderSystem(hInst));
 	}
 
 	D3D9RenderSystemFactory::InitOnStart D3D9RenderSystemFactory::initOnStart;

CamelotEditor/Source/CmEditorApplication.cpp

@@ -26,7 +26,7 @@ namespace CamelotEditor
 	};
 
 	EditorApplication::EditorApplication()
-		:p(new PImpl())
+		:p(CM_NEW(PImpl, GenAlloc) PImpl())
 	{
 		p->mApp = nullptr;
 		p->mEditor = nullptr;
@@ -34,22 +34,22 @@ namespace CamelotEditor
 
 	EditorApplication::~EditorApplication()
 	{
-		delete p;
+		CM_DELETE(p, PImpl, GenAlloc);
 	}
 
 	void EditorApplication::startUp()
 	{
-		EditorPrefs::startUp(new EditorPrefs());
+		EditorPrefs::startUp(CM_NEW(EditorPrefs, GenAlloc) EditorPrefs());
 
 		if(FileSystem::fileExists(getEditorPrefsPath().toStdString()))
 			gEditorPrefs().load(getEditorPrefsPath());
 		
-		ProjectPrefs::startUp(new ProjectPrefs());
+		ProjectPrefs::startUp(CM_NEW(EditorPrefs, GenAlloc) ProjectPrefs());
 
 		startUpQt();
 
-		EditorWindowManager::startUp(new EditorWindowManager());
-		WindowDockManager::startUp(new WindowDockManager(p->mEditor->getCentralWidget(), p->mEditor->getDockOverlayWidget()));
+		EditorWindowManager::startUp(CM_NEW(EditorWindowManager, GenAlloc) EditorWindowManager());
+		WindowDockManager::startUp(CM_NEW(WindowDockManager, GenAlloc) WindowDockManager(p->mEditor->getCentralWidget(), p->mEditor->getDockOverlayWidget()));
 
 		gEditorWindowManager().registerWidgetFactory(new SceneWidgetFactory());
 		gEditorWindowManager().registerWidgetFactory(new HierarchyWidgetFactory());

CamelotGLRenderer/Include/CmGLRenderSystem.h

@@ -218,6 +218,7 @@ namespace CamelotEngine {
         FilterOptions mMipFilter;
 
         /// Holds texture type settings for every stage
+        UINT32	mNumTextureTypes;
         GLenum* mTextureTypes;
 
         void initInputDevices(void);

CamelotGLRenderer/Source/CmGLRenderSystem.cpp

@@ -91,6 +91,7 @@ namespace CamelotEngine
 		mVertexTexOffset(0),
 		mGeometryTexOffset(0),
 		mTextureTypes(nullptr),
+		mNumTextureTypes(0),
 		mFragmentUBOffset(0),
 		mVertexUBOffset(0),
 		mGeometryUBOffset(0),
@@ -142,11 +143,11 @@ namespace CamelotEngine
 		THROW_IF_NOT_RENDER_THREAD;
 
 		mGLSupport->start();
-		RenderWindowManager::startUp(new GLRenderWindowManager(this));
+		RenderWindowManager::startUp(CM_NEW(GLRenderWindowManager, GenAlloc) GLRenderWindowManager(this));
 
-		RenderStateManager::startUp(new RenderStateManager());
+		RenderStateManager::startUp(CM_NEW(RenderStateManager, GenAlloc) RenderStateManager());
 
-		BuiltinMaterialManager::startUp(new GLBuiltinMaterialManager());
+		BuiltinMaterialManager::startUp(CM_NEW(GLBuiltinMaterialManager, GenAlloc) GLBuiltinMaterialManager());
 
 		RenderSystem::initialize_internal();
 	}
@@ -160,8 +161,8 @@ namespace CamelotEngine
 		{
 			// Remove from manager safely
 			HighLevelGpuProgramManager::instance().removeFactory(mGLSLProgramFactory);
-			delete mGLSLProgramFactory;
-			mGLSLProgramFactory = 0;
+			CM_DELETE(mGLSLProgramFactory, GLSLProgramFactory, GenAlloc);
+			mGLSLProgramFactory = nullptr;
 		}
 
 		// Deleting Cg GLSL program factory
@@ -169,8 +170,8 @@ namespace CamelotEngine
 		{
 			// Remove from manager safely
 			HighLevelGpuProgramManager::instance().removeFactory(mCgProgramFactory);
-			delete mCgProgramFactory;
-			mCgProgramFactory = 0;
+			CM_DELETE(mCgProgramFactory, CgProgramFactory, GenAlloc);
+			mCgProgramFactory = nullptr;
 		}
 
 		// Deleting the GPU program manager and hardware buffer manager.  Has to be done before the mGLSupport->stop().
@@ -217,6 +218,9 @@ namespace CamelotEngine
 
 		if(mGLSupport)
 			delete mGLSupport;
+
+		if(mTextureTypes != nullptr)
+			CM_DELETE_ARRAY(mTextureTypes, GLenum, mNumTextureTypes, GenAlloc);
 	}
 
 	//---------------------------------------------------------------------
@@ -1818,25 +1822,23 @@ namespace CamelotEngine
 			glUnmapBufferARB = glUnmapBuffer;
 		}
 
-		HardwareBufferManager::startUp(new GLHardwareBufferManager);
+		HardwareBufferManager::startUp(CM_NEW(GLHardwareBufferManager, GenAlloc) GLHardwareBufferManager);
 		checkForErrors();
 
 		// GPU Program Manager setup
-		GpuProgramManager::startUp(new GLGpuProgramManager());
+		GpuProgramManager::startUp(CM_NEW(GLGpuProgramManager, GenAlloc) GLGpuProgramManager());
 		checkForErrors();
 
 		if(caps->isShaderProfileSupported("glsl"))
 		{
-			// NFZ - check for GLSL vertex and fragment shader support successful
-			mGLSLProgramFactory = new GLSLProgramFactory();
+			mGLSLProgramFactory = CM_NEW(GLSLProgramFactory, GenAlloc) GLSLProgramFactory();
 			HighLevelGpuProgramManager::instance().addFactory(mGLSLProgramFactory);
 			checkForErrors();
 		}
 
 		if(caps->isShaderProfileSupported("cg"))
 		{
-			// NFZ - check for GLSL vertex and fragment shader support successful
-			mCgProgramFactory = new CgProgramFactory();
+			mCgProgramFactory = CM_NEW(CgProgramFactory, GenAlloc) CgProgramFactory();
 			HighLevelGpuProgramManager::instance().addFactory(mCgProgramFactory);
 			checkForErrors();
 		}
@@ -1870,7 +1872,7 @@ namespace CamelotEngine
 			if(caps->hasCapability(RSC_HWRENDER_TO_TEXTURE))
 			{
 				// Create FBO manager
-				GLRTTManager::startUp(new GLRTTManager());
+				GLRTTManager::startUp(CM_NEW(GLRTTManager, GenAlloc) GLRTTManager());
 				checkForErrors();
 			}
 		}
@@ -1895,7 +1897,8 @@ namespace CamelotEngine
 		if(totalNumTexUnits > numCombinedTexUnits)
 			CM_EXCEPT(InternalErrorException, "Number of combined texture units less than the number of individual units!?");
 
-		mTextureTypes = new GLenum[numCombinedTexUnits];
+		mNumTextureTypes = numCombinedTexUnits;
+		mTextureTypes = CM_NEW_ARRAY(GLenum, mNumTextureTypes, GenAlloc);
 		for(UINT16 i = 0; i < numCombinedTexUnits; i++)
 			mTextureTypes[i] = 0;
 
@@ -1918,7 +1921,7 @@ namespace CamelotEngine
 			CM_EXCEPT(InternalErrorException, "Number of combined uniform block buffers less than the number of individual per-stage buffers!?");
 
 		/// Create the texture manager        
-		TextureManager::startUp(new GLTextureManager(*mGLSupport)); 
+		TextureManager::startUp(CM_NEW(GLTextureManager, GenAlloc) GLTextureManager(*mGLSupport)); 
 		checkForErrors();
 
 		mGLInitialised = true;
@@ -1926,7 +1929,7 @@ namespace CamelotEngine
 
 	RenderSystemCapabilities* GLRenderSystem::createRenderSystemCapabilities() const
 	{
-		RenderSystemCapabilities* rsc = new RenderSystemCapabilities();
+		RenderSystemCapabilities* rsc = CM_NEW(RenderSystemCapabilities, GenAlloc) RenderSystemCapabilities();
 
 		rsc->setCategoryRelevant(CAPS_CATEGORY_GL, true);
 		rsc->setDriverVersion(mDriverVersion);

CamelotGLRenderer/Source/CmGLRenderSystemFactory.cpp

@@ -5,7 +5,7 @@ namespace CamelotEngine
 {
 	void GLRenderSystemFactory::create()
 	{
-		RenderSystem::startUp(new GLRenderSystem());
+		RenderSystem::startUp(CM_NEW(GLRenderSystem, GenAlloc) GLRenderSystem());
 	}
 
 	GLRenderSystemFactory::InitOnStart GLRenderSystemFactory::initOnStart;

CamelotUtility/CamelotUtility.vcxproj

@@ -186,6 +186,7 @@
     <ClInclude Include="Include\CmLog.h" />
     <ClInclude Include="Include\CmManagedDataBlock.h" />
     <ClInclude Include="Include\CmMathAsm.h" />
+    <ClInclude Include="Include\CmMemoryAllocator.h" />
     <ClInclude Include="Include\CmModule.h" />
     <ClInclude Include="Include\CmPath.h" />
     <ClInclude Include="Include\CmPixelData.h" />

CamelotUtility/CamelotUtility.vcxproj.filters

@@ -222,6 +222,9 @@
     <ClInclude Include="Include\CmTexAtlasGenerator.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="Include\CmMemoryAllocator.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Include\CmAxisAlignedBox.cpp">

CamelotUtility/Include/CmMemoryAllocator.h

@@ -0,0 +1,73 @@
+#pragma once
+
+namespace CamelotEngine
+{
+	/**
+	 * @brief	Memory allocator providing a generic implementation. 
+	 * 			Specialize for specific categories as needed.
+	 */
+	template<class T>
+	class MemoryAllocator
+	{
+	public:
+		static inline void* allocate(unsigned int bytes)
+		{
+			return malloc(bytes);
+		}
+
+		static inline void* allocateArray(unsigned int bytes, UINT32 count)
+		{
+			return malloc(bytes * count);
+		}
+
+		static inline void free(void* ptr)
+		{
+			::free(ptr);
+		}
+
+		static inline void freeArray(void* ptr, UINT32 count)
+		{
+			::free(ptr);
+		}
+	};
+
+	template<class T, class category> 
+	inline T* __cm_construct_array(unsigned int count)
+	{
+		T* ptr = (T*)MemoryAllocator<category>::allocateArray(sizeof(T), count);
+
+		for(unsigned int i = 0; i < count; i++)
+			new ((void*)&ptr[i]) T;
+
+		return ptr;
+	}
+
+	template<class T, class category> 
+	inline void __cm_destruct(T* ptr)
+	{
+		(ptr)->~T();
+
+		MemoryAllocator<category>::free(ptr);
+	}
+
+	template<class T, class category> 
+	inline void __cm_destruct_array(T* ptr, unsigned int count)
+	{
+		// This might seem a bit weird if T is a built-in type or a pointer, but
+		// standard allows us to call destructor on such types (they don't do anything)
+		for(unsigned int i = 0; i < count; i++)
+			ptr[i].~T();
+
+		MemoryAllocator<category>::freeArray(ptr, count);
+	}
+
+	class GenAlloc
+	{ };
+}
+
+#define CM_NEW(T, category) new (MemoryAllocator<category>::allocate(sizeof(T)))
+#define CM_NEW_ARRAY(T, count, category) __cm_construct_array<T, category>(count)
+#define CM_DELETE(ptr, T, category) __cm_destruct<T, category>(ptr)
+#define CM_DELETE_ARRAY(ptr, T, count, category) __cm_destruct_array<T, category>(ptr, count)
+
+

CamelotUtility/Include/CmModule.h

@@ -79,7 +79,7 @@ namespace CamelotEngine
 
 			_instance->onShutDown();
 
-			delete _instance;
+			CM_DELETE(_instance, T, GenAlloc);
 			isShutDown = true;
 		}
 

CamelotUtility/Include/CmPrerequisitesUtil.h

@@ -72,4 +72,6 @@ THE SOFTWARE
 
 #include "CmRTTIPrerequisites.h"
 
-#include "CmString.h"
+#include "CmString.h"
+
+#include "CmMemoryAllocator.h"

TODO.txt

@@ -27,6 +27,9 @@ Add TextUtil class
 
  When rendering GUIWidget its individual elements need to be sorted based on Z depth so the transparency works as expected
 
+ Port gameObjects and components so that they are no shared pointers. They are meant to be destroyed on shutdown and I can't have calling code keep references to them.
+ - But how do I easily do GameObject.Destroy or Component.Destroy, while notifying any code referencing them?
+
 Immediate TODO:
  BuiltinMaterialManager creates a shader before shader factory is initialized