Removed the useless HardwareBufferManagerBase

CamelotD3D11RenderSystem/Include/CmD3D11HardwareBufferManager.h

@@ -5,11 +5,11 @@
 
 namespace CamelotEngine
 {
-	class CM_D3D11_EXPORT D3D11HardwareBufferManagerBase : public HardwareBufferManagerBase
+	class CM_D3D11_EXPORT D3D11HardwareBufferManager : public HardwareBufferManager
 	{
 	public:
-		D3D11HardwareBufferManagerBase(D3D11Device& device);
-		~D3D11HardwareBufferManagerBase();
+		D3D11HardwareBufferManager(D3D11Device& device);
+		~D3D11HardwareBufferManager();
 
 		/**
 		 * @brief	Creates a hardware vertex buffer.
@@ -42,17 +42,4 @@ namespace CamelotEngine
 
 		D3D11Device& mDevice;
 	};
-
-	class CM_D3D11_EXPORT D3D11HardwareBufferManager : public HardwareBufferManager
-	{
-	public:
-		D3D11HardwareBufferManager(D3D11Device& device)
-			: HardwareBufferManager(new D3D11HardwareBufferManagerBase(device)) 
-		{ }
-
-		~D3D11HardwareBufferManager()
-		{
-			delete mImpl;
-		}
-	};
 }

CamelotD3D11RenderSystem/Include/CmD3D11HardwareConstantBuffer.h

@@ -10,7 +10,7 @@ namespace CamelotEngine
 	class CM_D3D11_EXPORT D3D11HardwareConstantBuffer
 	{
 	public:
-		D3D11HardwareConstantBuffer(D3D11Device& device, HardwareBufferManagerBase* mgr, UINT32 sizeBytes, 
+		D3D11HardwareConstantBuffer(D3D11Device& device, HardwareBufferManager* mgr, UINT32 sizeBytes, 
 			GpuBufferUsage usage, bool useSystemMem);
 		~D3D11HardwareConstantBuffer();
 

CamelotD3D11RenderSystem/Include/CmD3D11IndexBuffer.h

@@ -9,7 +9,7 @@ namespace CamelotEngine
 	class CM_D3D11_EXPORT D3D11IndexBuffer : public IndexBuffer
 	{
 	public:
-		D3D11IndexBuffer(D3D11Device& device, HardwareBufferManagerBase* mgr, IndexType idxType, UINT32 numIndexes, 
+		D3D11IndexBuffer(D3D11Device& device, HardwareBufferManager* mgr, IndexType idxType, UINT32 numIndexes, 
 			GpuBufferUsage usage, bool useSystemMem);
 		~D3D11IndexBuffer();
 

CamelotD3D11RenderSystem/Include/CmD3D11VertexBuffer.h

@@ -9,7 +9,7 @@ namespace CamelotEngine
 	class CM_D3D11_EXPORT D3D11VertexBuffer : public VertexBuffer
 	{
 	public:
-		D3D11VertexBuffer(D3D11Device& device, HardwareBufferManagerBase* mgr, UINT32 vertexSize, UINT32 numVertices, 
+		D3D11VertexBuffer(D3D11Device& device, HardwareBufferManager* mgr, UINT32 vertexSize, UINT32 numVertices, 
 			GpuBufferUsage usage, bool useSystemMem, bool streamOut);
 		~D3D11VertexBuffer();
 

CamelotD3D11RenderSystem/Source/CmD3D11HardwareBufferManager.cpp

@@ -8,16 +8,16 @@
 
 namespace CamelotEngine
 {
-	D3D11HardwareBufferManagerBase::D3D11HardwareBufferManagerBase(D3D11Device& device)
+	D3D11HardwareBufferManager::D3D11HardwareBufferManager(D3D11Device& device)
 		: mDevice(device)
 	{ }
 
-	D3D11HardwareBufferManagerBase::~D3D11HardwareBufferManagerBase()
+	D3D11HardwareBufferManager::~D3D11HardwareBufferManager()
 	{
 		destroyAllBindings();
 	}
 
-	HardwareVertexBufferPtr D3D11HardwareBufferManagerBase::createVertexBuffer(UINT32 vertexSize, 
+	HardwareVertexBufferPtr D3D11HardwareBufferManager::createVertexBuffer(UINT32 vertexSize, 
 		UINT32 numVerts, GpuBufferUsage usage, bool streamOut)
 	{
 		assert (numVerts > 0);
@@ -30,7 +30,7 @@ namespace CamelotEngine
 		return HardwareVertexBufferPtr(vbuf);
 	}
 
-	HardwareIndexBufferPtr D3D11HardwareBufferManagerBase::createIndexBuffer(IndexBuffer::IndexType itype, 
+	HardwareIndexBufferPtr D3D11HardwareBufferManager::createIndexBuffer(IndexBuffer::IndexType itype, 
 		UINT32 numIndexes, GpuBufferUsage usage)
 	{
 		assert (numIndexes > 0);
@@ -45,23 +45,23 @@ namespace CamelotEngine
 		return HardwareIndexBufferPtr(idx);
 	}
 
-	GpuParamBlockPtr D3D11HardwareBufferManagerBase::createGpuParamBlock(const GpuParamBlockDesc& blockDesc)
+	GpuParamBlockPtr D3D11HardwareBufferManager::createGpuParamBlock(const GpuParamBlockDesc& blockDesc)
 	{
 		return GpuParamBlockPtr(new GpuParamBlock(blockDesc));
 	}
 
-	GenericBufferPtr D3D11HardwareBufferManagerBase::createGenericBuffer(UINT32 elementCount, UINT32 elementSize, 
+	GenericBufferPtr D3D11HardwareBufferManager::createGenericBuffer(UINT32 elementCount, UINT32 elementSize, 
 		GenericBufferType type, GpuBufferUsage usage, bool randomGpuWrite, bool useCounter)
 	{
 		return GenericBufferPtr(new D3D11GenericBuffer(elementCount, elementSize, type, usage, randomGpuWrite, useCounter));
 	}
 
-	VertexDeclarationPtr D3D11HardwareBufferManagerBase::createVertexDeclarationImpl(void)
+	VertexDeclarationPtr D3D11HardwareBufferManager::createVertexDeclarationImpl(void)
 	{
 		return VertexDeclarationPtr(new D3D11VertexDeclaration());
 	}
 
-	void D3D11HardwareBufferManagerBase::destroyVertexDeclarationImpl(VertexDeclaration* decl)
+	void D3D11HardwareBufferManager::destroyVertexDeclarationImpl(VertexDeclaration* decl)
 	{
 		delete decl;
 	}

CamelotD3D11RenderSystem/Source/CmD3D11HardwareConstantBuffer.cpp

@@ -2,7 +2,7 @@
 
 namespace CamelotEngine
 {
-	D3D11HardwareConstantBuffer::D3D11HardwareConstantBuffer(D3D11Device& device, HardwareBufferManagerBase* mgr, UINT32 sizeBytes, 
+	D3D11HardwareConstantBuffer::D3D11HardwareConstantBuffer(D3D11Device& device, HardwareBufferManager* mgr, UINT32 sizeBytes, 
 		GpuBufferUsage usage, bool useSystemMem)
 		//:HardwareConstantBuffer(mgr, sizeBytes, usage, useSystemMem)
 	{

CamelotD3D11RenderSystem/Source/CmD3D11IndexBuffer.cpp

@@ -2,7 +2,7 @@
 
 namespace CamelotEngine
 {
-	D3D11IndexBuffer::D3D11IndexBuffer(D3D11Device& device, HardwareBufferManagerBase* mgr, IndexType idxType, UINT32 numIndexes, 
+	D3D11IndexBuffer::D3D11IndexBuffer(D3D11Device& device, HardwareBufferManager* mgr, IndexType idxType, UINT32 numIndexes, 
 		GpuBufferUsage usage, bool useSystemMem)
 		:IndexBuffer(mgr, idxType, numIndexes, usage, useSystemMem)
 	{

CamelotD3D11RenderSystem/Source/CmD3D11RenderSystem.cpp

@@ -34,8 +34,8 @@ namespace CamelotEngine
 
 	void D3D11RenderSystem::initialize_internal()
 	{
-		HRESULT hr = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&mDXGIFactory);
-		if(FAILED(hr))
+		HRESULT hr = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&mDXGIFactory);
+		if(FAILED(hr))
 			CM_EXCEPT(RenderingAPIException, "Failed to create Direct3D11 DXGIFactory");
 
 		mDriverList = new D3D11DriverList(mDXGIFactory);
@@ -43,33 +43,33 @@ namespace CamelotEngine
 
 		IDXGIAdapter* selectedAdapter = mActiveD3DDriver->getDeviceAdapter();
 
-		D3D_FEATURE_LEVEL requestedLevels[] = {
-			D3D_FEATURE_LEVEL_11_0,
-			D3D_FEATURE_LEVEL_10_1,
-			D3D_FEATURE_LEVEL_10_0,
-			D3D_FEATURE_LEVEL_9_3,
-			D3D_FEATURE_LEVEL_9_2,
-			D3D_FEATURE_LEVEL_9_1
+		D3D_FEATURE_LEVEL requestedLevels[] = {
+			D3D_FEATURE_LEVEL_11_0,
+			D3D_FEATURE_LEVEL_10_1,
+			D3D_FEATURE_LEVEL_10_0,
+			D3D_FEATURE_LEVEL_9_3,
+			D3D_FEATURE_LEVEL_9_2,
+			D3D_FEATURE_LEVEL_9_1
 		};
 
 		UINT32 numRequestedLevel = sizeof(requestedLevels) / sizeof(requestedLevels[0]);
 
 		ID3D11Device* device;
-		hr = D3D11CreateDevice(selectedAdapter, D3D_DRIVER_TYPE_HARDWARE, nullptr, 0, 
-			requestedLevels, numRequestedLevel, D3D11_SDK_VERSION, &device, &mFeatureLevel, 0);
-
-		if(FAILED(hr))         
+		hr = D3D11CreateDevice(selectedAdapter, D3D_DRIVER_TYPE_HARDWARE, nullptr, 0, 
+			requestedLevels, numRequestedLevel, D3D11_SDK_VERSION, &device, &mFeatureLevel, 0);
+
+		if(FAILED(hr))         
 			CM_EXCEPT(RenderingAPIException, "Failed to create Direct3D11 object. D3D11CreateDeviceN returned this error code: " + toString(hr));
 
 		mDevice = new D3D11Device(device);
 
-		LARGE_INTEGER driverVersion;
-		if(SUCCEEDED(selectedAdapter->CheckInterfaceSupport(IID_ID3D10Device /* intentionally D3D10, not D3D11 */, &driverVersion)))
-		{
-			mDriverVersion.major = HIWORD(driverVersion.HighPart);
-			mDriverVersion.minor = LOWORD(driverVersion.HighPart);
-			mDriverVersion.release = HIWORD(driverVersion.LowPart);
-			mDriverVersion.build = LOWORD(driverVersion.LowPart);
+		LARGE_INTEGER driverVersion;
+		if(SUCCEEDED(selectedAdapter->CheckInterfaceSupport(IID_ID3D10Device /* intentionally D3D10, not D3D11 */, &driverVersion)))
+		{
+			mDriverVersion.major = HIWORD(driverVersion.HighPart);
+			mDriverVersion.minor = LOWORD(driverVersion.HighPart);
+			mDriverVersion.release = HIWORD(driverVersion.LowPart);
+			mDriverVersion.build = LOWORD(driverVersion.LowPart);
 		}
 
 		// Create the texture manager for use by others		
@@ -230,109 +230,109 @@ namespace CamelotEngine
 
 	void D3D11RenderSystem::determineFSAASettings(UINT32 fsaa, const String& fsaaHint, DXGI_FORMAT format, DXGI_SAMPLE_DESC* outFSAASettings)
 	{
-		bool ok = false;
-		bool qualityHint = fsaaHint.find("Quality") != String::npos;
-		size_t origFSAA = fsaa;
-		bool tryCSAA = false;
-		// NVIDIA, prefer CSAA if available for 8+
-		// it would be tempting to use getCapabilities()->getVendor() == GPU_NVIDIA but
-		// if this is the first window, caps will not be initialised yet
-		
-		if (mActiveD3DDriver->getAdapterIdentifier().VendorId == 0x10DE && 
-			fsaa >= 8)
-		{
-			tryCSAA	 = true;
-		}
-
-		while (!ok)
-		{
-			// Deal with special cases
-			if (tryCSAA)
-			{
-				// see http://developer.nvidia.com/object/coverage-sampled-aa.html
-				switch(fsaa)
-				{
-				case 8:
-					if (qualityHint)
-					{
-						outFSAASettings->Count = 8;
-						outFSAASettings->Quality = 8;
-					}
-					else
-					{
-						outFSAASettings->Count = 4;
-						outFSAASettings->Quality = 8;
-					}
-					break;
-				case 16:
-					if (qualityHint)
-					{
-						outFSAASettings->Count = 8;
-						outFSAASettings->Quality = 16;
-					}
-					else
-					{
-						outFSAASettings->Count = 4;
-						outFSAASettings->Quality = 16;
-					}
-					break;
-				}
-			}
-			else // !CSAA
-			{
-				outFSAASettings->Count = fsaa == 0 ? 1 : fsaa;
-				outFSAASettings->Quality = 0;
-			}
-
-
-			HRESULT hr;
-			UINT outQuality;
-			hr = mDevice->getD3D11Device()->CheckMultisampleQualityLevels(format, outFSAASettings->Count, &outQuality);
-
-			if (SUCCEEDED(hr) && (!tryCSAA || outQuality > outFSAASettings->Quality))
-			{
-				ok = true;
-			}
-			else
-			{
-				// downgrade
-				if (tryCSAA && fsaa == 8)
-				{
-					// for CSAA, we'll try downgrading with quality mode at all samples.
-					// then try without quality, then drop CSAA
-					if (qualityHint)
-					{
-						// drop quality first
-						qualityHint = false;
-					}
-					else
-					{
-						// drop CSAA entirely 
-						tryCSAA = false;
-					}
-					// return to original requested samples
-					fsaa = static_cast<UINT32>(origFSAA);
-				}
-				else
-				{
-					// drop samples
-					--fsaa;
-
-					if (fsaa == 1)
-					{
-						// ran out of options, no FSAA
-						fsaa = 0;
-						ok = true;
-					}
-				}
-			}
-
+		bool ok = false;
+		bool qualityHint = fsaaHint.find("Quality") != String::npos;
+		size_t origFSAA = fsaa;
+		bool tryCSAA = false;
+		// NVIDIA, prefer CSAA if available for 8+
+		// it would be tempting to use getCapabilities()->getVendor() == GPU_NVIDIA but
+		// if this is the first window, caps will not be initialised yet
+		
+		if (mActiveD3DDriver->getAdapterIdentifier().VendorId == 0x10DE && 
+			fsaa >= 8)
+		{
+			tryCSAA	 = true;
+		}
+
+		while (!ok)
+		{
+			// Deal with special cases
+			if (tryCSAA)
+			{
+				// see http://developer.nvidia.com/object/coverage-sampled-aa.html
+				switch(fsaa)
+				{
+				case 8:
+					if (qualityHint)
+					{
+						outFSAASettings->Count = 8;
+						outFSAASettings->Quality = 8;
+					}
+					else
+					{
+						outFSAASettings->Count = 4;
+						outFSAASettings->Quality = 8;
+					}
+					break;
+				case 16:
+					if (qualityHint)
+					{
+						outFSAASettings->Count = 8;
+						outFSAASettings->Quality = 16;
+					}
+					else
+					{
+						outFSAASettings->Count = 4;
+						outFSAASettings->Quality = 16;
+					}
+					break;
+				}
+			}
+			else // !CSAA
+			{
+				outFSAASettings->Count = fsaa == 0 ? 1 : fsaa;
+				outFSAASettings->Quality = 0;
+			}
+
+
+			HRESULT hr;
+			UINT outQuality;
+			hr = mDevice->getD3D11Device()->CheckMultisampleQualityLevels(format, outFSAASettings->Count, &outQuality);
+
+			if (SUCCEEDED(hr) && (!tryCSAA || outQuality > outFSAASettings->Quality))
+			{
+				ok = true;
+			}
+			else
+			{
+				// downgrade
+				if (tryCSAA && fsaa == 8)
+				{
+					// for CSAA, we'll try downgrading with quality mode at all samples.
+					// then try without quality, then drop CSAA
+					if (qualityHint)
+					{
+						// drop quality first
+						qualityHint = false;
+					}
+					else
+					{
+						// drop CSAA entirely 
+						tryCSAA = false;
+					}
+					// return to original requested samples
+					fsaa = static_cast<UINT32>(origFSAA);
+				}
+				else
+				{
+					// drop samples
+					--fsaa;
+
+					if (fsaa == 1)
+					{
+						// ran out of options, no FSAA
+						fsaa = 0;
+						ok = true;
+					}
+				}
+			}
+
 		} // while !ok
 	}
-
-	bool D3D11RenderSystem::checkTextureFilteringSupported(TextureType ttype, PixelFormat format, int usage)
-	{
-		return true;
+
+	bool D3D11RenderSystem::checkTextureFilteringSupported(TextureType ttype, PixelFormat format, int usage)
+	{
+		return true;
 	}
 
 	VertexElementType D3D11RenderSystem::getColorVertexElementType() const
@@ -342,21 +342,21 @@ namespace CamelotEngine
 
 	void D3D11RenderSystem::convertProjectionMatrix(const Matrix4& matrix, Matrix4& dest, bool forGpuProgram /*= false */)
 	{
-		dest = matrix;
-
-		// Convert depth range from [-1,+1] to [0,1]
-		dest[2][0] = (dest[2][0] + dest[3][0]) / 2;
-		dest[2][1] = (dest[2][1] + dest[3][1]) / 2;
-		dest[2][2] = (dest[2][2] + dest[3][2]) / 2;
-		dest[2][3] = (dest[2][3] + dest[3][3]) / 2;
-
-		if (!forGpuProgram)
-		{
-			// Convert right-handed to left-handed
-			dest[0][2] = -dest[0][2];
-			dest[1][2] = -dest[1][2];
-			dest[2][2] = -dest[2][2];
-			dest[3][2] = -dest[3][2];
+		dest = matrix;
+
+		// Convert depth range from [-1,+1] to [0,1]
+		dest[2][0] = (dest[2][0] + dest[3][0]) / 2;
+		dest[2][1] = (dest[2][1] + dest[3][1]) / 2;
+		dest[2][2] = (dest[2][2] + dest[3][2]) / 2;
+		dest[2][3] = (dest[2][3] + dest[3][3]) / 2;
+
+		if (!forGpuProgram)
+		{
+			// Convert right-handed to left-handed
+			dest[0][2] = -dest[0][2];
+			dest[1][2] = -dest[1][2];
+			dest[2][2] = -dest[2][2];
+			dest[3][2] = -dest[3][2];
 		}
 	}
 

CamelotD3D11RenderSystem/Source/CmD3D11VertexBuffer.cpp

@@ -2,7 +2,7 @@
 
 namespace CamelotEngine
 {
-	D3D11VertexBuffer::D3D11VertexBuffer(D3D11Device& device, HardwareBufferManagerBase* mgr, UINT32 vertexSize, UINT32 numVertices, 
+	D3D11VertexBuffer::D3D11VertexBuffer(D3D11Device& device, HardwareBufferManager* mgr, UINT32 vertexSize, UINT32 numVertices, 
 		GpuBufferUsage usage, bool useSystemMem, bool streamOut)
 		:VertexBuffer(mgr, vertexSize, numVertices, usage, useSystemMem)
 	{

CamelotD3D9Renderer/Include/CmD3D9HardwareBufferManager.h

@@ -34,7 +34,7 @@ THE SOFTWARE.
 namespace CamelotEngine {
 
     /** Implementation of HardwareBufferManager for D3D9. */
-    class CM_D3D9_EXPORT D3D9HardwareBufferManagerBase : public HardwareBufferManagerBase
+    class CM_D3D9_EXPORT D3D9HardwareBufferManager : public HardwareBufferManager
     {
     protected:     
         /// Internal method for creates a new vertex declaration, may be overridden by certain rendering APIs
@@ -43,48 +43,30 @@ namespace CamelotEngine {
         void destroyVertexDeclarationImpl(VertexDeclaration* decl);
 
     public:
-        D3D9HardwareBufferManagerBase();
-        ~D3D9HardwareBufferManagerBase();
+        D3D9HardwareBufferManager();
+        ~D3D9HardwareBufferManager();
 
 		/**
-		 * @copydoc HardwareBufferManagerBase::createVertexBuffer
+		 * @copydoc HardwareBufferManager::createVertexBuffer
 		 */
-		HardwareVertexBufferPtr 
-            createVertexBuffer(UINT32 vertexSize, UINT32 numVerts, GpuBufferUsage usage, bool streamOut = false);
+		HardwareVertexBufferPtr createVertexBuffer(UINT32 vertexSize, UINT32 numVerts, GpuBufferUsage usage, bool streamOut = false);
 
 		/**
-		 * @copydoc HardwareBufferManagerBase::createIndexBuffer
+		 * @copydoc HardwareBufferManager::createIndexBuffer
 		 */
-		HardwareIndexBufferPtr 
-            createIndexBuffer(IndexBuffer::IndexType itype, UINT32 numIndexes, GpuBufferUsage usage);
+		HardwareIndexBufferPtr createIndexBuffer(IndexBuffer::IndexType itype, UINT32 numIndexes, GpuBufferUsage usage);
 
-		/** @copydoc HardwareBufferManagerInterface::createGpuParamBlock */
+		/** @copydoc HardwareBufferManager::createGpuParamBlock */
 		GpuParamBlockPtr createGpuParamBlock(const GpuParamBlockDesc& paramDesc);
 
 		/**
-		 * @copydoc HardwareBufferManagerInterface::createGpuParamBlock
+		 * @copydoc HardwareBufferManager::createGenericBuffer
 		 *
 		 * DirectX 9 does not support generic buffers so this method will return a dummy instance.
 		 */
 		GenericBufferPtr createGenericBuffer(UINT32 elementCount, UINT32 elementSize, 
 			GenericBufferType type, GpuBufferUsage usage, bool randomGpuWrite = false, bool useCounter = false);
     };
-
-	/// D3D9HardwareBufferManagerBase as a Singleton
-	class CM_D3D9_EXPORT D3D9HardwareBufferManager : public HardwareBufferManager
-	{
-	public:
-		D3D9HardwareBufferManager()
-			: HardwareBufferManager(new D3D9HardwareBufferManagerBase()) 
-		{
-
-		}
-		~D3D9HardwareBufferManager()
-		{
-			delete mImpl;
-		}
-	};
-
 }
 
 

CamelotD3D9Renderer/Include/CmD3D9IndexBuffer.h

@@ -39,7 +39,7 @@ namespace CamelotEngine {
     {
   
     public:
-		D3D9IndexBuffer(HardwareBufferManagerBase* mgr, IndexType idxType, UINT32 numIndexes, 
+		D3D9IndexBuffer(HardwareBufferManager* mgr, IndexType idxType, UINT32 numIndexes, 
 			GpuBufferUsage usage, bool useSystemMem);
         ~D3D9IndexBuffer();
         /** See HardwareBuffer. */

CamelotD3D9Renderer/Include/CmD3D9VertexBuffer.h

@@ -39,7 +39,7 @@ namespace CamelotEngine {
     {   
 
     public:
-		D3D9VertexBuffer(HardwareBufferManagerBase* mgr, UINT32 vertexSize, 
+		D3D9VertexBuffer(HardwareBufferManager* mgr, UINT32 vertexSize, 
 			UINT32 numVertices, GpuBufferUsage usage, bool useSystemMem);
         ~D3D9VertexBuffer();
         /** See HardwareBuffer. */

CamelotD3D9Renderer/Source/CmD3D9HardwareBufferManager.cpp

@@ -35,18 +35,16 @@ THE SOFTWARE.
 
 namespace CamelotEngine {
     //-----------------------------------------------------------------------
-    D3D9HardwareBufferManagerBase::D3D9HardwareBufferManagerBase()       
+    D3D9HardwareBufferManager::D3D9HardwareBufferManager()       
     {
     }
     //-----------------------------------------------------------------------
-    D3D9HardwareBufferManagerBase::~D3D9HardwareBufferManagerBase()
+    D3D9HardwareBufferManager::~D3D9HardwareBufferManager()
     {
         destroyAllBindings();
     }
     //-----------------------------------------------------------------------
-    HardwareVertexBufferPtr 
-    D3D9HardwareBufferManagerBase::
-    createVertexBuffer(UINT32 vertexSize, UINT32 numVerts, GpuBufferUsage usage, bool streamOut)
+    HardwareVertexBufferPtr D3D9HardwareBufferManager::createVertexBuffer(UINT32 vertexSize, UINT32 numVerts, GpuBufferUsage usage, bool streamOut)
     {
 		assert (numVerts > 0);
 
@@ -58,9 +56,7 @@ namespace CamelotEngine {
         return HardwareVertexBufferPtr(vbuf);
     }
     //-----------------------------------------------------------------------
-	HardwareIndexBufferPtr 
-    D3D9HardwareBufferManagerBase::
-    createIndexBuffer(IndexBuffer::IndexType itype, UINT32 numIndexes, GpuBufferUsage usage)
+	HardwareIndexBufferPtr D3D9HardwareBufferManager::createIndexBuffer(IndexBuffer::IndexType itype, UINT32 numIndexes, GpuBufferUsage usage)
     {
 		assert (numIndexes > 0);
 
@@ -72,23 +68,23 @@ namespace CamelotEngine {
             
     }
 	//-----------------------------------------------------------------------
-	GpuParamBlockPtr D3D9HardwareBufferManagerBase::createGpuParamBlock(const GpuParamBlockDesc& paramDesc)
+	GpuParamBlockPtr D3D9HardwareBufferManager::createGpuParamBlock(const GpuParamBlockDesc& paramDesc)
 	{
 		return GpuParamBlockPtr(new GpuParamBlock(paramDesc));
 	}
 	//-----------------------------------------------------------------------
-	GenericBufferPtr D3D9HardwareBufferManagerBase::createGenericBuffer(UINT32 elementCount, UINT32 elementSize, 
+	GenericBufferPtr D3D9HardwareBufferManager::createGenericBuffer(UINT32 elementCount, UINT32 elementSize, 
 		GenericBufferType type, GpuBufferUsage usage, bool randomGpuWrite, bool useCounter)
 	{
 		return GenericBufferPtr(new D3D9GenericBuffer(elementCount, elementSize, type, usage, randomGpuWrite, useCounter));
 	}
     //-----------------------------------------------------------------------
-    VertexDeclarationPtr D3D9HardwareBufferManagerBase::createVertexDeclarationImpl(void)
+    VertexDeclarationPtr D3D9HardwareBufferManager::createVertexDeclarationImpl(void)
     {
         return VertexDeclarationPtr(new D3D9VertexDeclaration());
     }
     //-----------------------------------------------------------------------
-    void D3D9HardwareBufferManagerBase::destroyVertexDeclarationImpl(VertexDeclaration* decl)
+    void D3D9HardwareBufferManager::destroyVertexDeclarationImpl(VertexDeclaration* decl)
     {
         delete decl;
     }

CamelotD3D9Renderer/Source/CmD3D9IndexBuffer.cpp

@@ -36,7 +36,7 @@ THE SOFTWARE.
 namespace CamelotEngine {
 
 	//---------------------------------------------------------------------
-    D3D9IndexBuffer::D3D9IndexBuffer(HardwareBufferManagerBase* mgr, IndexBuffer::IndexType idxType, 
+    D3D9IndexBuffer::D3D9IndexBuffer(HardwareBufferManager* mgr, IndexBuffer::IndexType idxType, 
         UINT32 numIndexes, GpuBufferUsage usage,
         bool useSystemMemory)
         : IndexBuffer(mgr, idxType, numIndexes, usage, useSystemMemory)

CamelotD3D9Renderer/Source/CmD3D9VertexBuffer.cpp

@@ -36,7 +36,7 @@ THE SOFTWARE.
 namespace CamelotEngine {
 
 	//---------------------------------------------------------------------
-    D3D9VertexBuffer::D3D9VertexBuffer(HardwareBufferManagerBase* mgr, UINT32 vertexSize, 
+    D3D9VertexBuffer::D3D9VertexBuffer(HardwareBufferManager* mgr, UINT32 vertexSize, 
         UINT32 numVertices, GpuBufferUsage usage, 
         bool useSystemMemory)
 		: VertexBuffer(mgr, vertexSize, numVertices, usage, useSystemMemory)

CamelotGLRenderer/Include/CmGLHardwareBufferManager.h

@@ -34,11 +34,11 @@ THE SOFTWARE.
 namespace CamelotEngine {
 
 // Default threshold at which glMapBuffer becomes more efficient than glBufferSubData (32k?)
-#	define OGRE_GL_DEFAULT_MAP_BUFFER_THRESHOLD (1024 * 32)
+#	define CM_GL_DEFAULT_MAP_BUFFER_THRESHOLD (1024 * 32)
 
 
     /** Implementation of HardwareBufferManager for OpenGL. */
-    class CM_RSGL_EXPORT GLHardwareBufferManagerBase : public HardwareBufferManagerBase
+    class CM_RSGL_EXPORT GLHardwareBufferManager : public HardwareBufferManager
     {
 	protected:
 		char* mScratchBufferPool;
@@ -46,27 +46,27 @@ namespace CamelotEngine {
 		UINT32 mMapBufferThreshold;
 
     public:
-        GLHardwareBufferManagerBase();
-        ~GLHardwareBufferManagerBase();
+        GLHardwareBufferManager();
+        ~GLHardwareBufferManager();
 
 		/**
-		 * @copydoc HardwareBufferManagerBase::createVertexBuffer
+		 * @copydoc HardwareBufferManager::createVertexBuffer
 		 */
         HardwareVertexBufferPtr createVertexBuffer(UINT32 vertexSize, 
             UINT32 numVerts, GpuBufferUsage usage, bool streamOut = false);
 
 		/**
-		 * @copydoc HardwareBufferManagerBase::createIndexBuffer
+		 * @copydoc HardwareBufferManager::createIndexBuffer
 		 */
         HardwareIndexBufferPtr createIndexBuffer(
             IndexBuffer::IndexType itype, UINT32 numIndexes, 
             GpuBufferUsage usage);
 
-		/** @copydoc HardwareBufferManagerInterface::createGpuParamBlock */
+		/** @copydoc HardwareBufferManager::createGpuParamBlock */
 		GpuParamBlockPtr createGpuParamBlock(const GpuParamBlockDesc& paramDesc);
 
 		/**
-		 * @copydoc HardwareBufferManagerInterface::createGpuParamBlock
+		 * @copydoc HardwareBufferManager::createGenericBuffer
 		 *
 		 * OpenGL does not support generic buffers so this method will return a dummy instance.
 		 */
@@ -96,62 +96,6 @@ namespace CamelotEngine {
 		const UINT32 getGLMapBufferThreshold() const;
 		void setGLMapBufferThreshold( const UINT32 value );
     };
-
-	/// GLHardwareBufferManagerBase as a Singleton
-	class CM_RSGL_EXPORT GLHardwareBufferManager : public HardwareBufferManager
-	{
-	public:
-		GLHardwareBufferManager()
-			: HardwareBufferManager(new GLHardwareBufferManagerBase()) 
-		{
-
-		}
-		~GLHardwareBufferManager()
-		{
-			delete mImpl;
-		}
-
-
-
-		/// Utility function to get the correct GL usage based on HBU's
-		static GLenum getGLUsage(unsigned int usage) 
-		{ return GLHardwareBufferManagerBase::getGLUsage(usage); }
-
-		/// Utility function to get the correct GL type based on VET's
-		static GLenum getGLType(unsigned int type)
-		{ return GLHardwareBufferManagerBase::getGLType(type); }
-
-		/** Allocator method to allow us to use a pool of memory as a scratch
-		area for hardware buffers. This is because glMapBuffer is incredibly
-		inefficient, seemingly no matter what options we give it. So for the
-		period of lock/unlock, we will instead allocate a section of a local
-		memory pool, and use glBufferSubDataARB / glGetBufferSubDataARB
-		instead.
-		*/
-		void* allocateScratch(UINT32 size)
-		{
-			return static_cast<GLHardwareBufferManagerBase*>(mImpl)->allocateScratch(size);
-		}
-
-		/// @see allocateScratch
-		void deallocateScratch(void* ptr)
-		{
-			static_cast<GLHardwareBufferManagerBase*>(mImpl)->deallocateScratch(ptr);
-		}
-
-		/** Threshold after which glMapBuffer is used and not glBufferSubData
-		*/
-		const UINT32 getGLMapBufferThreshold() const
-		{
-			return static_cast<GLHardwareBufferManagerBase*>(mImpl)->getGLMapBufferThreshold();
-		}
-		void setGLMapBufferThreshold( const UINT32 value )
-		{
-			static_cast<GLHardwareBufferManagerBase*>(mImpl)->setGLMapBufferThreshold(value);
-		}
-
-	};
-
 }
 
 #endif // __GLHARWAREBUFFERMANAGER_H__

CamelotGLRenderer/Include/CmGLIndexBuffer.h

@@ -50,7 +50,7 @@ namespace CamelotEngine {
         /** See HardwareBuffer. */
         void unlockImpl(void);
     public:
-        GLIndexBuffer(HardwareBufferManagerBase* mgr, IndexType idxType, UINT32 numIndexes, 
+        GLIndexBuffer(HardwareBufferManager* mgr, IndexType idxType, UINT32 numIndexes, 
             GpuBufferUsage usage); 
         ~GLIndexBuffer();
         /** See HardwareBuffer. */

CamelotGLRenderer/Include/CmGLVertexBuffer.h

@@ -51,7 +51,7 @@ namespace CamelotEngine {
         /** See HardwareBuffer. */
         void unlockImpl(void);
     public:
-        GLVertexBuffer(HardwareBufferManagerBase* mgr, UINT32 vertexSize, UINT32 numVertices, GpuBufferUsage usage); 
+        GLVertexBuffer(HardwareBufferManager* mgr, UINT32 vertexSize, UINT32 numVertices, GpuBufferUsage usage); 
         ~GLVertexBuffer();
         /** See HardwareBuffer. */
         void readData(UINT32 offset, UINT32 length, void* pDest);

CamelotGLRenderer/Source/CmGLHardwareBufferManager.cpp

@@ -47,8 +47,8 @@ namespace CamelotEngine {
 	#define SCRATCH_POOL_SIZE 1 * 1024 * 1024
 	#define SCRATCH_ALIGNMENT 32
 	//---------------------------------------------------------------------
-    GLHardwareBufferManagerBase::GLHardwareBufferManagerBase() 
-		: mScratchBufferPool(NULL), mMapBufferThreshold(OGRE_GL_DEFAULT_MAP_BUFFER_THRESHOLD)
+    GLHardwareBufferManager::GLHardwareBufferManager() 
+		: mScratchBufferPool(NULL), mMapBufferThreshold(CM_GL_DEFAULT_MAP_BUFFER_THRESHOLD)
     {
 		// Init scratch pool
 		// TODO make it a configurable size?
@@ -75,14 +75,14 @@ namespace CamelotEngine {
 
     }
     //-----------------------------------------------------------------------
-    GLHardwareBufferManagerBase::~GLHardwareBufferManagerBase()
+    GLHardwareBufferManager::~GLHardwareBufferManager()
     {
         destroyAllBindings();
 
 		_aligned_free(mScratchBufferPool);
     }
     //-----------------------------------------------------------------------
-    HardwareVertexBufferPtr GLHardwareBufferManagerBase::createVertexBuffer(
+    HardwareVertexBufferPtr GLHardwareBufferManager::createVertexBuffer(
         UINT32 vertexSize, UINT32 numVerts, GpuBufferUsage usage, bool streamOut)
     {
 		GLVertexBuffer* buf = 
@@ -94,7 +94,7 @@ namespace CamelotEngine {
     }
     //-----------------------------------------------------------------------
     HardwareIndexBufferPtr 
-    GLHardwareBufferManagerBase::createIndexBuffer(
+    GLHardwareBufferManager::createIndexBuffer(
         IndexBuffer::IndexType itype, UINT32 numIndexes, 
         GpuBufferUsage usage)
     {
@@ -106,18 +106,18 @@ namespace CamelotEngine {
 		return HardwareIndexBufferPtr(buf);
     }
 	//---------------------------------------------------------------------
-	GpuParamBlockPtr GLHardwareBufferManagerBase::createGpuParamBlock(const GpuParamBlockDesc& paramDesc)
+	GpuParamBlockPtr GLHardwareBufferManager::createGpuParamBlock(const GpuParamBlockDesc& paramDesc)
 	{
 		return GpuParamBlockPtr(new GLGpuParamBlock(paramDesc));
 	}
 	//---------------------------------------------------------------------
-	GenericBufferPtr GLHardwareBufferManagerBase::createGenericBuffer(UINT32 elementCount, UINT32 elementSize, 
+	GenericBufferPtr GLHardwareBufferManager::createGenericBuffer(UINT32 elementCount, UINT32 elementSize, 
 		GenericBufferType type, GpuBufferUsage usage, bool randomGpuWrite, bool useCounter)
 	{
 		return GenericBufferPtr(new GLGenericBuffer(elementCount, elementSize, type, usage, randomGpuWrite, useCounter));
 	}
     //---------------------------------------------------------------------
-    GLenum GLHardwareBufferManagerBase::getGLUsage(unsigned int usage)
+    GLenum GLHardwareBufferManager::getGLUsage(unsigned int usage)
     {
         switch(usage)
         {
@@ -130,7 +130,7 @@ namespace CamelotEngine {
         };
     }
     //---------------------------------------------------------------------
-    GLenum GLHardwareBufferManagerBase::getGLType(unsigned int type)
+    GLenum GLHardwareBufferManager::getGLType(unsigned int type)
     {
         switch(type)
         {
@@ -155,7 +155,7 @@ namespace CamelotEngine {
     }
 	//---------------------------------------------------------------------
 	//---------------------------------------------------------------------
-	void* GLHardwareBufferManagerBase::allocateScratch(UINT32 size)
+	void* GLHardwareBufferManager::allocateScratch(UINT32 size)
 	{
 		// simple forward link search based on alloc sizes
 		// not that fast but the list should never get that long since not many
@@ -208,7 +208,7 @@ namespace CamelotEngine {
 
 	}
 	//---------------------------------------------------------------------
-	void GLHardwareBufferManagerBase::deallocateScratch(void* ptr)
+	void GLHardwareBufferManager::deallocateScratch(void* ptr)
 	{
 		CM_LOCK_MUTEX(mScratchMutex)
 
@@ -263,12 +263,12 @@ namespace CamelotEngine {
 
 	}
 	//---------------------------------------------------------------------
-	const UINT32 GLHardwareBufferManagerBase::getGLMapBufferThreshold() const
+	const UINT32 GLHardwareBufferManager::getGLMapBufferThreshold() const
 	{
 		return mMapBufferThreshold;
 	}
 	//---------------------------------------------------------------------
-	void GLHardwareBufferManagerBase::setGLMapBufferThreshold( const UINT32 value )
+	void GLHardwareBufferManager::setGLMapBufferThreshold( const UINT32 value )
 	{
 		mMapBufferThreshold = value;
 	}

CamelotGLRenderer/Source/CmGLIndexBuffer.cpp

@@ -32,7 +32,7 @@ THE SOFTWARE.
 namespace CamelotEngine {
 
 	//---------------------------------------------------------------------
-    GLIndexBuffer::GLIndexBuffer(HardwareBufferManagerBase* mgr, IndexType idxType,
+    GLIndexBuffer::GLIndexBuffer(HardwareBufferManager* mgr, IndexType idxType,
         UINT32 numIndexes, GpuBufferUsage usage)
         : IndexBuffer(mgr, idxType, numIndexes, usage, false)
     {

CamelotGLRenderer/Source/CmGLVertexBuffer.cpp

@@ -32,7 +32,7 @@ THE SOFTWARE.
 namespace CamelotEngine {
 
 	//---------------------------------------------------------------------
-    GLVertexBuffer::GLVertexBuffer(HardwareBufferManagerBase* mgr, UINT32 vertexSize, 
+    GLVertexBuffer::GLVertexBuffer(HardwareBufferManager* mgr, UINT32 vertexSize, 
         UINT32 numVertices, GpuBufferUsage usage)
         : VertexBuffer(mgr, vertexSize, numVertices, usage, false)
     {

CamelotRenderer/Include/CmHardwareBufferManager.h

@@ -45,17 +45,8 @@ namespace CamelotEngine {
 	*/
 
 	/** Base definition of a hardware buffer manager.
-	@remarks
-		This class is deliberately not a Singleton, so that multiple types can 
-		exist at once. The Singleton is wrapped via the Decorator pattern
-		in HardwareBufferManager, below. Each concrete implementation should
-		provide a subclass of HardwareBufferManagerBase, which does the actual
-		work, and also a very simple subclass of HardwareBufferManager which 
-		simply constructs the instance of the HardwareBufferManagerBase subclass 
-		and passes it to the HardwareBufferManager superclass as a delegate. 
-		This subclass must also delete the implementation instance it creates.
 	*/
-	class CM_EXPORT HardwareBufferManagerBase
+	class CM_EXPORT HardwareBufferManager : public Module<HardwareBufferManager>
 	{
     protected:
         /** WARNING: The following three members should place before all other members.
@@ -84,8 +75,8 @@ namespace CamelotEngine {
 		virtual void destroyVertexBufferBindingImpl(VertexBufferBinding* binding);
 
     public:
-        HardwareBufferManagerBase();
-        virtual ~HardwareBufferManagerBase();
+        HardwareBufferManager();
+        virtual ~HardwareBufferManager();
 		/** Create a hardware vertex buffer.
         @remarks
             This method creates a new vertex buffer; this will act as a source of geometry
@@ -161,67 +152,6 @@ namespace CamelotEngine {
 		void _notifyIndexBufferDestroyed(IndexBuffer* buf);
 	};
 
-    /** Singleton wrapper for hardware buffer manager. */
-    class CM_EXPORT HardwareBufferManager : public HardwareBufferManagerBase, public Module<HardwareBufferManager>
-    {
-    protected:
-		HardwareBufferManagerBase* mImpl;
-	public:
-		HardwareBufferManager(HardwareBufferManagerBase* imp);
-		~HardwareBufferManager();
-
-		/** @copydoc HardwareBufferManagerInterface::createVertexBuffer */
-		HardwareVertexBufferPtr createVertexBuffer(UINT32 vertexSize, UINT32 numVerts, GpuBufferUsage usage, bool streamOut = false)
-		{
-			return mImpl->createVertexBuffer(vertexSize, numVerts, usage, streamOut);
-		}
-		/** @copydoc HardwareBufferManagerInterface::createIndexBuffer */
-		HardwareIndexBufferPtr createIndexBuffer(IndexBuffer::IndexType itype, UINT32 numIndexes, GpuBufferUsage usage)
-		{
-			return mImpl->createIndexBuffer(itype, numIndexes, usage);
-		}
-
-		/** @copydoc HardwareBufferManagerInterface::createGpuParamBlock */
-		GpuParamBlockPtr createGpuParamBlock(const GpuParamBlockDesc& paramDesc)
-		{
-			return mImpl->createGpuParamBlock(paramDesc);
-		}
-
-		/** @copydoc HardwareBufferManagerInterface::createGenericBuffer */
-		GenericBufferPtr createGenericBuffer(UINT32 elementCount, UINT32 elementSize, 
-			GenericBufferType type, GpuBufferUsage usage, bool randomGpuWrite = false, bool useCounter = false)
-		{
-			return mImpl->createGenericBuffer(elementCount, elementSize, type, usage, randomGpuWrite, useCounter);
-		}
-
-		/** @copydoc HardwareBufferManagerInterface::createVertexDeclaration */
-		virtual VertexDeclarationPtr createVertexDeclaration(void)
-		{
-			return mImpl->createVertexDeclaration();
-		}
-
-		/** @copydoc HardwareBufferManagerInterface::createVertexBufferBinding */
-		virtual VertexBufferBinding* createVertexBufferBinding(void)
-		{
-			return mImpl->createVertexBufferBinding();
-		}
-		/** @copydoc HardwareBufferManagerInterface::destroyVertexBufferBinding */
-		virtual void destroyVertexBufferBinding(VertexBufferBinding* binding)
-		{
-			mImpl->destroyVertexBufferBinding(binding);
-		}
-		/** @copydoc HardwareBufferManagerInterface::_notifyVertexBufferDestroyed */
-		void _notifyVertexBufferDestroyed(VertexBuffer* buf)
-		{
-			mImpl->_notifyVertexBufferDestroyed(buf);
-		}
-		/** @copydoc HardwareBufferManagerInterface::_notifyIndexBufferDestroyed */
-		void _notifyIndexBufferDestroyed(IndexBuffer* buf)
-		{
-			mImpl->_notifyIndexBufferDestroyed(buf);
-		}            
-    };
-
 	/** @} */
 	/** @} */
 }

CamelotRenderer/Include/CmIndexBuffer.h

@@ -32,9 +32,8 @@ THE SOFTWARE.
 #include "CmPrerequisites.h"
 #include "CmHardwareBuffer.h"
 
-namespace CamelotEngine {
-	class HardwareBufferManagerBase;
-
+namespace CamelotEngine 
+{
 	/** \addtogroup Core
 	*  @{
 	*/
@@ -51,18 +50,18 @@ namespace CamelotEngine {
 		    };
 
 	    protected:
-			HardwareBufferManagerBase* mMgr;
+			HardwareBufferManager* mMgr;
 		    IndexType mIndexType;
 		    UINT32 mNumIndexes;
             UINT32 mIndexSize;
 
 	    public:
 		    /// Should be called by HardwareBufferManager
-		    IndexBuffer(HardwareBufferManagerBase* mgr, IndexType idxType, UINT32 numIndexes, GpuBufferUsage usage,
+		    IndexBuffer(HardwareBufferManager* mgr, IndexType idxType, UINT32 numIndexes, GpuBufferUsage usage,
                 bool useSystemMemory);
             ~IndexBuffer();
 			/// Return the manager of this buffer, if any
-			HardwareBufferManagerBase* getManager() const { return mMgr; }
+			HardwareBufferManager* getManager() const { return mMgr; }
     		/// Get the type of indexes used in this buffer
             IndexType getType(void) const { return mIndexType; }
             /// Get the number of indexes in this buffer

CamelotRenderer/Include/CmPrerequisites.h

@@ -106,7 +106,7 @@ namespace CamelotEngine {
 	class WorkQueue;
 	class PassParameters;
 	class AsyncOp;
-	class HardwareBufferManagerBase;
+	class HardwareBufferManager;
 	class HardwareConstantBuffer;
 	class CommandQueue;
 	class DeferredRenderContext;

CamelotRenderer/Include/CmVertexBuffer.h

@@ -34,9 +34,8 @@ THE SOFTWARE.
 #include "CmIReflectable.h"
 #include "CmColor.h"
 
-namespace CamelotEngine {
-	class HardwareBufferManagerBase;
-
+namespace CamelotEngine 
+{
 	/** \addtogroup Core
 	*  @{
 	*/
@@ -47,17 +46,17 @@ namespace CamelotEngine {
     class CM_EXPORT VertexBuffer : public HardwareBuffer
     {
 	    protected:
-			HardwareBufferManagerBase* mMgr;
+			HardwareBufferManager* mMgr;
 		    UINT32 mNumVertices;
             UINT32 mVertexSize;
 
 	    public:
 		    /// Should be called by HardwareBufferManager
-		    VertexBuffer(HardwareBufferManagerBase* mgr, UINT32 vertexSize, UINT32 numVertices,
+		    VertexBuffer(HardwareBufferManager* mgr, UINT32 vertexSize, UINT32 numVertices,
                 GpuBufferUsage usage, bool useSystemMemory);
             ~VertexBuffer();
 			/// Return the manager of this buffer, if any
-			HardwareBufferManagerBase* getManager() const { return mMgr; }
+			HardwareBufferManager* getManager() const { return mMgr; }
             /// Gets the size in bytes of a single vertex in this buffer
             UINT32 getVertexSize(void) const { return mVertexSize; }
             /// Get the number of vertices in this buffer

CamelotRenderer/Include/CmVertexDeclaration.h

@@ -356,7 +356,7 @@ namespace CamelotEngine
 		@param mgr Optional HardwareBufferManager to use for creating the clone
 			(if null, use the current default).
 		*/
-        virtual VertexDeclarationPtr clone(HardwareBufferManagerBase* mgr = 0);
+        virtual VertexDeclarationPtr clone(HardwareBufferManager* mgr = 0);
 
         inline bool operator== (const VertexDeclaration& rhs) const
         {

CamelotRenderer/Include/CmVertexIndexData.h

@@ -54,7 +54,7 @@ namespace CamelotEngine {
         /// Protected operator=, to prevent misuse
         VertexData& operator=(const VertexData& rhs); /* do not use */
 
-		HardwareBufferManagerBase* mMgr;
+		HardwareBufferManager* mMgr;
     public:
 		/** Constructor.
 		@note 
@@ -62,7 +62,7 @@ namespace CamelotEngine {
 			automatically, and arranges for their deletion afterwards.
 		@param mgr Optional HardwareBufferManager from which to create resources
 		*/
-        VertexData(HardwareBufferManagerBase* mgr = 0);
+        VertexData(HardwareBufferManager* mgr = 0);
 		/** Constructor.
 		@note 
 		This constructor receives the VertexDeclaration and VertexBufferBinding
@@ -94,7 +94,7 @@ namespace CamelotEngine {
 		@param mgr If supplied, the buffer manager through which copies should be made
 		@remarks The caller is expected to delete the returned pointer when ready
 		*/
-		VertexData* clone(bool copyData = true, HardwareBufferManagerBase* mgr = 0) const;
+		VertexData* clone(bool copyData = true, HardwareBufferManager* mgr = 0) const;
 
         /** Additional shadow volume vertex buffer storage. 
         @remarks
@@ -131,7 +131,7 @@ namespace CamelotEngine {
 			and buffers etc. If not supplied, the HardwareBufferManager singleton will be used
 		*/
 		void reorganiseBuffers(VertexDeclarationPtr newDeclaration, const BufferUsageList& bufferUsage, 
-			HardwareBufferManagerBase* mgr = 0);
+			HardwareBufferManager* mgr = 0);
 
 		/** Reorganises the data in the vertex buffers according to the 
 			new vertex declaration passed in. Note that new vertex buffers
@@ -150,7 +150,7 @@ namespace CamelotEngine {
 		@param mgr Optional pointer to the manager to use to create new declarations
 			and buffers etc. If not supplied, the HardwareBufferManager singleton will be used
 		*/
-		void reorganiseBuffers(VertexDeclarationPtr newDeclaration, HardwareBufferManagerBase* mgr = 0);
+		void reorganiseBuffers(VertexDeclarationPtr newDeclaration, HardwareBufferManager* mgr = 0);
 
         /** Remove any gaps in the vertex buffer bindings.
         @remarks
@@ -208,7 +208,7 @@ namespace CamelotEngine {
 		@param mgr If supplied, the buffer manager through which copies should be made
 		@remarks The caller is expected to delete the returned pointer when finished
 		*/
-		IndexData* clone(bool copyData = true, HardwareBufferManagerBase* mgr = 0) const;
+		IndexData* clone(bool copyData = true, HardwareBufferManager* mgr = 0) const;
 
 		/** Re-order the indexes in this index data structure to be more
 			vertex cache friendly; that is to re-use the same vertices as close

CamelotRenderer/Source/CmHardwareBufferManager.cpp

@@ -31,23 +31,12 @@ THE SOFTWARE.
 #include "CmVertexDeclaration.h"
 
 namespace CamelotEngine {
-	//---------------------------------------------------------------------
-	HardwareBufferManager::HardwareBufferManager(HardwareBufferManagerBase* imp)
-		: HardwareBufferManagerBase(), mImpl(imp)
-	{
-
-	}
-	//---------------------------------------------------------------------
-	HardwareBufferManager::~HardwareBufferManager()
-	{
-		// mImpl must be deleted by the creator
-	}
     //-----------------------------------------------------------------------
-    HardwareBufferManagerBase::HardwareBufferManagerBase()
+    HardwareBufferManager::HardwareBufferManager()
     {
     }
     //-----------------------------------------------------------------------
-    HardwareBufferManagerBase::~HardwareBufferManagerBase()
+    HardwareBufferManager::~HardwareBufferManager()
     {
         // Clear vertex/index buffer list first, avoid destroyed notify do
         // unnecessary work, and we'll destroy everything here.
@@ -61,41 +50,41 @@ namespace CamelotEngine {
         // No need to destroy temp buffers - they will be destroyed automatically.
     }
     //-----------------------------------------------------------------------
-    VertexDeclarationPtr HardwareBufferManagerBase::createVertexDeclaration(void)
+    VertexDeclarationPtr HardwareBufferManager::createVertexDeclaration(void)
     {
         VertexDeclarationPtr decl = createVertexDeclarationImpl();
         return decl;
     }
     //-----------------------------------------------------------------------
-	VertexBufferBinding* HardwareBufferManagerBase::createVertexBufferBinding(void)
+	VertexBufferBinding* HardwareBufferManager::createVertexBufferBinding(void)
 	{
 		VertexBufferBinding* ret = createVertexBufferBindingImpl();
 		mVertexBufferBindings.insert(ret);
 		return ret;
 	}
     //-----------------------------------------------------------------------
-	void HardwareBufferManagerBase::destroyVertexBufferBinding(VertexBufferBinding* binding)
+	void HardwareBufferManager::destroyVertexBufferBinding(VertexBufferBinding* binding)
 	{
 		mVertexBufferBindings.erase(binding);
 		destroyVertexBufferBindingImpl(binding);
 	}
     //-----------------------------------------------------------------------
-    VertexDeclarationPtr HardwareBufferManagerBase::createVertexDeclarationImpl(void)
+    VertexDeclarationPtr HardwareBufferManager::createVertexDeclarationImpl(void)
     {
         return VertexDeclarationPtr(new VertexDeclaration());
     }
     //-----------------------------------------------------------------------
-	VertexBufferBinding* HardwareBufferManagerBase::createVertexBufferBindingImpl(void)
+	VertexBufferBinding* HardwareBufferManager::createVertexBufferBindingImpl(void)
 	{
 		return new VertexBufferBinding();
 	}
     //-----------------------------------------------------------------------
-	void HardwareBufferManagerBase::destroyVertexBufferBindingImpl(VertexBufferBinding* binding)
+	void HardwareBufferManager::destroyVertexBufferBindingImpl(VertexBufferBinding* binding)
 	{
 		delete binding;
 	}
     //-----------------------------------------------------------------------
-    void HardwareBufferManagerBase::destroyAllBindings(void)
+    void HardwareBufferManager::destroyAllBindings(void)
     {
         VertexBufferBindingList::iterator bind;
         for (bind = mVertexBufferBindings.begin(); bind != mVertexBufferBindings.end(); ++bind)
@@ -105,7 +94,7 @@ namespace CamelotEngine {
         mVertexBufferBindings.clear();
     }
 	//-----------------------------------------------------------------------
-	void HardwareBufferManagerBase::_notifyVertexBufferDestroyed(VertexBuffer* buf)
+	void HardwareBufferManager::_notifyVertexBufferDestroyed(VertexBuffer* buf)
 	{
 		VertexBufferList::iterator i = mVertexBuffers.find(buf);
 		if (i != mVertexBuffers.end())
@@ -115,7 +104,7 @@ namespace CamelotEngine {
 		}
 	}
 	//-----------------------------------------------------------------------
-	void HardwareBufferManagerBase::_notifyIndexBufferDestroyed(IndexBuffer* buf)
+	void HardwareBufferManager::_notifyIndexBufferDestroyed(IndexBuffer* buf)
 	{
 		IndexBufferList::iterator i = mIndexBuffers.find(buf);
 		if (i != mIndexBuffers.end())

CamelotRenderer/Source/CmIndexBuffer.cpp

@@ -32,7 +32,7 @@ THE SOFTWARE.
 namespace CamelotEngine {
 
     //-----------------------------------------------------------------------------
-    IndexBuffer::IndexBuffer(HardwareBufferManagerBase* mgr, IndexType idxType, 
+    IndexBuffer::IndexBuffer(HardwareBufferManager* mgr, IndexType idxType, 
         UINT32 numIndexes, GpuBufferUsage usage, 
         bool useSystemMemory) 
         : HardwareBuffer(usage, useSystemMemory)

CamelotRenderer/Source/CmVertexBuffer.cpp

@@ -36,7 +36,7 @@ THE SOFTWARE.
 namespace CamelotEngine {
 
     //-----------------------------------------------------------------------------
-    VertexBuffer::VertexBuffer(HardwareBufferManagerBase* mgr, UINT32 vertexSize,  
+    VertexBuffer::VertexBuffer(HardwareBufferManager* mgr, UINT32 vertexSize,  
         UINT32 numVertices, GpuBufferUsage usage, 
         bool useSystemMemory) 
         : HardwareBuffer(usage, useSystemMemory), 

CamelotRenderer/Source/CmVertexDeclaration.cpp

@@ -341,9 +341,9 @@ namespace CamelotEngine
 		return sz;
 	}
 	//-----------------------------------------------------------------------------
-	VertexDeclarationPtr VertexDeclaration::clone(HardwareBufferManagerBase* mgr)
+	VertexDeclarationPtr VertexDeclaration::clone(HardwareBufferManager* mgr)
 	{
-		HardwareBufferManagerBase* pManager = mgr ? mgr : HardwareBufferManager::instancePtr(); 
+		HardwareBufferManager* pManager = mgr ? mgr : HardwareBufferManager::instancePtr(); 
 		VertexDeclarationPtr ret = pManager->createVertexDeclaration();
 
 		VertexElementList::const_iterator i, iend;

CamelotRenderer/Source/CmVertexIndexData.cpp

@@ -38,7 +38,7 @@ THE SOFTWARE.
 namespace CamelotEngine {
 
     //-----------------------------------------------------------------------
-	VertexData::VertexData(HardwareBufferManagerBase* mgr)
+	VertexData::VertexData(HardwareBufferManager* mgr)
 	{
 		mMgr = mgr ? mgr : HardwareBufferManager::instancePtr();
 		vertexBufferBinding = mMgr->createVertexBufferBinding();
@@ -68,9 +68,9 @@ namespace CamelotEngine {
 		}
 	}
     //-----------------------------------------------------------------------
-	VertexData* VertexData::clone(bool copyData, HardwareBufferManagerBase* mgr) const
+	VertexData* VertexData::clone(bool copyData, HardwareBufferManager* mgr) const
 	{
-		HardwareBufferManagerBase* pManager = mgr ? mgr : mMgr;
+		HardwareBufferManager* pManager = mgr ? mgr : mMgr;
 
 		VertexData* dest = new VertexData(mgr);
 
@@ -127,9 +127,9 @@ namespace CamelotEngine {
 	}
 	//-----------------------------------------------------------------------
 	void VertexData::reorganiseBuffers(VertexDeclarationPtr newDeclaration, 
-		const BufferUsageList& bufferUsages, HardwareBufferManagerBase* mgr)
+		const BufferUsageList& bufferUsages, HardwareBufferManager* mgr)
 	{
-		HardwareBufferManagerBase* pManager = mgr ? mgr : mMgr;
+		HardwareBufferManager* pManager = mgr ? mgr : mMgr;
         // Firstly, close up any gaps in the buffer sources which might have arisen
         newDeclaration->closeGapsInSource();
 
@@ -253,7 +253,7 @@ namespace CamelotEngine {
 
 	}
     //-----------------------------------------------------------------------
-    void VertexData::reorganiseBuffers(VertexDeclarationPtr newDeclaration, HardwareBufferManagerBase* mgr)
+    void VertexData::reorganiseBuffers(VertexDeclarationPtr newDeclaration, HardwareBufferManager* mgr)
     {
         // Derive the buffer usages from looking at where the source has come
         // from
@@ -459,9 +459,9 @@ namespace CamelotEngine {
 	{
 	}
     //-----------------------------------------------------------------------
-	IndexData* IndexData::clone(bool copyData, HardwareBufferManagerBase* mgr) const
+	IndexData* IndexData::clone(bool copyData, HardwareBufferManager* mgr) const
 	{
-		HardwareBufferManagerBase* pManager = mgr ? mgr : HardwareBufferManager::instancePtr();
+		HardwareBufferManager* pManager = mgr ? mgr : HardwareBufferManager::instancePtr();
 		IndexData* dest = new IndexData();
 		if (indexBuffer.get())
 		{