Renamed all of the hardware buffers

CamelotD3D11RenderSystem/CamelotD3D11RenderSystem.vcxproj

@@ -160,13 +160,13 @@
     <ClInclude Include="Include\CmD3D11GpuProgramManager.h" />
     <ClInclude Include="Include\CmD3D11HardwareBuffer.h" />
     <ClInclude Include="Include\CmD3D11HLSLProgram.h" />
-    <ClInclude Include="Include\CmD3D11HardwareIndexBuffer.h" />
+    <ClInclude Include="Include\CmD3D11IndexBuffer.h" />
     <ClInclude Include="Include\CmD3D11HLSLProgramFactory.h" />
     <ClInclude Include="Include\CmD3D11HLSLProgramRTTI.h" />
     <ClInclude Include="Include\CmD3D11Mappings.h" />
     <ClInclude Include="Include\CmD3D11MultiRenderTexture.h" />
     <ClInclude Include="Include\CmD3D11Prerequisites.h" />
-    <ClInclude Include="Include\CmD3D11HardwareVertexBuffer.h" />
+    <ClInclude Include="Include\CmD3D11VertexBuffer.h" />
     <ClInclude Include="Include\CmD3D11RasterizerState.h" />
     <ClInclude Include="Include\CmD3D11RenderStateManager.h" />
     <ClInclude Include="Include\CmD3D11RenderSystem.h" />
@@ -196,10 +196,10 @@
     <ClCompile Include="Source\CmD3D11HardwareBufferManager.cpp" />
     <ClCompile Include="Source\CmD3D11HardwareConstantBuffer.cpp" />
     <ClCompile Include="Source\CmD3D11HLSLProgram.cpp" />
-    <ClCompile Include="Source\CmD3D11HardwareIndexBuffer.cpp" />
+    <ClCompile Include="Source\CmD3D11IndexBuffer.cpp" />
     <ClCompile Include="Source\CmD3D11HLSLProgramFactory.cpp" />
     <ClCompile Include="Source\CmD3D11Mappings.cpp" />
-    <ClCompile Include="Source\CmD3D11HardwareVertexBuffer.cpp" />
+    <ClCompile Include="Source\CmD3D11VertexBuffer.cpp" />
     <ClCompile Include="Source\CmD3D11MultiRenderTexture.cpp" />
     <ClCompile Include="Source\CmD3D11RasterizerState.cpp" />
     <ClCompile Include="Source\CmD3D11RenderStateManager.cpp" />

CamelotD3D11RenderSystem/CamelotD3D11RenderSystem.vcxproj.filters

@@ -51,12 +51,6 @@
     <ClInclude Include="Include\CmD3D11HardwareBuffer.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="Include\CmD3D11HardwareIndexBuffer.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="Include\CmD3D11HardwareVertexBuffer.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
     <ClInclude Include="Include\CmD3D11HardwareConstantBuffer.h">
       <Filter>Header Files</Filter>
     </ClInclude>
@@ -120,6 +114,12 @@
     <ClInclude Include="Include\CmD3D11GenericBufferView.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="Include\CmD3D11IndexBuffer.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\CmD3D11VertexBuffer.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Source\CmD3D11GpuProgram.cpp">
@@ -152,12 +152,6 @@
     <ClCompile Include="Source\CmD3D11HardwareBuffer.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="Source\CmD3D11HardwareIndexBuffer.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="Source\CmD3D11HardwareVertexBuffer.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
     <ClCompile Include="Source\CmD3D11HardwareConstantBuffer.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
@@ -218,5 +212,11 @@
     <ClCompile Include="Source\CmD3D11GenericBufferView.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="Source\CmD3D11VertexBuffer.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Source\CmD3D11IndexBuffer.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

CamelotD3D11RenderSystem/Include/CmD3D11HardwareBuffer.h

@@ -5,56 +5,56 @@
 
 namespace CamelotEngine
 {
-	class CM_D3D11_EXPORT D3D11HardwareBuffer : public HardwareBuffer
-	{
-	public:
-		enum BufferType
-		{
-			BT_VERTEX = 0x1,
-			BT_INDEX = 0x2,
-			BT_CONSTANT = 0x4,
-			BT_GROUP_GENERIC = 0x8,
+	class CM_D3D11_EXPORT D3D11HardwareBuffer : public HardwareBuffer
+	{
+	public:
+		enum BufferType
+		{
+			BT_VERTEX = 0x1,
+			BT_INDEX = 0x2,
+			BT_CONSTANT = 0x4,
+			BT_GROUP_GENERIC = 0x8,
 			BT_STRUCTURED = BT_GROUP_GENERIC | 0x10,
 			BT_RAW = BT_GROUP_GENERIC | 0x20,
 			BT_INDIRECTARGUMENT = BT_GROUP_GENERIC | 0x40,
-			BT_APPENDCONSUME = BT_GROUP_GENERIC | 0x80
-		};
-
-		D3D11HardwareBuffer(BufferType btype, GpuBufferUsage usage, UINT32 elementCount, UINT32 elementSize, 
-			D3D11Device& device, bool useSystemMem = false, bool streamOut = false, bool randomGpuWrite = false, bool useCounter = false);
-		~D3D11HardwareBuffer();
-
-		/** See HardwareBuffer. */
-		void readData(UINT32 offset, UINT32 length, void* pDest);
-		/** See HardwareBuffer. */
-		void writeData(UINT32 offset, UINT32 length, const void* pSource,
-			bool discardWholeBuffer = false);
-		/** See HardwareBuffer. We perform a hardware copy here. */
-		void copyData(HardwareBuffer& srcBuffer, UINT32 srcOffset, 
-			UINT32 dstOffset, UINT32 length, bool discardWholeBuffer = false);
-
-		/// Get the D3D-specific buffer
-		ID3D11Buffer* getD3DBuffer(void) { return mD3DBuffer; }
-
+			BT_APPENDCONSUME = BT_GROUP_GENERIC | 0x80
+		};
+
+		D3D11HardwareBuffer(BufferType btype, GpuBufferUsage usage, UINT32 elementCount, UINT32 elementSize, 
+			D3D11Device& device, bool useSystemMem = false, bool streamOut = false, bool randomGpuWrite = false, bool useCounter = false);
+		~D3D11HardwareBuffer();
+
+		/** See HardwareBuffer. */
+		void readData(UINT32 offset, UINT32 length, void* pDest);
+		/** See HardwareBuffer. */
+		void writeData(UINT32 offset, UINT32 length, const void* pSource,
+			bool discardWholeBuffer = false);
+		/** See HardwareBuffer. We perform a hardware copy here. */
+		void copyData(HardwareBuffer& srcBuffer, UINT32 srcOffset, 
+			UINT32 dstOffset, UINT32 length, bool discardWholeBuffer = false);
+
+		/// Get the D3D-specific buffer
+		ID3D11Buffer* getD3DBuffer(void) { return mD3DBuffer; }
+
 	protected:
 		BufferType mBufferType;
 		bool mRandomGpuWrite;
 		bool mUseCounter;
 		UINT32 mElementCount;
-		UINT32 mElementSize;
-
-		ID3D11Buffer* mD3DBuffer;
-
-		bool mUseTempStagingBuffer;
-		D3D11HardwareBuffer* mpTempStagingBuffer;
-		bool mStagingUploadNeeded;
-		
-		D3D11Device& mDevice;
-		D3D11_BUFFER_DESC mDesc;
-
-		/** See HardwareBuffer. */
-		void* lockImpl(UINT32 offset, UINT32 length, GpuLockOptions options);
-		/** See HardwareBuffer. */
-		void unlockImpl(void);
+		UINT32 mElementSize;
+
+		ID3D11Buffer* mD3DBuffer;
+
+		bool mUseTempStagingBuffer;
+		D3D11HardwareBuffer* mpTempStagingBuffer;
+		bool mStagingUploadNeeded;
+		
+		D3D11Device& mDevice;
+		D3D11_BUFFER_DESC mDesc;
+
+		/** See HardwareBuffer. */
+		void* lockImpl(UINT32 offset, UINT32 length, GpuLockOptions options);
+		/** See HardwareBuffer. */
+		void unlockImpl(void);
 	};
 }

CamelotD3D11RenderSystem/Include/CmD3D11HardwareBufferManager.h

@@ -19,7 +19,7 @@ namespace CamelotEngine
 		/**
 		 * @brief	Creates a hardware index buffer.
 		 */
-		HardwareIndexBufferPtr createIndexBuffer(HardwareIndexBuffer::IndexType itype, UINT32 numIndexes, GpuBufferUsage usage);
+		HardwareIndexBufferPtr createIndexBuffer(IndexBuffer::IndexType itype, UINT32 numIndexes, GpuBufferUsage usage);
 
 		/** @copydoc HardwareBufferManagerInterface::createGpuParamBlock */
 		GpuParamBlockPtr createGpuParamBlock(const GpuParamBlockDesc& paramDesc);

CamelotD3D11RenderSystem/Include/CmD3D11HardwareIndexBuffer.h → CamelotD3D11RenderSystem/Include/CmD3D11IndexBuffer.h

@@ -1,17 +1,17 @@
 #pragma once
 
 #include "CmD3D11Prerequisites.h"
-#include "CmHardwareIndexBuffer.h"
+#include "CmIndexBuffer.h"
 #include "CmD3D11HardwareBuffer.h"
 
 namespace CamelotEngine
 {
-	class CM_D3D11_EXPORT D3D11HardwareIndexBuffer : public HardwareIndexBuffer
+	class CM_D3D11_EXPORT D3D11IndexBuffer : public IndexBuffer
 	{
 	public:
-		D3D11HardwareIndexBuffer(D3D11Device& device, HardwareBufferManagerBase* mgr, IndexType idxType, UINT32 numIndexes, 
+		D3D11IndexBuffer(D3D11Device& device, HardwareBufferManagerBase* mgr, IndexType idxType, UINT32 numIndexes, 
 			GpuBufferUsage usage, bool useSystemMem);
-		~D3D11HardwareIndexBuffer();
+		~D3D11IndexBuffer();
 
 		/**
 		 * @copydoc HardwareBuffer::readData

CamelotD3D11RenderSystem/Include/CmD3D11Mappings.h

@@ -4,7 +4,7 @@
 #include "CmCommonEnums.h"
 #include "CmTexture.h"
 #include "CmPixelData.h"
-#include "CmHardwareIndexBuffer.h"
+#include "CmIndexBuffer.h"
 #include "CmVertexIndexData.h"
 #include "CmSamplerState.h"
 
@@ -48,7 +48,7 @@ namespace CamelotEngine
 		static DWORD get(GpuBufferUsage usage);
 		/// Get lock options
 		static D3D11_MAP get(GpuLockOptions options, GpuBufferUsage usage);
-		static UINT getByteWidth(HardwareIndexBuffer::IndexType itype);
+		static UINT getByteWidth(IndexBuffer::IndexType itype);
 		/// Get vertex data type
 		static DXGI_FORMAT get(VertexElementType vType);
 		/// Get vertex semantic

CamelotD3D11RenderSystem/Include/CmD3D11Prerequisites.h

@@ -36,7 +36,7 @@ namespace CamelotEngine
 	class D3D11GpuProgram;
 	class D3D11GpuProgramManager;
 	class D3D11HardwareBufferManager;
-	class D3D11HardwareIndexBuffer;
+	class D3D11IndexBuffer;
 	class D3D11HardwareConstantBuffer;
 	class D3D11HLSLProgramFactory;
 	class D3D11HLSLProgram;

CamelotD3D11RenderSystem/Include/CmD3D11HardwareVertexBuffer.h → CamelotD3D11RenderSystem/Include/CmD3D11VertexBuffer.h

@@ -1,17 +1,17 @@
 #pragma once
 
 #include "CmD3D11Prerequisites.h"
-#include "CmHardwareVertexBuffer.h"
+#include "CmVertexBuffer.h"
 #include "CmD3D11HardwareBuffer.h"
 
 namespace CamelotEngine
 {
-	class CM_D3D11_EXPORT D3D11HardwareVertexBuffer : public HardwareVertexBuffer
+	class CM_D3D11_EXPORT D3D11VertexBuffer : public VertexBuffer
 	{
 	public:
-		D3D11HardwareVertexBuffer(D3D11Device& device, HardwareBufferManagerBase* mgr, UINT32 vertexSize, UINT32 numVertices, 
+		D3D11VertexBuffer(D3D11Device& device, HardwareBufferManagerBase* mgr, UINT32 vertexSize, UINT32 numVertices, 
 			GpuBufferUsage usage, bool useSystemMem, bool streamOut);
-		~D3D11HardwareVertexBuffer();
+		~D3D11VertexBuffer();
 
 		/**
 		 * @copydoc HardwareBuffer::readData

CamelotD3D11RenderSystem/Source/CmD3D11HardwareBufferManager.cpp

@@ -1,6 +1,6 @@
 #include "CmD3D11HardwareBufferManager.h"
-#include "CmD3D11HardwareVertexBuffer.h"
-#include "CmD3D11HardwareIndexBuffer.h"
+#include "CmD3D11VertexBuffer.h"
+#include "CmD3D11IndexBuffer.h"
 #include "CmD3D11HardwareConstantBuffer.h"
 #include "CmD3D11VertexDeclaration.h"
 #include "CmD3D11GenericBuffer.h"
@@ -21,7 +21,7 @@ namespace CamelotEngine
 		UINT32 numVerts, GpuBufferUsage usage, bool streamOut)
 	{
 		assert (numVerts > 0);
-		D3D11HardwareVertexBuffer* vbuf = new D3D11HardwareVertexBuffer(mDevice,
+		D3D11VertexBuffer* vbuf = new D3D11VertexBuffer(mDevice,
 			this, vertexSize, numVerts, usage, false, streamOut);
 		{
 			mVertexBuffers.insert(vbuf);
@@ -30,12 +30,12 @@ namespace CamelotEngine
 		return HardwareVertexBufferPtr(vbuf);
 	}
 
-	HardwareIndexBufferPtr D3D11HardwareBufferManagerBase::createIndexBuffer(HardwareIndexBuffer::IndexType itype, 
+	HardwareIndexBufferPtr D3D11HardwareBufferManagerBase::createIndexBuffer(IndexBuffer::IndexType itype, 
 		UINT32 numIndexes, GpuBufferUsage usage)
 	{
 		assert (numIndexes > 0);
 
-		D3D11HardwareIndexBuffer* idx = new D3D11HardwareIndexBuffer(mDevice,
+		D3D11IndexBuffer* idx = new D3D11IndexBuffer(mDevice,
 			this, itype, numIndexes, usage, false);
 		{
 

CamelotD3D11RenderSystem/Source/CmD3D11HardwareIndexBuffer.cpp

@@ -1,42 +0,0 @@
-#include "CmD3D11HardwareIndexBuffer.h"
-
-namespace CamelotEngine
-{
-	D3D11HardwareIndexBuffer::D3D11HardwareIndexBuffer(D3D11Device& device, HardwareBufferManagerBase* mgr, IndexType idxType, UINT32 numIndexes, 
-		GpuBufferUsage usage, bool useSystemMem)
-		:HardwareIndexBuffer(mgr, idxType, numIndexes, usage, useSystemMem)
-	{
-		mBuffer = new D3D11HardwareBuffer(D3D11HardwareBuffer::BT_INDEX, usage, 1, mSizeInBytes, device, useSystemMem);
-	}
-
-	D3D11HardwareIndexBuffer::~D3D11HardwareIndexBuffer()
-	{
-		delete mBuffer;
-	}
-
-	void* D3D11HardwareIndexBuffer::lockImpl(UINT32 offset, UINT32 length, GpuLockOptions options)
-	{
-		return mBuffer->lock(offset, length, options);
-	}
-
-	void D3D11HardwareIndexBuffer::unlockImpl()
-	{
-		mBuffer->unlock();
-	}
-
-	void D3D11HardwareIndexBuffer::readData(UINT32 offset, UINT32 length, void* pDest)
-	{
-		mBuffer->readData(offset, length, pDest);
-	}
-
-	void D3D11HardwareIndexBuffer::writeData(UINT32 offset, UINT32 length, const void* pSource, bool discardWholeBuffer)
-	{
-		mBuffer->writeData(offset, length, pSource, discardWholeBuffer);
-	}
-
-	void D3D11HardwareIndexBuffer::copyData(HardwareBuffer& srcBuffer, UINT32 srcOffset, 
-		UINT32 dstOffset, UINT32 length, bool discardWholeBuffer)
-	{
-		mBuffer->copyData(srcBuffer, srcOffset, dstOffset, length, discardWholeBuffer);
-	}
-}

CamelotD3D11RenderSystem/Source/CmD3D11HardwareVertexBuffer.cpp

@@ -1,42 +0,0 @@
-#include "CmD3D11HardwareVertexBuffer.h"
-
-namespace CamelotEngine
-{
-	D3D11HardwareVertexBuffer::D3D11HardwareVertexBuffer(D3D11Device& device, HardwareBufferManagerBase* mgr, UINT32 vertexSize, UINT32 numVertices, 
-		GpuBufferUsage usage, bool useSystemMem, bool streamOut)
-		:HardwareVertexBuffer(mgr, vertexSize, numVertices, usage, useSystemMem)
-	{
-		mBuffer = new D3D11HardwareBuffer(D3D11HardwareBuffer::BT_VERTEX, usage, 1, mSizeInBytes, device, useSystemMem, streamOut);
-	}
-
-	D3D11HardwareVertexBuffer::~D3D11HardwareVertexBuffer()
-	{
-		delete mBuffer;
-	}
-
-	void* D3D11HardwareVertexBuffer::lockImpl(UINT32 offset, UINT32 length, GpuLockOptions options)
-	{
-		return mBuffer->lock(offset, length, options);
-	}
-
-	void D3D11HardwareVertexBuffer::unlockImpl()
-	{
-		mBuffer->unlock();
-	}
-
-	void D3D11HardwareVertexBuffer::readData(UINT32 offset, UINT32 length, void* pDest)
-	{
-		mBuffer->readData(offset, length, pDest);
-	}
-
-	void D3D11HardwareVertexBuffer::writeData(UINT32 offset, UINT32 length, const void* pSource, bool discardWholeBuffer)
-	{
-		mBuffer->writeData(offset, length, pSource, discardWholeBuffer);
-	}
-
-	void D3D11HardwareVertexBuffer::copyData(HardwareBuffer& srcBuffer, UINT32 srcOffset, 
-		UINT32 dstOffset, UINT32 length, bool discardWholeBuffer)
-	{
-		mBuffer->copyData(srcBuffer, srcOffset, dstOffset, length, discardWholeBuffer);
-	}
-}

CamelotD3D11RenderSystem/Source/CmD3D11IndexBuffer.cpp

@@ -0,0 +1,42 @@
+#include "CmD3D11IndexBuffer.h"
+
+namespace CamelotEngine
+{
+	D3D11IndexBuffer::D3D11IndexBuffer(D3D11Device& device, HardwareBufferManagerBase* mgr, IndexType idxType, UINT32 numIndexes, 
+		GpuBufferUsage usage, bool useSystemMem)
+		:IndexBuffer(mgr, idxType, numIndexes, usage, useSystemMem)
+	{
+		mBuffer = new D3D11HardwareBuffer(D3D11HardwareBuffer::BT_INDEX, usage, 1, mSizeInBytes, device, useSystemMem);
+	}
+
+	D3D11IndexBuffer::~D3D11IndexBuffer()
+	{
+		delete mBuffer;
+	}
+
+	void* D3D11IndexBuffer::lockImpl(UINT32 offset, UINT32 length, GpuLockOptions options)
+	{
+		return mBuffer->lock(offset, length, options);
+	}
+
+	void D3D11IndexBuffer::unlockImpl()
+	{
+		mBuffer->unlock();
+	}
+
+	void D3D11IndexBuffer::readData(UINT32 offset, UINT32 length, void* pDest)
+	{
+		mBuffer->readData(offset, length, pDest);
+	}
+
+	void D3D11IndexBuffer::writeData(UINT32 offset, UINT32 length, const void* pSource, bool discardWholeBuffer)
+	{
+		mBuffer->writeData(offset, length, pSource, discardWholeBuffer);
+	}
+
+	void D3D11IndexBuffer::copyData(HardwareBuffer& srcBuffer, UINT32 srcOffset, 
+		UINT32 dstOffset, UINT32 length, bool discardWholeBuffer)
+	{
+		mBuffer->copyData(srcBuffer, srcOffset, dstOffset, length, discardWholeBuffer);
+	}
+}

CamelotD3D11RenderSystem/Source/CmD3D11Mappings.cpp

@@ -294,9 +294,9 @@ namespace CamelotEngine
 		return ret;
 	}
 
-	UINT D3D11Mappings::getByteWidth(HardwareIndexBuffer::IndexType itype)
+	UINT D3D11Mappings::getByteWidth(IndexBuffer::IndexType itype)
 	{
-		if (itype == HardwareIndexBuffer::IT_32BIT)
+		if (itype == IndexBuffer::IT_32BIT)
 		{
 			return sizeof(UINT32);
 		}

CamelotD3D11RenderSystem/Source/CmD3D11VertexBuffer.cpp

@@ -0,0 +1,42 @@
+#include "CmD3D11VertexBuffer.h"
+
+namespace CamelotEngine
+{
+	D3D11VertexBuffer::D3D11VertexBuffer(D3D11Device& device, HardwareBufferManagerBase* mgr, UINT32 vertexSize, UINT32 numVertices, 
+		GpuBufferUsage usage, bool useSystemMem, bool streamOut)
+		:VertexBuffer(mgr, vertexSize, numVertices, usage, useSystemMem)
+	{
+		mBuffer = new D3D11HardwareBuffer(D3D11HardwareBuffer::BT_VERTEX, usage, 1, mSizeInBytes, device, useSystemMem, streamOut);
+	}
+
+	D3D11VertexBuffer::~D3D11VertexBuffer()
+	{
+		delete mBuffer;
+	}
+
+	void* D3D11VertexBuffer::lockImpl(UINT32 offset, UINT32 length, GpuLockOptions options)
+	{
+		return mBuffer->lock(offset, length, options);
+	}
+
+	void D3D11VertexBuffer::unlockImpl()
+	{
+		mBuffer->unlock();
+	}
+
+	void D3D11VertexBuffer::readData(UINT32 offset, UINT32 length, void* pDest)
+	{
+		mBuffer->readData(offset, length, pDest);
+	}
+
+	void D3D11VertexBuffer::writeData(UINT32 offset, UINT32 length, const void* pSource, bool discardWholeBuffer)
+	{
+		mBuffer->writeData(offset, length, pSource, discardWholeBuffer);
+	}
+
+	void D3D11VertexBuffer::copyData(HardwareBuffer& srcBuffer, UINT32 srcOffset, 
+		UINT32 dstOffset, UINT32 length, bool discardWholeBuffer)
+	{
+		mBuffer->copyData(srcBuffer, srcOffset, dstOffset, length, discardWholeBuffer);
+	}
+}

CamelotD3D9Renderer/CamelotD3D9Renderer.vcxproj

@@ -156,10 +156,10 @@
     <ClInclude Include="Include\CmD3D9GpuProgram.h" />
     <ClInclude Include="Include\CmD3D9GpuProgramManager.h" />
     <ClInclude Include="Include\CmD3D9HardwareBufferManager.h" />
-    <ClInclude Include="Include\CmD3D9HardwareIndexBuffer.h" />
-    <ClInclude Include="Include\CmD3D9HardwareOcclusionQuery.h" />
-    <ClInclude Include="Include\CmD3D9HardwarePixelBuffer.h" />
-    <ClInclude Include="Include\CmD3D9HardwareVertexBuffer.h" />
+    <ClInclude Include="Include\CmD3D9IndexBuffer.h" />
+    <ClInclude Include="Include\CmD3D9OcclusionQuery.h" />
+    <ClInclude Include="Include\CmD3D9PixelBuffer.h" />
+    <ClInclude Include="Include\CmD3D9VertexBuffer.h" />
     <ClInclude Include="Include\CmD3D9HLSLProgram.h" />
     <ClInclude Include="Include\CmD3D9HLSLProgramFactory.h" />
     <ClInclude Include="Include\CmD3D9HLSLProgramRTTI.h" />
@@ -190,10 +190,10 @@
     <ClCompile Include="Source\CmD3D9GpuProgram.cpp" />
     <ClCompile Include="Source\CmD3D9GpuProgramManager.cpp" />
     <ClCompile Include="Source\CmD3D9HardwareBufferManager.cpp" />
-    <ClCompile Include="Source\CmD3D9HardwareIndexBuffer.cpp" />
-    <ClCompile Include="Source\CmD3D9HardwareOcclusionQuery.cpp" />
-    <ClCompile Include="Source\CmD3D9HardwarePixelBuffer.cpp" />
-    <ClCompile Include="Source\CmD3D9HardwareVertexBuffer.cpp" />
+    <ClCompile Include="Source\CmD3D9IndexBuffer.cpp" />
+    <ClCompile Include="Source\CmD3D9OcclusionQuery.cpp" />
+    <ClCompile Include="Source\CmD3D9PixelBuffer.cpp" />
+    <ClCompile Include="Source\CmD3D9VertexBuffer.cpp" />
     <ClCompile Include="Source\CmD3D9HLSLProgram.cpp" />
     <ClCompile Include="Source\CmD3D9HLSLProgramFactory.cpp" />
     <ClCompile Include="Source\CmD3D9Mappings.cpp" />

CamelotD3D9Renderer/CamelotD3D9Renderer.vcxproj.filters

@@ -39,18 +39,6 @@
     <ClInclude Include="Include\CmD3D9HardwareBufferManager.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="Include\CmD3D9HardwareIndexBuffer.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="Include\CmD3D9HardwareOcclusionQuery.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="Include\CmD3D9HardwarePixelBuffer.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="Include\CmD3D9HardwareVertexBuffer.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
     <ClInclude Include="Include\CmD3D9HLSLProgram.h">
       <Filter>Header Files</Filter>
     </ClInclude>
@@ -111,6 +99,18 @@
     <ClInclude Include="Include\CmD3D9GenericBuffer.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="Include\CmD3D9VertexBuffer.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\CmD3D9PixelBuffer.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\CmD3D9OcclusionQuery.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\CmD3D9IndexBuffer.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Source\CmD3D9Device.cpp">
@@ -134,18 +134,6 @@
     <ClCompile Include="Source\CmD3D9HardwareBufferManager.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="Source\CmD3D9HardwareIndexBuffer.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="Source\CmD3D9HardwareOcclusionQuery.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="Source\CmD3D9HardwarePixelBuffer.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="Source\CmD3D9HardwareVertexBuffer.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
     <ClCompile Include="Source\CmD3D9HLSLProgram.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
@@ -203,5 +191,17 @@
     <ClCompile Include="Source\CmD3D9GenericBuffer.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="Source\CmD3D9IndexBuffer.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Source\CmD3D9OcclusionQuery.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Source\CmD3D9PixelBuffer.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Source\CmD3D9VertexBuffer.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

CamelotD3D9Renderer/Include/CmD3D9HardwareBufferManager.h

@@ -56,7 +56,7 @@ namespace CamelotEngine {
 		 * @copydoc HardwareBufferManagerBase::createIndexBuffer
 		 */
 		HardwareIndexBufferPtr 
-            createIndexBuffer(HardwareIndexBuffer::IndexType itype, UINT32 numIndexes, GpuBufferUsage usage);
+            createIndexBuffer(IndexBuffer::IndexType itype, UINT32 numIndexes, GpuBufferUsage usage);
 
 		/** @copydoc HardwareBufferManagerInterface::createGpuParamBlock */
 		GpuParamBlockPtr createGpuParamBlock(const GpuParamBlockDesc& paramDesc);

CamelotD3D9Renderer/Include/CmD3D9HardwareIndexBuffer.h → CamelotD3D9Renderer/Include/CmD3D9IndexBuffer.h

@@ -29,19 +29,19 @@ THE SOFTWARE.
 #define __D3D9HARDWAREINDEXBUFFER_H__
 
 #include "CmD3D9Prerequisites.h"
-#include "CmHardwareIndexBuffer.h"
+#include "CmIndexBuffer.h"
 #include "CmD3D9Resource.h"
 
 namespace CamelotEngine { 
 
 
-    class CM_D3D9_EXPORT D3D9HardwareIndexBuffer : public HardwareIndexBuffer, public D3D9Resource
+    class CM_D3D9_EXPORT D3D9IndexBuffer : public IndexBuffer, public D3D9Resource
     {
   
     public:
-		D3D9HardwareIndexBuffer(HardwareBufferManagerBase* mgr, IndexType idxType, UINT32 numIndexes, 
+		D3D9IndexBuffer(HardwareBufferManagerBase* mgr, IndexType idxType, UINT32 numIndexes, 
 			GpuBufferUsage usage, bool useSystemMem);
-        ~D3D9HardwareIndexBuffer();
+        ~D3D9IndexBuffer();
         /** See HardwareBuffer. */
         void readData(UINT32 offset, UINT32 length, void* pDest);
         /** See HardwareBuffer. */

CamelotD3D9Renderer/Include/CmD3D9Mappings.h

@@ -32,7 +32,7 @@ THE SOFTWARE.
 #include "CmCommonEnums.h"
 #include "CmRenderSystem.h"
 #include "CmHardwareBuffer.h"
-#include "CmHardwareIndexBuffer.h"
+#include "CmIndexBuffer.h"
 
 namespace CamelotEngine 
 {
@@ -88,7 +88,7 @@ namespace CamelotEngine
         /// Get lock options
         static DWORD get(GpuLockOptions options, GpuBufferUsage usage);
         /// Get index type
-        static D3DFORMAT get(HardwareIndexBuffer::IndexType itype);
+        static D3DFORMAT get(IndexBuffer::IndexType itype);
 		/// Get vertex data type
 		static D3DDECLTYPE get(VertexElementType vType);
 		/// Get vertex semantic

CamelotD3D9Renderer/Include/CmD3D9HardwareOcclusionQuery.h → CamelotD3D9Renderer/Include/CmD3D9OcclusionQuery.h

@@ -30,7 +30,7 @@ THE SOFTWARE.
 #define _D3D9HARWAREOCCLUSIONQUERY_H__
 
 #include "CmD3D9Prerequisites.h"
-#include "CmHardwareOcclusionQuery.h"
+#include "CmOcclusionQuery.h"
 #include "CmD3D9Resource.h"
 
 
@@ -51,7 +51,7 @@ namespace CamelotEngine {
 	* Updated on 12/7/2004 by Chris McGuirk
 	* Updated on 4/8/2005 by Tuan Kuranes email: [email protected]
 	*/
-	class CM_D3D9_EXPORT D3D9HardwareOcclusionQuery : public HardwareOcclusionQuery, public D3D9Resource
+	class CM_D3D9_EXPORT D3D9OcclusionQuery : public OcclusionQuery, public D3D9Resource
 	{
 		//----------------------------------------------------------------------
 		// Public methods
@@ -62,12 +62,12 @@ namespace CamelotEngine {
 		* Default object constructor
 		* 
 		*/
-		D3D9HardwareOcclusionQuery();
+		D3D9OcclusionQuery();
 
 		/**
 		* Object destructor
 		*/
-		~D3D9HardwareOcclusionQuery();
+		~D3D9OcclusionQuery();
 
 		//------------------------------------------------------------------
 		// Occlusion query functions (see base class documentation for this)

CamelotD3D9Renderer/Include/CmD3D9HardwarePixelBuffer.h → CamelotD3D9Renderer/Include/CmD3D9PixelBuffer.h

@@ -29,19 +29,19 @@ THE SOFTWARE.
 #define __D3D9PIXELBUFFER_H__
 
 #include "CmD3D9Prerequisites.h"
-#include "CmHardwarePixelBuffer.h"
+#include "CmPixelBuffer.h"
 
 namespace CamelotEngine {
 
 	class D3D9Texture;
 	class D3D9RenderTexture;
 
-	class CM_D3D9_EXPORT D3D9HardwarePixelBuffer : public HardwarePixelBuffer
+	class CM_D3D9_EXPORT D3D9PixelBuffer : public PixelBuffer
 	{
 	public:
-		D3D9HardwarePixelBuffer(GpuBufferUsage usage, 
+		D3D9PixelBuffer(GpuBufferUsage usage, 
 			D3D9Texture* ownerTexture);
-		~D3D9HardwarePixelBuffer();
+		~D3D9PixelBuffer();
 
 		/// Call this to associate a D3D surface or volume with this pixel buffer
 		void bind(IDirect3DDevice9 *dev, IDirect3DSurface9 *mSurface,
@@ -49,7 +49,7 @@ namespace CamelotEngine {
 		void bind(IDirect3DDevice9 *dev, IDirect3DVolume9 *mVolume, IDirect3DBaseTexture9 *mipTex);
 
 		/// @copydoc HardwarePixelBuffer::blit
-		void blit(const HardwarePixelBufferPtr &src, const Box &srcBox, const Box &dstBox);
+		void blit(const PixelBufferPtr &src, const Box &srcBox, const Box &dstBox);
 
 		/// @copydoc HardwarePixelBuffer::blitFromMemory
 		void blitFromMemory(const PixelData &src, const Box &dstBox);
@@ -124,7 +124,7 @@ namespace CamelotEngine {
 		BufferResources* getBufferResources(IDirect3DDevice9* d3d9Device);
 		BufferResources* createBufferResources();
 
-		void blit(IDirect3DDevice9* d3d9Device, const HardwarePixelBufferPtr &src,
+		void blit(IDirect3DDevice9* d3d9Device, const PixelBufferPtr &src,
 				const Box &srcBox, const Box &dstBox, 
 				BufferResources* srcBufferResources, 
 				BufferResources* dstBufferResources);

CamelotD3D9Renderer/Include/CmD3D9Prerequisites.h

@@ -76,7 +76,7 @@ namespace CamelotEngine
 	class D3D9GpuProgram;
 	class D3D9GpuProgramManager;
     class D3D9HardwareBufferManager;
-    class D3D9HardwareIndexBuffer;
+    class D3D9IndexBuffer;
     class D3D9HLSLProgramFactory;
     class D3D9HLSLProgram;
     class D3D9VertexDeclaration;

CamelotD3D9Renderer/Include/CmD3D9Texture.h

@@ -32,7 +32,7 @@ THE SOFTWARE.
 #include "CmTexture.h"
 #include "CmRenderTexture.h"
 #include "CmException.h"
-#include "CmD3D9HardwarePixelBuffer.h"
+#include "CmD3D9PixelBuffer.h"
 #include "CmD3D9Resource.h"
 
 namespace CamelotEngine {
@@ -73,7 +73,7 @@ namespace CamelotEngine {
 			@remarks	The buffer is invalidated when the resource is unloaded or destroyed.
 						Do not use it after the lifetime of the containing texture.
 		*/
-		HardwarePixelBufferPtr getBuffer(UINT32 face, UINT32 mipmap);
+		PixelBufferPtr getBuffer(UINT32 face, UINT32 mipmap);
 
 		// Called immediately after the Direct3D device has been created.
 		virtual void notifyOnDeviceCreate(IDirect3DDevice9* d3d9Device);
@@ -89,7 +89,7 @@ namespace CamelotEngine {
 
 	protected:	
 		friend class D3D9TextureManager;
-		friend class D3D9HardwarePixelBuffer;
+		friend class D3D9PixelBuffer;
 
 		struct TextureResources
 		{
@@ -112,7 +112,7 @@ namespace CamelotEngine {
 		DeviceToTextureResourcesMap	mMapDeviceToTextureResources;
 
 		/// Vector of pointers to subsurfaces
-		typedef vector<HardwarePixelBufferPtr>::type SurfaceList;
+		typedef vector<PixelBufferPtr>::type SurfaceList;
 		SurfaceList	mSurfaceList;
 		/// cube texture individual face names
 		String							mCubeFaceNames[6];	
@@ -121,7 +121,7 @@ namespace CamelotEngine {
 		// Dynamic textures?
 		bool                            mDynamicTextures;
 		
-		HardwarePixelBufferPtr			mLockedBuffer;
+		PixelBufferPtr			mLockedBuffer;
 
 		/// Is hardware gamma supported (read)?
 		bool mHwGammaReadSupported;

CamelotD3D9Renderer/Include/CmD3D9HardwareVertexBuffer.h → CamelotD3D9Renderer/Include/CmD3D9VertexBuffer.h

@@ -29,19 +29,19 @@ THE SOFTWARE.
 #define __D3D9HARDWAREVERTEXBUFFER_H__
 
 #include "CmD3D9Prerequisites.h"
-#include "CmHardwareVertexBuffer.h"
+#include "CmVertexBuffer.h"
 #include "CmD3D9Resource.h"
 
 namespace CamelotEngine {
 
     /// Specialisation of HardwareVertexBuffer for D3D9
-    class CM_D3D9_EXPORT D3D9HardwareVertexBuffer : public HardwareVertexBuffer, public D3D9Resource
+    class CM_D3D9_EXPORT D3D9VertexBuffer : public VertexBuffer, public D3D9Resource
     {   
 
     public:
-		D3D9HardwareVertexBuffer(HardwareBufferManagerBase* mgr, UINT32 vertexSize, 
+		D3D9VertexBuffer(HardwareBufferManagerBase* mgr, UINT32 vertexSize, 
 			UINT32 numVertices, GpuBufferUsage usage, bool useSystemMem);
-        ~D3D9HardwareVertexBuffer();
+        ~D3D9VertexBuffer();
         /** See HardwareBuffer. */
         void readData(UINT32 offset, UINT32 length, void* pDest);
         /** See HardwareBuffer. */

CamelotD3D9Renderer/Source/CmD3D9HardwareBufferManager.cpp

@@ -26,8 +26,8 @@ THE SOFTWARE.
 -----------------------------------------------------------------------------
 */
 #include "CmD3D9HardwareBufferManager.h"
-#include "CmD3D9HardwareVertexBuffer.h"
-#include "CmD3D9HardwareIndexBuffer.h"
+#include "CmD3D9VertexBuffer.h"
+#include "CmD3D9IndexBuffer.h"
 #include "CmD3D9VertexDeclaration.h"
 #include "CmD3D9GenericBuffer.h"
 #include "CmGpuParamBlock.h"
@@ -50,7 +50,7 @@ namespace CamelotEngine {
     {
 		assert (numVerts > 0);
 
-		D3D9HardwareVertexBuffer* vbuf = new D3D9HardwareVertexBuffer(
+		D3D9VertexBuffer* vbuf = new D3D9VertexBuffer(
 			this, vertexSize, numVerts, usage, false);
 		{
 			mVertexBuffers.insert(vbuf);
@@ -60,11 +60,11 @@ namespace CamelotEngine {
     //-----------------------------------------------------------------------
 	HardwareIndexBufferPtr 
     D3D9HardwareBufferManagerBase::
-    createIndexBuffer(HardwareIndexBuffer::IndexType itype, UINT32 numIndexes, GpuBufferUsage usage)
+    createIndexBuffer(IndexBuffer::IndexType itype, UINT32 numIndexes, GpuBufferUsage usage)
     {
 		assert (numIndexes > 0);
 
-		D3D9HardwareIndexBuffer* idx = new D3D9HardwareIndexBuffer(this, itype, numIndexes, usage, false);
+		D3D9IndexBuffer* idx = new D3D9IndexBuffer(this, itype, numIndexes, usage, false);
 		{
 			mIndexBuffers.insert(idx);
 		}

CamelotD3D9Renderer/Source/CmD3D9HardwareIndexBuffer.cpp → CamelotD3D9Renderer/Source/CmD3D9IndexBuffer.cpp

@@ -25,7 +25,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 ----------------------------------------------------------------------------
 */
-#include "CmD3D9HardwareIndexBuffer.h"
+#include "CmD3D9IndexBuffer.h"
 #include "CmD3D9Mappings.h"
 #include "CmException.h"
 #include "CmD3D9HardwareBufferManager.h"
@@ -36,10 +36,10 @@ THE SOFTWARE.
 namespace CamelotEngine {
 
 	//---------------------------------------------------------------------
-    D3D9HardwareIndexBuffer::D3D9HardwareIndexBuffer(HardwareBufferManagerBase* mgr, HardwareIndexBuffer::IndexType idxType, 
+    D3D9IndexBuffer::D3D9IndexBuffer(HardwareBufferManagerBase* mgr, IndexBuffer::IndexType idxType, 
         UINT32 numIndexes, GpuBufferUsage usage,
         bool useSystemMemory)
-        : HardwareIndexBuffer(mgr, idxType, numIndexes, usage, useSystemMemory)
+        : IndexBuffer(mgr, idxType, numIndexes, usage, useSystemMemory)
     {
 		D3D9_DEVICE_ACCESS_CRITICAL_SECTION
 
@@ -70,7 +70,7 @@ namespace CamelotEngine {
 		}				
     }
 	//---------------------------------------------------------------------
-    D3D9HardwareIndexBuffer::~D3D9HardwareIndexBuffer()
+    D3D9IndexBuffer::~D3D9IndexBuffer()
     {
 		D3D9_DEVICE_ACCESS_CRITICAL_SECTION
 
@@ -86,7 +86,7 @@ namespace CamelotEngine {
 		SAFE_DELETE_ARRAY(mSystemMemoryBuffer);
     }
 	//---------------------------------------------------------------------
-    void* D3D9HardwareIndexBuffer::lockImpl(UINT32 offset, 
+    void* D3D9IndexBuffer::lockImpl(UINT32 offset, 
         UINT32 length, GpuLockOptions options)
     {		
 		D3D9_DEVICE_ACCESS_CRITICAL_SECTION
@@ -126,7 +126,7 @@ namespace CamelotEngine {
 		return mSystemMemoryBuffer + offset;		
     }
 	//---------------------------------------------------------------------
-	void D3D9HardwareIndexBuffer::unlockImpl(void)
+	void D3D9IndexBuffer::unlockImpl(void)
     {	
 		D3D9_DEVICE_ACCESS_CRITICAL_SECTION
 
@@ -148,7 +148,7 @@ namespace CamelotEngine {
 		}			
     }
 	//---------------------------------------------------------------------
-    void D3D9HardwareIndexBuffer::readData(UINT32 offset, UINT32 length, 
+    void D3D9IndexBuffer::readData(UINT32 offset, UINT32 length, 
         void* pDest)
     {
        // There is no functional interface in D3D, just do via manual 
@@ -159,7 +159,7 @@ namespace CamelotEngine {
 
     }
 	//---------------------------------------------------------------------
-    void D3D9HardwareIndexBuffer::writeData(UINT32 offset, UINT32 length, 
+    void D3D9IndexBuffer::writeData(UINT32 offset, UINT32 length, 
             const void* pSource,
 			bool discardWholeBuffer)
     {
@@ -171,7 +171,7 @@ namespace CamelotEngine {
         this->unlock();    
 	}
 	//---------------------------------------------------------------------
-	void D3D9HardwareIndexBuffer::notifyOnDeviceCreate(IDirect3DDevice9* d3d9Device)
+	void D3D9IndexBuffer::notifyOnDeviceCreate(IDirect3DDevice9* d3d9Device)
 	{			
 		D3D9_DEVICE_ACCESS_CRITICAL_SECTION
 
@@ -180,7 +180,7 @@ namespace CamelotEngine {
 
 	}
 	//---------------------------------------------------------------------
-	void D3D9HardwareIndexBuffer::notifyOnDeviceDestroy(IDirect3DDevice9* d3d9Device)
+	void D3D9IndexBuffer::notifyOnDeviceDestroy(IDirect3DDevice9* d3d9Device)
 	{		
 		D3D9_DEVICE_ACCESS_CRITICAL_SECTION
 
@@ -194,7 +194,7 @@ namespace CamelotEngine {
 		}
 	}
 	//---------------------------------------------------------------------
-	void D3D9HardwareIndexBuffer::notifyOnDeviceLost(IDirect3DDevice9* d3d9Device)
+	void D3D9IndexBuffer::notifyOnDeviceLost(IDirect3DDevice9* d3d9Device)
 	{		
 		D3D9_DEVICE_ACCESS_CRITICAL_SECTION
 
@@ -209,7 +209,7 @@ namespace CamelotEngine {
 		}
 	}
 	//---------------------------------------------------------------------
-	void D3D9HardwareIndexBuffer::notifyOnDeviceReset(IDirect3DDevice9* d3d9Device)
+	void D3D9IndexBuffer::notifyOnDeviceReset(IDirect3DDevice9* d3d9Device)
 	{		
 		D3D9_DEVICE_ACCESS_CRITICAL_SECTION
 
@@ -217,7 +217,7 @@ namespace CamelotEngine {
 			createBuffer(d3d9Device, mBufferDesc.Pool);		
 	}
 	//---------------------------------------------------------------------
-	void D3D9HardwareIndexBuffer::createBuffer(IDirect3DDevice9* d3d9Device, D3DPOOL ePool)
+	void D3D9IndexBuffer::createBuffer(IDirect3DDevice9* d3d9Device, D3DPOOL ePool)
 	{
 		D3D9_DEVICE_ACCESS_CRITICAL_SECTION
 
@@ -273,7 +273,7 @@ namespace CamelotEngine {
 	}
 
 	//---------------------------------------------------------------------
-	IDirect3DIndexBuffer9* D3D9HardwareIndexBuffer::getD3DIndexBuffer(void)
+	IDirect3DIndexBuffer9* D3D9IndexBuffer::getD3DIndexBuffer(void)
 	{		
 		IDirect3DDevice9* d3d9Device = D3D9RenderSystem::getActiveD3D9Device();
 		DeviceToBufferResourcesIterator it;
@@ -298,7 +298,7 @@ namespace CamelotEngine {
 		return it->second->mBuffer;
 	}
 	//---------------------------------------------------------------------
-	bool D3D9HardwareIndexBuffer::updateBufferResources(const char* systemMemoryBuffer,
+	bool D3D9IndexBuffer::updateBufferResources(const char* systemMemoryBuffer,
 		BufferResources* bufferResources)
 	{
 		assert(bufferResources != NULL);

CamelotD3D9Renderer/Source/CmD3D9Mappings.cpp

@@ -358,9 +358,9 @@ namespace CamelotEngine
         return ret;
     }
 	//---------------------------------------------------------------------
-    D3DFORMAT D3D9Mappings::get(HardwareIndexBuffer::IndexType itype)
+    D3DFORMAT D3D9Mappings::get(IndexBuffer::IndexType itype)
     {
-        if (itype == HardwareIndexBuffer::IT_32BIT)
+        if (itype == IndexBuffer::IT_32BIT)
         {
             return D3DFMT_INDEX32;
         }

CamelotD3D9Renderer/Source/CmD3D9MultiRenderTexture.cpp

@@ -21,7 +21,7 @@ namespace CamelotEngine
 		if(texture != nullptr)
 		{
 			D3D9Texture* d3d9texture = static_cast<D3D9Texture*>(texture.get());
-			D3D9HardwarePixelBuffer* pixelBuffer = static_cast<D3D9HardwarePixelBuffer*>(d3d9texture->getBuffer(face, mipLevel).get());
+			D3D9PixelBuffer* pixelBuffer = static_cast<D3D9PixelBuffer*>(d3d9texture->getBuffer(face, mipLevel).get());
 			mColorSurfaces[surfaceIdx] = pixelBuffer->getSurface(D3D9RenderSystem::getActiveD3D9Device());
 		}
 		else

CamelotD3D9Renderer/Source/CmD3D9HardwareOcclusionQuery.cpp → CamelotD3D9Renderer/Source/CmD3D9OcclusionQuery.cpp

@@ -25,7 +25,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 -----------------------------------------------------------------------------
 */
-#include "CmD3D9HardwareOcclusionQuery.h"
+#include "CmD3D9OcclusionQuery.h"
 #include "CmRenderSystemCapabilities.h"
 #include "CmException.h"
 #include "CmD3D9RenderSystem.h"
@@ -45,7 +45,7 @@ namespace CamelotEngine {
 	/**
 	* Default object constructor
 	*/
-    D3D9HardwareOcclusionQuery::D3D9HardwareOcclusionQuery()
+    D3D9OcclusionQuery::D3D9OcclusionQuery()
 	{ 
 		
 	}
@@ -53,7 +53,7 @@ namespace CamelotEngine {
 	/**
 	* Object destructor
 	*/
-	D3D9HardwareOcclusionQuery::~D3D9HardwareOcclusionQuery() 
+	D3D9OcclusionQuery::~D3D9OcclusionQuery() 
 	{ 
 		DeviceToQueryIterator it = mMapDeviceToQuery.begin();
 
@@ -68,7 +68,7 @@ namespace CamelotEngine {
 	//------------------------------------------------------------------
 	// Occlusion query functions (see base class documentation for this)
 	//--
-	void D3D9HardwareOcclusionQuery::beginOcclusionQuery() 
+	void D3D9OcclusionQuery::beginOcclusionQuery() 
 	{	
 		IDirect3DDevice9* pCurDevice  = D3D9RenderSystem::getActiveD3D9Device();				
 		DeviceToQueryIterator it      = mMapDeviceToQuery.find(pCurDevice);
@@ -90,7 +90,7 @@ namespace CamelotEngine {
 		}		
 	}
 
-	void D3D9HardwareOcclusionQuery::endOcclusionQuery() 
+	void D3D9OcclusionQuery::endOcclusionQuery() 
 	{ 
 		IDirect3DDevice9* pCurDevice  = D3D9RenderSystem::getActiveD3D9Device();				
 		DeviceToQueryIterator it      = mMapDeviceToQuery.find(pCurDevice);
@@ -107,7 +107,7 @@ namespace CamelotEngine {
 	}	
 
 	//------------------------------------------------------------------
-	bool D3D9HardwareOcclusionQuery::pullOcclusionQuery( unsigned int* NumOfFragments ) 
+	bool D3D9OcclusionQuery::pullOcclusionQuery( unsigned int* NumOfFragments ) 
 	{
 		IDirect3DDevice9* pCurDevice = D3D9RenderSystem::getActiveD3D9Device();
 		DeviceToQueryIterator it     = mMapDeviceToQuery.find(pCurDevice);
@@ -155,13 +155,13 @@ namespace CamelotEngine {
 	}
 
 	//------------------------------------------------------------------
-	unsigned int D3D9HardwareOcclusionQuery::getLastQuerysPixelcount()
+	unsigned int D3D9OcclusionQuery::getLastQuerysPixelcount()
 	{
 		return mPixelCount;
 	}
 
     //------------------------------------------------------------------
-    bool D3D9HardwareOcclusionQuery::isStillOutstanding(void)
+    bool D3D9OcclusionQuery::isStillOutstanding(void)
     {       
         // in case you already asked for this query
         if (!mIsQueryResultStillOutstanding)
@@ -195,31 +195,31 @@ namespace CamelotEngine {
 	}
 
 	//------------------------------------------------------------------
-	void D3D9HardwareOcclusionQuery::notifyOnDeviceCreate(IDirect3DDevice9* d3d9Device)
+	void D3D9OcclusionQuery::notifyOnDeviceCreate(IDirect3DDevice9* d3d9Device)
 	{
 		
 	}
 
 	//------------------------------------------------------------------
-	void D3D9HardwareOcclusionQuery::notifyOnDeviceDestroy(IDirect3DDevice9* d3d9Device)
+	void D3D9OcclusionQuery::notifyOnDeviceDestroy(IDirect3DDevice9* d3d9Device)
 	{		
 		releaseQuery(d3d9Device);
 	}
 
 	//------------------------------------------------------------------
-	void D3D9HardwareOcclusionQuery::notifyOnDeviceLost(IDirect3DDevice9* d3d9Device)
+	void D3D9OcclusionQuery::notifyOnDeviceLost(IDirect3DDevice9* d3d9Device)
 	{		
 		releaseQuery(d3d9Device);		
 	}
 
 	//------------------------------------------------------------------
-	void D3D9HardwareOcclusionQuery::notifyOnDeviceReset(IDirect3DDevice9* d3d9Device)
+	void D3D9OcclusionQuery::notifyOnDeviceReset(IDirect3DDevice9* d3d9Device)
 	{		
 		
 	}
 
 	//------------------------------------------------------------------
-	void D3D9HardwareOcclusionQuery::createQuery(IDirect3DDevice9* d3d9Device)
+	void D3D9OcclusionQuery::createQuery(IDirect3DDevice9* d3d9Device)
 	{
 		HRESULT hr;
 
@@ -239,7 +239,7 @@ namespace CamelotEngine {
 	}
 
 	//------------------------------------------------------------------
-	void D3D9HardwareOcclusionQuery::releaseQuery(IDirect3DDevice9* d3d9Device)
+	void D3D9OcclusionQuery::releaseQuery(IDirect3DDevice9* d3d9Device)
 	{
 		DeviceToQueryIterator it     = mMapDeviceToQuery.find(d3d9Device);
 

CamelotD3D9Renderer/Source/CmD3D9HardwarePixelBuffer.cpp → CamelotD3D9Renderer/Source/CmD3D9PixelBuffer.cpp

@@ -25,7 +25,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 -----------------------------------------------------------------------------
 */
-#include "CmD3D9HardwarePixelBuffer.h"
+#include "CmD3D9PixelBuffer.h"
 #include "CmD3D9Texture.h"
 #include "CmD3D9Mappings.h"
 #include "CmException.h"
@@ -34,16 +34,16 @@ THE SOFTWARE.
 
 namespace CamelotEngine 
 {
-	CM_STATIC_MUTEX_INSTANCE(D3D9HardwarePixelBuffer::msDeviceAccessMutex)
+	CM_STATIC_MUTEX_INSTANCE(D3D9PixelBuffer::msDeviceAccessMutex)
 	//-----------------------------------------------------------------------------  
 
-	D3D9HardwarePixelBuffer::D3D9HardwarePixelBuffer(GpuBufferUsage usage, 
+	D3D9PixelBuffer::D3D9PixelBuffer(GpuBufferUsage usage, 
 													 D3D9Texture* ownerTexture):
-		HardwarePixelBuffer(0, 0, 0, PF_UNKNOWN, usage, false),
+		PixelBuffer(0, 0, 0, PF_UNKNOWN, usage, false),
 		mDoMipmapGen(0), mHWMipmaps(0), mOwnerTexture(ownerTexture)
 	{	
 	}
-	D3D9HardwarePixelBuffer::~D3D9HardwarePixelBuffer()
+	D3D9PixelBuffer::~D3D9PixelBuffer()
 	{
 		D3D9_DEVICE_ACCESS_CRITICAL_SECTION
 
@@ -59,7 +59,7 @@ namespace CamelotEngine
 		}
 	}
 	//-----------------------------------------------------------------------------  
-	void D3D9HardwarePixelBuffer::bind(IDirect3DDevice9 *dev, IDirect3DSurface9 *surface, 
+	void D3D9PixelBuffer::bind(IDirect3DDevice9 *dev, IDirect3DSurface9 *surface, 
 									   bool writeGamma, UINT32 fsaa, const String& srcName,
 									   IDirect3DBaseTexture9 *mipTex)
 	{
@@ -119,7 +119,7 @@ namespace CamelotEngine
 		}
 	}
 	//-----------------------------------------------------------------------------
-	void D3D9HardwarePixelBuffer::bind(IDirect3DDevice9 *dev, IDirect3DVolume9 *volume, IDirect3DBaseTexture9 *mipTex)
+	void D3D9PixelBuffer::bind(IDirect3DDevice9 *dev, IDirect3DVolume9 *volume, IDirect3DBaseTexture9 *mipTex)
 	{
 		D3D9_DEVICE_ACCESS_CRITICAL_SECTION
 
@@ -177,7 +177,7 @@ namespace CamelotEngine
 	}
 
 	//-----------------------------------------------------------------------------  
-	D3D9HardwarePixelBuffer::BufferResources* D3D9HardwarePixelBuffer::getBufferResources(IDirect3DDevice9* d3d9Device)
+	D3D9PixelBuffer::BufferResources* D3D9PixelBuffer::getBufferResources(IDirect3DDevice9* d3d9Device)
 	{
 		DeviceToBufferResourcesIterator it = mMapDeviceToBufferResources.find(d3d9Device);
 
@@ -188,7 +188,7 @@ namespace CamelotEngine
 	}
 
 	//-----------------------------------------------------------------------------  
-	D3D9HardwarePixelBuffer::BufferResources* D3D9HardwarePixelBuffer::createBufferResources()
+	D3D9PixelBuffer::BufferResources* D3D9PixelBuffer::createBufferResources()
 	{
 		BufferResources* newResources = new BufferResources;
 
@@ -198,7 +198,7 @@ namespace CamelotEngine
 	}
 
 	//-----------------------------------------------------------------------------  
-	void D3D9HardwarePixelBuffer::destroyBufferResources(IDirect3DDevice9* d3d9Device)
+	void D3D9PixelBuffer::destroyBufferResources(IDirect3DDevice9* d3d9Device)
 	{
 		D3D9_DEVICE_ACCESS_CRITICAL_SECTION
 
@@ -214,13 +214,13 @@ namespace CamelotEngine
 	}
 
 	//-----------------------------------------------------------------------------  
-	void D3D9HardwarePixelBuffer::lockDeviceAccess()
+	void D3D9PixelBuffer::lockDeviceAccess()
 	{
 		D3D9_DEVICE_ACCESS_LOCK;			
 	}
 
 	//-----------------------------------------------------------------------------  
-	void D3D9HardwarePixelBuffer::unlockDeviceAccess()
+	void D3D9PixelBuffer::unlockDeviceAccess()
 	{
 		D3D9_DEVICE_ACCESS_UNLOCK;								
 	}
@@ -317,7 +317,7 @@ namespace CamelotEngine
 		return pbox;
 	}
 	//-----------------------------------------------------------------------------  
-	PixelData D3D9HardwarePixelBuffer::lockImpl(const Box lockBox,  GpuLockOptions options)
+	PixelData D3D9PixelBuffer::lockImpl(const Box lockBox,  GpuLockOptions options)
 	{	
 		D3D9_DEVICE_ACCESS_CRITICAL_SECTION
 
@@ -356,7 +356,7 @@ namespace CamelotEngine
 	}
 
 	//-----------------------------------------------------------------------------  
-	CamelotEngine::PixelData D3D9HardwarePixelBuffer::lockBuffer(BufferResources* bufferResources, 
+	CamelotEngine::PixelData D3D9PixelBuffer::lockBuffer(BufferResources* bufferResources, 
 													   const Box &lockBox, 
 													   DWORD flags)
 	{
@@ -403,7 +403,7 @@ namespace CamelotEngine
 	}
 
 	//-----------------------------------------------------------------------------  
-	void D3D9HardwarePixelBuffer::unlockImpl(void)
+	void D3D9PixelBuffer::unlockImpl(void)
 	{
 		D3D9_DEVICE_ACCESS_CRITICAL_SECTION
 
@@ -434,7 +434,7 @@ namespace CamelotEngine
 	}
 
 	//-----------------------------------------------------------------------------  
-	void D3D9HardwarePixelBuffer::unlockBuffer(BufferResources* bufferResources)
+	void D3D9PixelBuffer::unlockBuffer(BufferResources* bufferResources)
 	{
 		if(bufferResources->surface) 
 		{
@@ -449,13 +449,13 @@ namespace CamelotEngine
 	}
 
 	//-----------------------------------------------------------------------------  
-	void D3D9HardwarePixelBuffer::blit(const HardwarePixelBufferPtr &rsrc, 
+	void D3D9PixelBuffer::blit(const PixelBufferPtr &rsrc, 
 									   const Box &srcBox, 
 									   const Box &dstBox)
 	{
 		D3D9_DEVICE_ACCESS_CRITICAL_SECTION
 
-		D3D9HardwarePixelBuffer *src = static_cast<D3D9HardwarePixelBuffer*>(rsrc.get());
+		D3D9PixelBuffer *src = static_cast<D3D9PixelBuffer*>(rsrc.get());
 		DeviceToBufferResourcesIterator it = mMapDeviceToBufferResources.begin();
 
 		// Update all the buffer copies.
@@ -475,8 +475,8 @@ namespace CamelotEngine
 	}
 
 	//-----------------------------------------------------------------------------  
-	void D3D9HardwarePixelBuffer::blit(IDirect3DDevice9* d3d9Device, 
-									   const HardwarePixelBufferPtr &rsrc, 
+	void D3D9PixelBuffer::blit(IDirect3DDevice9* d3d9Device, 
+									   const PixelBufferPtr &rsrc, 
 									   const Box &srcBox, 
 									   const Box &dstBox,
 									   BufferResources* srcBufferResources, 
@@ -567,12 +567,12 @@ namespace CamelotEngine
 		else
 		{
 			// Software fallback   
-			HardwarePixelBuffer::blit(rsrc, srcBox, dstBox);
+			PixelBuffer::blit(rsrc, srcBox, dstBox);
 		}
 	}
 
 	//-----------------------------------------------------------------------------  
-	void D3D9HardwarePixelBuffer::blitFromMemory(const PixelData &src, const Box &dstBox)
+	void D3D9PixelBuffer::blitFromMemory(const PixelData &src, const Box &dstBox)
 	{	
 		D3D9_DEVICE_ACCESS_CRITICAL_SECTION
 
@@ -588,7 +588,7 @@ namespace CamelotEngine
 	}
 
 	//-----------------------------------------------------------------------------  
-	void D3D9HardwarePixelBuffer::blitFromMemory(const PixelData &src, const Box &dstBox, BufferResources* dstBufferResources)
+	void D3D9PixelBuffer::blitFromMemory(const PixelData &src, const Box &dstBox, BufferResources* dstBufferResources)
 	{
 		// for scoped deletion of conversion buffer
 		void* data = NULL;
@@ -680,7 +680,7 @@ namespace CamelotEngine
 	}
 
 	//-----------------------------------------------------------------------------  
-	void D3D9HardwarePixelBuffer::blitToMemory(const Box &srcBox, const PixelData &dst)
+	void D3D9PixelBuffer::blitToMemory(const Box &srcBox, const PixelData &dst)
 	{
 		D3D9_DEVICE_ACCESS_CRITICAL_SECTION
 
@@ -691,7 +691,7 @@ namespace CamelotEngine
 	}
 
 	//-----------------------------------------------------------------------------  
-	void D3D9HardwarePixelBuffer::blitToMemory(const Box &srcBox, const PixelData &dst, 
+	void D3D9PixelBuffer::blitToMemory(const Box &srcBox, const PixelData &dst, 
 											   BufferResources* srcBufferResources,
 											   IDirect3DDevice9* d3d9Device)
 	{
@@ -846,7 +846,7 @@ namespace CamelotEngine
 	}
 
 	//-----------------------------------------------------------------------------  
-	void D3D9HardwarePixelBuffer::_genMipmaps(IDirect3DBaseTexture9* mipTex)
+	void D3D9PixelBuffer::_genMipmaps(IDirect3DBaseTexture9* mipTex)
 	{
 		assert(mipTex);
 
@@ -867,14 +867,14 @@ namespace CamelotEngine
 
 	}
 	//----------------------------------------------------------------------------- 
-	void D3D9HardwarePixelBuffer::_setMipmapping(bool doMipmapGen, 
+	void D3D9PixelBuffer::_setMipmapping(bool doMipmapGen, 
 												 bool HWMipmaps)
 	{	
 		mDoMipmapGen = doMipmapGen;
 		mHWMipmaps = HWMipmaps;	
 	}
 	//-----------------------------------------------------------------------------  
-	void D3D9HardwarePixelBuffer::releaseSurfaces(IDirect3DDevice9* d3d9Device)
+	void D3D9PixelBuffer::releaseSurfaces(IDirect3DDevice9* d3d9Device)
 	{
 		BufferResources* bufferResources = getBufferResources(d3d9Device);
 
@@ -885,7 +885,7 @@ namespace CamelotEngine
 		}
 	}
 	//-----------------------------------------------------------------------------   
-	IDirect3DSurface9* D3D9HardwarePixelBuffer::getSurface(IDirect3DDevice9* d3d9Device)
+	IDirect3DSurface9* D3D9PixelBuffer::getSurface(IDirect3DDevice9* d3d9Device)
 	{
 		BufferResources* bufferResources = getBufferResources(d3d9Device);
 

CamelotD3D9Renderer/Source/CmD3D9RenderSystem.cpp

@@ -37,13 +37,13 @@ THE SOFTWARE.
 #include "CmMath.h"
 #include "CmCamera.h"
 #include "CmD3D9HardwareBufferManager.h"
-#include "CmD3D9HardwareIndexBuffer.h"
-#include "CmD3D9HardwareVertexBuffer.h"
+#include "CmD3D9IndexBuffer.h"
+#include "CmD3D9VertexBuffer.h"
 #include "CmD3D9VertexDeclaration.h"
 #include "CmD3D9GpuProgram.h"
 #include "CmD3D9GpuProgramManager.h"
 #include "CmD3D9HLSLProgramFactory.h"
-#include "CmD3D9HardwareOcclusionQuery.h"
+#include "CmD3D9OcclusionQuery.h"
 #include "CmD3D9DeviceManager.h"
 #include "CmD3D9ResourceManager.h"
 #include "CmD3D9RenderWindowManager.h"
@@ -1210,8 +1210,8 @@ namespace CamelotEngine
 				}
 			}
 
-			D3D9HardwareVertexBuffer* d3d9buf = 
-				static_cast<D3D9HardwareVertexBuffer*>(i->second.get());
+			D3D9VertexBuffer* d3d9buf = 
+				static_cast<D3D9VertexBuffer*>(i->second.get());
 			hr = getActiveD3D9Device()->SetStreamSource(
 				static_cast<UINT>(source),
 				d3d9buf->getD3D9VertexBuffer(),
@@ -1302,8 +1302,8 @@ namespace CamelotEngine
 		HRESULT hr;
 		if( op.useIndexes )
 		{
-			D3D9HardwareIndexBuffer* d3dIdxBuf = 
-				static_cast<D3D9HardwareIndexBuffer*>(op.indexData->indexBuffer.get());
+			D3D9IndexBuffer* d3dIdxBuf = 
+				static_cast<D3D9IndexBuffer*>(op.indexData->indexBuffer.get());
 			hr = getActiveD3D9Device()->SetIndices( d3dIdxBuf->getD3DIndexBuffer() );
 			if (FAILED(hr))
 			{

CamelotD3D9Renderer/Source/CmD3D9RenderTexture.cpp

@@ -1,6 +1,6 @@
 #include "CmD3D9RenderTexture.h"
 #include "CmD3D9Texture.h"
-#include "CmD3D9HardwarePixelBuffer.h"
+#include "CmD3D9PixelBuffer.h"
 #include "CmD3D9RenderSystem.h"
 #include "CmD3D9DepthStencilBuffer.h"
 
@@ -42,7 +42,7 @@ namespace CamelotEngine
 	void D3D9RenderTexture::createInternalResourcesImpl()
 	{
 		D3D9Texture* d3d9texture = static_cast<D3D9Texture*>(mSurface.texture.get());
-		D3D9HardwarePixelBuffer* pixelBuffer = static_cast<D3D9HardwarePixelBuffer*>(d3d9texture->getBuffer(mSurface.face, mSurface.mipLevel).get());
+		D3D9PixelBuffer* pixelBuffer = static_cast<D3D9PixelBuffer*>(d3d9texture->getBuffer(mSurface.face, mSurface.mipLevel).get());
 		mColorSurface = pixelBuffer->getSurface(D3D9RenderSystem::getActiveD3D9Device());
 
 		D3D9DepthStencilBuffer* d3d9DepthStencil = static_cast<D3D9DepthStencilBuffer*>(mDepthStencilBuffer.get());

CamelotD3D9Renderer/Source/CmD3D9ResourceManager.cpp

@@ -27,7 +27,7 @@ THE SOFTWARE.
 */
 #include "CmD3D9Resource.h"
 #include "CmD3D9ResourceManager.h"
-#include "CmD3D9HardwarePixelBuffer.h"
+#include "CmD3D9PixelBuffer.h"
 
 namespace CamelotEngine
 {
@@ -143,7 +143,7 @@ namespace CamelotEngine
 		{					
 			CM_LOCK_RECURSIVE_MUTEX(mResourcesMutex);		
 			D3D9Resource::lockDeviceAccess();
-			D3D9HardwarePixelBuffer::lockDeviceAccess();
+			D3D9PixelBuffer::lockDeviceAccess();
 		}
 	}
 
@@ -154,7 +154,7 @@ namespace CamelotEngine
 		mDeviceAccessLockCount--;				
 		if (mDeviceAccessLockCount == 0)
 		{						
-			D3D9HardwarePixelBuffer::unlockDeviceAccess();
+			D3D9PixelBuffer::unlockDeviceAccess();
 			D3D9Resource::unlockDeviceAccess();			
 			CM_UNLOCK_RECURSIVE_MUTEX(mResourcesMutex);			
 		}

CamelotD3D9Renderer/Source/CmD3D9Texture.cpp

@@ -26,7 +26,7 @@ THE SOFTWARE.
 -----------------------------------------------------------------------------
 */
 #include "CmD3D9Texture.h"
-#include "CmD3D9HardwarePixelBuffer.h"
+#include "CmD3D9PixelBuffer.h"
 #include "CmException.h"
 #include "CmBitwise.h"
 #include "CmD3D9Mappings.h"
@@ -301,7 +301,7 @@ namespace CamelotEngine
 		// Release surfaces from each mip level.
 		for(unsigned int i = 0; i < mSurfaceList.size(); ++i)
 		{
-			D3D9HardwarePixelBuffer* pixelBuffer = static_cast<D3D9HardwarePixelBuffer*>(mSurfaceList[i].get());
+			D3D9PixelBuffer* pixelBuffer = static_cast<D3D9PixelBuffer*>(mSurfaceList[i].get());
 
 			pixelBuffer->releaseSurfaces(d3d9Device);			
 		}
@@ -927,12 +927,12 @@ namespace CamelotEngine
 	/****************************************************************************************/
 	// Macro to hide ugly cast
 	#define GETLEVEL(face,mip) \
-	 	static_cast<D3D9HardwarePixelBuffer*>(mSurfaceList[face*(mNumMipmaps+1)+mip].get())
+	 	static_cast<D3D9PixelBuffer*>(mSurfaceList[face*(mNumMipmaps+1)+mip].get())
 	void D3D9Texture::_createSurfaceList(IDirect3DDevice9* d3d9Device, TextureResources* textureResources)
 	{
 		IDirect3DSurface9 *surface;
 		IDirect3DVolume9 *volume;
-		D3D9HardwarePixelBuffer *buffer;				
+		D3D9PixelBuffer *buffer;				
 		UINT32 mip, face;
 
 		
@@ -972,8 +972,8 @@ namespace CamelotEngine
 			{
 				for(UINT32 mip=0; mip<=mNumMipmaps; ++mip)
 				{
-					buffer = new D3D9HardwarePixelBuffer((GpuBufferUsage)bufusage, this);
-					mSurfaceList.push_back(HardwarePixelBufferPtr(buffer));
+					buffer = new D3D9PixelBuffer((GpuBufferUsage)bufusage, this);
+					mSurfaceList.push_back(PixelBufferPtr(buffer));
 				}
 			}
 		}
@@ -983,7 +983,7 @@ namespace CamelotEngine
 			assert(textureResources->pFSAASurface);
 			assert(getTextureType() == TEX_TYPE_2D);
 
-			D3D9HardwarePixelBuffer* currPixelBuffer = GETLEVEL(0, 0);
+			D3D9PixelBuffer* currPixelBuffer = GETLEVEL(0, 0);
 
 			currPixelBuffer->bind(d3d9Device, textureResources->pFSAASurface,
 				mHwGammaWriteSupported, mFSAA, "PortNoName", textureResources->pBaseTex);
@@ -1001,7 +1001,7 @@ namespace CamelotEngine
 					if(textureResources->pNormTex->GetSurfaceLevel(static_cast<UINT>(mip), &surface) != D3D_OK)
 						CM_EXCEPT(RenderingAPIException, "Get surface level failed");
 
-					D3D9HardwarePixelBuffer* currPixelBuffer = GETLEVEL(0, mip);
+					D3D9PixelBuffer* currPixelBuffer = GETLEVEL(0, mip);
 
 					currPixelBuffer->bind(d3d9Device, surface,
 						mHwGammaWriteSupported, mFSAA, "PortNoName", textureResources->pBaseTex);
@@ -1022,7 +1022,7 @@ namespace CamelotEngine
 						if(textureResources->pCubeTex->GetCubeMapSurface((D3DCUBEMAP_FACES)face, static_cast<UINT>(mip), &surface) != D3D_OK)
 							CM_EXCEPT(RenderingAPIException, "Get cubemap surface failed");
 
-						D3D9HardwarePixelBuffer* currPixelBuffer = GETLEVEL(face, mip);
+						D3D9PixelBuffer* currPixelBuffer = GETLEVEL(face, mip);
 
 						currPixelBuffer->bind(d3d9Device, surface,
 							mHwGammaWriteSupported, mFSAA, "NoNamePort", textureResources->pBaseTex);
@@ -1041,7 +1041,7 @@ namespace CamelotEngine
 					if(textureResources->pVolumeTex->GetVolumeLevel(static_cast<UINT>(mip), &volume) != D3D_OK)
 						CM_EXCEPT(RenderingAPIException, "Get volume level failed");	
 
-					D3D9HardwarePixelBuffer* currPixelBuffer = GETLEVEL(0, mip);
+					D3D9PixelBuffer* currPixelBuffer = GETLEVEL(0, mip);
 
 					currPixelBuffer->bind(d3d9Device, volume, textureResources->pBaseTex);
 
@@ -1056,7 +1056,7 @@ namespace CamelotEngine
 	}
 	#undef GETLEVEL
 	/****************************************************************************************/
-	HardwarePixelBufferPtr D3D9Texture::getBuffer(UINT32 face, UINT32 mipmap) 
+	PixelBufferPtr D3D9Texture::getBuffer(UINT32 face, UINT32 mipmap) 
 	{
 		THROW_IF_NOT_RENDER_THREAD;
 
@@ -1111,7 +1111,7 @@ namespace CamelotEngine
 			// Destroy surfaces from each mip level.
 			for(unsigned int i = 0; i < mSurfaceList.size(); ++i)
 			{
-				D3D9HardwarePixelBuffer* pixelBuffer = static_cast<D3D9HardwarePixelBuffer*>(mSurfaceList[i].get());
+				D3D9PixelBuffer* pixelBuffer = static_cast<D3D9PixelBuffer*>(mSurfaceList[i].get());
 
 				pixelBuffer->destroyBufferResources(d3d9Device);			
 			}

CamelotD3D9Renderer/Source/CmD3D9HardwareVertexBuffer.cpp → CamelotD3D9Renderer/Source/CmD3D9VertexBuffer.cpp

@@ -25,7 +25,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 -----------------------------------------------------------------------------
 */
-#include "CmD3D9HardwareVertexBuffer.h"
+#include "CmD3D9VertexBuffer.h"
 #include "CmD3D9Mappings.h"
 #include "CmException.h"
 #include "CmD3D9HardwareBufferManager.h"
@@ -36,10 +36,10 @@ THE SOFTWARE.
 namespace CamelotEngine {
 
 	//---------------------------------------------------------------------
-    D3D9HardwareVertexBuffer::D3D9HardwareVertexBuffer(HardwareBufferManagerBase* mgr, UINT32 vertexSize, 
+    D3D9VertexBuffer::D3D9VertexBuffer(HardwareBufferManagerBase* mgr, UINT32 vertexSize, 
         UINT32 numVertices, GpuBufferUsage usage, 
         bool useSystemMemory)
-		: HardwareVertexBuffer(mgr, vertexSize, numVertices, usage, useSystemMemory)
+		: VertexBuffer(mgr, vertexSize, numVertices, usage, useSystemMemory)
     {
 		D3D9_DEVICE_ACCESS_CRITICAL_SECTION
 
@@ -70,7 +70,7 @@ namespace CamelotEngine {
 		}				
     }
 	//---------------------------------------------------------------------
-    D3D9HardwareVertexBuffer::~D3D9HardwareVertexBuffer()
+    D3D9VertexBuffer::~D3D9VertexBuffer()
     {	
 		D3D9_DEVICE_ACCESS_CRITICAL_SECTION
 
@@ -86,7 +86,7 @@ namespace CamelotEngine {
 		SAFE_DELETE_ARRAY(mSystemMemoryBuffer);
     }
 	//---------------------------------------------------------------------
-    void* D3D9HardwareVertexBuffer::lockImpl(UINT32 offset, 
+    void* D3D9VertexBuffer::lockImpl(UINT32 offset, 
         UINT32 length, GpuLockOptions options)
     {		
 		D3D9_DEVICE_ACCESS_CRITICAL_SECTION
@@ -126,7 +126,7 @@ namespace CamelotEngine {
 		return mSystemMemoryBuffer + offset;		
     }
 	//---------------------------------------------------------------------
-	void D3D9HardwareVertexBuffer::unlockImpl(void)
+	void D3D9VertexBuffer::unlockImpl(void)
     {
 		D3D9_DEVICE_ACCESS_CRITICAL_SECTION
 
@@ -148,7 +148,7 @@ namespace CamelotEngine {
 		}			
     }
 	//---------------------------------------------------------------------
-    void D3D9HardwareVertexBuffer::readData(UINT32 offset, UINT32 length, 
+    void D3D9VertexBuffer::readData(UINT32 offset, UINT32 length, 
         void* pDest)
     {
         // There is no functional interface in D3D, just do via manual 
@@ -159,7 +159,7 @@ namespace CamelotEngine {
 
     }
 	//---------------------------------------------------------------------
-	void D3D9HardwareVertexBuffer::writeData(UINT32 offset, UINT32 length, 
+	void D3D9VertexBuffer::writeData(UINT32 offset, UINT32 length, 
 		const void* pSource,
 		bool discardWholeBuffer)
 	{
@@ -171,7 +171,7 @@ namespace CamelotEngine {
 		this->unlock();
 	}
 	//---------------------------------------------------------------------
-	void D3D9HardwareVertexBuffer::notifyOnDeviceCreate(IDirect3DDevice9* d3d9Device)
+	void D3D9VertexBuffer::notifyOnDeviceCreate(IDirect3DDevice9* d3d9Device)
 	{			
 		D3D9_DEVICE_ACCESS_CRITICAL_SECTION
 
@@ -179,7 +179,7 @@ namespace CamelotEngine {
 			createBuffer(d3d9Device, mBufferDesc.Pool);
 	}
 	//---------------------------------------------------------------------
-	void D3D9HardwareVertexBuffer::notifyOnDeviceDestroy(IDirect3DDevice9* d3d9Device)
+	void D3D9VertexBuffer::notifyOnDeviceDestroy(IDirect3DDevice9* d3d9Device)
 	{	
 		D3D9_DEVICE_ACCESS_CRITICAL_SECTION
 
@@ -193,7 +193,7 @@ namespace CamelotEngine {
 		}	
 	}
 	//---------------------------------------------------------------------
-	void D3D9HardwareVertexBuffer::notifyOnDeviceLost(IDirect3DDevice9* d3d9Device)
+	void D3D9VertexBuffer::notifyOnDeviceLost(IDirect3DDevice9* d3d9Device)
 	{	
 		D3D9_DEVICE_ACCESS_CRITICAL_SECTION
 
@@ -208,7 +208,7 @@ namespace CamelotEngine {
 		}
 	}
 	//---------------------------------------------------------------------
-	void D3D9HardwareVertexBuffer::notifyOnDeviceReset(IDirect3DDevice9* d3d9Device)
+	void D3D9VertexBuffer::notifyOnDeviceReset(IDirect3DDevice9* d3d9Device)
 	{		
 		D3D9_DEVICE_ACCESS_CRITICAL_SECTION
 
@@ -216,7 +216,7 @@ namespace CamelotEngine {
 			createBuffer(d3d9Device, mBufferDesc.Pool);
 	}
 	//---------------------------------------------------------------------
-	void D3D9HardwareVertexBuffer::createBuffer(IDirect3DDevice9* d3d9Device, D3DPOOL ePool)
+	void D3D9VertexBuffer::createBuffer(IDirect3DDevice9* d3d9Device, D3DPOOL ePool)
 	{
 		D3D9_DEVICE_ACCESS_CRITICAL_SECTION
 
@@ -271,7 +271,7 @@ namespace CamelotEngine {
 		}		
 	}
 	//---------------------------------------------------------------------
-	IDirect3DVertexBuffer9* D3D9HardwareVertexBuffer::getD3D9VertexBuffer(void)
+	IDirect3DVertexBuffer9* D3D9VertexBuffer::getD3D9VertexBuffer(void)
 	{
 		IDirect3DDevice9* d3d9Device = D3D9RenderSystem::getActiveD3D9Device();
 		DeviceToBufferResourcesIterator it;
@@ -296,7 +296,7 @@ namespace CamelotEngine {
 		return it->second->mBuffer;
 	}	
 	//---------------------------------------------------------------------
-	bool D3D9HardwareVertexBuffer::updateBufferResources(const char* systemMemoryBuffer,
+	bool D3D9VertexBuffer::updateBufferResources(const char* systemMemoryBuffer,
 		BufferResources* bufferResources)
 	{		
 		assert(bufferResources != NULL);

CamelotGLRenderer/CamelotGLRenderer.vcxproj

@@ -154,10 +154,10 @@
     <ClInclude Include="Include\CmGLGpuParamBlock.h" />
     <ClInclude Include="Include\CmGLGpuProgramManager.h" />
     <ClInclude Include="Include\CmGLHardwareBufferManager.h" />
-    <ClInclude Include="Include\CmGLHardwareIndexBuffer.h" />
-    <ClInclude Include="Include\CmGLHardwareOcclusionQuery.h" />
-    <ClInclude Include="Include\CmGLHardwarePixelBuffer.h" />
-    <ClInclude Include="Include\CmGLHardwareVertexBuffer.h" />
+    <ClInclude Include="Include\CmGLIndexBuffer.h" />
+    <ClInclude Include="Include\CmGLOcclusionQuery.h" />
+    <ClInclude Include="Include\CmGLPixelBuffer.h" />
+    <ClInclude Include="Include\CmGLVertexBuffer.h" />
     <ClInclude Include="Include\CmGLMultiRenderTexture.h" />
     <ClInclude Include="Include\CmGLPixelFormat.h" />
     <ClInclude Include="Include\CmGLPrerequisites.h" />
@@ -191,10 +191,10 @@
     <ClCompile Include="Source\CmGLGpuParamBlock.cpp" />
     <ClCompile Include="Source\CmGLGpuProgramManager.cpp" />
     <ClCompile Include="Source\CmGLHardwareBufferManager.cpp" />
-    <ClCompile Include="Source\CmGLHardwareIndexBuffer.cpp" />
-    <ClCompile Include="Source\CmGLHardwareOcclusionQuery.cpp" />
-    <ClCompile Include="Source\CmGLHardwarePixelBuffer.cpp" />
-    <ClCompile Include="Source\CmGLHardwareVertexBuffer.cpp" />
+    <ClCompile Include="Source\CmGLIndexBuffer.cpp" />
+    <ClCompile Include="Source\CmGLOcclusionQuery.cpp" />
+    <ClCompile Include="Source\CmGLPixelBuffer.cpp" />
+    <ClCompile Include="Source\CmGLVertexBuffer.cpp" />
     <ClCompile Include="Source\CmGLMultiRenderTexture.cpp" />
     <ClCompile Include="Source\CmGLPixelFormat.cpp" />
     <ClCompile Include="Source\CmGLRenderSystem.cpp" />

CamelotGLRenderer/CamelotGLRenderer.vcxproj.filters

@@ -36,18 +36,6 @@
     <ClInclude Include="Include\CmGLHardwareBufferManager.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="Include\CmGLHardwareIndexBuffer.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="Include\CmGLHardwareOcclusionQuery.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="Include\CmGLHardwarePixelBuffer.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="Include\CmGLHardwareVertexBuffer.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
     <ClInclude Include="Include\CmGLPixelFormat.h">
       <Filter>Header Files</Filter>
     </ClInclude>
@@ -126,6 +114,18 @@
     <ClInclude Include="Include\CmGLGenericBuffer.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="Include\CmGLOcclusionQuery.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\CmGLPixelBuffer.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\CmGLVertexBuffer.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\CmGLIndexBuffer.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Source\GLSL\src\CmGLSLExtSupport.cpp">
@@ -158,18 +158,6 @@
     <ClCompile Include="Source\CmGLHardwareBufferManager.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="Source\CmGLHardwareIndexBuffer.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="Source\CmGLHardwareOcclusionQuery.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="Source\CmGLHardwarePixelBuffer.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="Source\CmGLHardwareVertexBuffer.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
     <ClCompile Include="Source\CmGLPixelFormat.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
@@ -221,5 +209,17 @@
     <ClCompile Include="Source\CmGLGenericBuffer.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="Source\CmGLIndexBuffer.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Source\CmGLOcclusionQuery.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Source\CmGLPixelBuffer.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Source\CmGLVertexBuffer.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

CamelotGLRenderer/Include/CmGLFrameBufferObject.h

@@ -30,7 +30,7 @@ THE SOFTWARE.
 
 #include "CmGLPrerequisites.h"
 #include "CmGLContext.h"
-#include "CmGLHardwarePixelBuffer.h"
+#include "CmGLPixelBuffer.h"
 #include "CmPixelData.h"
 
 namespace CamelotEngine 

CamelotGLRenderer/Include/CmGLHardwareBufferManager.h

@@ -59,7 +59,7 @@ namespace CamelotEngine {
 		 * @copydoc HardwareBufferManagerBase::createIndexBuffer
 		 */
         HardwareIndexBufferPtr createIndexBuffer(
-            HardwareIndexBuffer::IndexType itype, UINT32 numIndexes, 
+            IndexBuffer::IndexType itype, UINT32 numIndexes, 
             GpuBufferUsage usage);
 
 		/** @copydoc HardwareBufferManagerInterface::createGpuParamBlock */

CamelotGLRenderer/Include/CmGLHardwareIndexBuffer.h → CamelotGLRenderer/Include/CmGLIndexBuffer.h

@@ -29,12 +29,12 @@ THE SOFTWARE.
 #define __GLHARDWAREINDEXBUFFER_H__
 
 #include "CmGLPrerequisites.h"
-#include "CmHardwareIndexBuffer.h"
+#include "CmIndexBuffer.h"
 
 namespace CamelotEngine { 
 
 
-    class CM_RSGL_EXPORT GLHardwareIndexBuffer : public HardwareIndexBuffer
+    class CM_RSGL_EXPORT GLIndexBuffer : public IndexBuffer
     {
     private:
         GLuint mBufferId;
@@ -50,9 +50,9 @@ namespace CamelotEngine {
         /** See HardwareBuffer. */
         void unlockImpl(void);
     public:
-        GLHardwareIndexBuffer(HardwareBufferManagerBase* mgr, IndexType idxType, UINT32 numIndexes, 
+        GLIndexBuffer(HardwareBufferManagerBase* mgr, IndexType idxType, UINT32 numIndexes, 
             GpuBufferUsage usage); 
-        ~GLHardwareIndexBuffer();
+        ~GLIndexBuffer();
         /** See HardwareBuffer. */
         void readData(UINT32 offset, UINT32 length, void* pDest);
         /** See HardwareBuffer. */

CamelotGLRenderer/Include/CmGLHardwareOcclusionQuery.h → CamelotGLRenderer/Include/CmGLOcclusionQuery.h

@@ -48,7 +48,7 @@ initialised and used in glRenderSystem and copy what is done there.
 #define __GLHARDWAREOCCLUSIONQUERY_H__
 
 #include "CmGLPrerequisites.h"
-#include "CmHardwareOcclusionQuery.h"
+#include "CmOcclusionQuery.h"
 
 
 namespace CamelotEngine { 
@@ -69,7 +69,7 @@ namespace CamelotEngine {
   * Updated on 13/9/2005 by Tuan Kuranes email: [email protected]
   */
 
-class CM_RSGL_EXPORT GLHardwareOcclusionQuery : public HardwareOcclusionQuery
+class CM_RSGL_EXPORT GLOcclusionQuery : public OcclusionQuery
 {
 //----------------------------------------------------------------------
 // Public methods
@@ -79,11 +79,11 @@ public:
 	  * Default object constructor
 	  * 
 	  */
-	GLHardwareOcclusionQuery();
+	GLOcclusionQuery();
 	/**
 	  * Object destructor
 	  */
-	~GLHardwareOcclusionQuery();
+	~GLOcclusionQuery();
 
 	//------------------------------------------------------------------
 	// Occlusion query functions (see base class documentation for this)

CamelotGLRenderer/Include/CmGLHardwarePixelBuffer.h → CamelotGLRenderer/Include/CmGLPixelBuffer.h

@@ -29,10 +29,10 @@ THE SOFTWARE.
 #define __GLPIXELBUFFER_H__
 
 #include "CmGLPrerequisites.h"
-#include "CmHardwarePixelBuffer.h"
+#include "CmPixelBuffer.h"
 
 namespace CamelotEngine {
-	class CM_RSGL_EXPORT GLHardwarePixelBuffer: public HardwarePixelBuffer
+	class CM_RSGL_EXPORT GLPixelBuffer: public PixelBuffer
 	{
 	protected:  
 		/// Lock a box
@@ -56,7 +56,7 @@ namespace CamelotEngine {
 		virtual void download(const PixelData &data);
 	public:
         /// Should be called by HardwareBufferManager
-        GLHardwarePixelBuffer(UINT32 mWidth, UINT32 mHeight, UINT32 mDepth,
+        GLPixelBuffer(UINT32 mWidth, UINT32 mHeight, UINT32 mDepth,
                 PixelFormat mFormat,
                 GpuBufferUsage usage);
 		
@@ -66,7 +66,7 @@ namespace CamelotEngine {
 		/// @copydoc HardwarePixelBuffer::blitToMemory
 		void blitToMemory(const Box &srcBox, const PixelData &dst);
 		
-		~GLHardwarePixelBuffer();
+		~GLPixelBuffer();
         
         /** Bind surface to frame buffer. Needs FBO extension.
         */
@@ -76,7 +76,7 @@ namespace CamelotEngine {
 
     /** Texture surface.
     */
-    class CM_RSGL_EXPORT GLTextureBuffer: public GLHardwarePixelBuffer
+    class CM_RSGL_EXPORT GLTextureBuffer: public GLPixelBuffer
 	{
     public:
         /** Texture constructor */
@@ -97,7 +97,7 @@ namespace CamelotEngine {
         /// Copy from framebuffer
         void copyFromFramebuffer(UINT32 zoffset);
         /// @copydoc HardwarePixelBuffer::blit
-        void blit(const HardwarePixelBufferPtr &src, const Box &srcBox, const Box &dstBox);
+        void blit(const PixelBufferPtr &src, const Box &srcBox, const Box &dstBox);
         // Blitting implementation
         void blitFromTexture(GLTextureBuffer *src, const Box &srcBox, const Box &dstBox);
     protected:
@@ -111,7 +111,7 @@ namespace CamelotEngine {
     };
      /** Renderbuffer surface.  Needs FBO extension.
      */
-    class CM_RSGL_EXPORT GLRenderBuffer: public GLHardwarePixelBuffer
+    class CM_RSGL_EXPORT GLRenderBuffer: public GLPixelBuffer
 	{
     public:
         GLRenderBuffer(GLenum format, UINT32 width, UINT32 height, GLsizei numSamples);

CamelotGLRenderer/Include/CmGLPrerequisites.h

@@ -39,13 +39,13 @@ namespace CamelotEngine {
     class GLSLGpuProgram;
     class GLContext;
     class GLRTTManager;
-    class GLHardwarePixelBuffer;
+    class GLPixelBuffer;
     class GLRenderBuffer;
 	class GLGpuParamBlock;
 	struct GLSLProgramPipeline;
 	class GLSLProgramPipelineManager;
 
-	typedef std::shared_ptr<GLHardwarePixelBuffer> GLHardwarePixelBufferPtr;
+	typedef std::shared_ptr<GLPixelBuffer> GLHardwarePixelBufferPtr;
 	typedef std::shared_ptr<GLRenderBuffer> GLRenderBufferPtr;
 	typedef std::shared_ptr<GLGpuParamBlock> GLGpuParamBlockPtr;
 

CamelotGLRenderer/Include/CmGLTexture.h

@@ -33,7 +33,7 @@ THE SOFTWARE.
 #include "CmRenderTexture.h"
 #include "CmTexture.h"
 #include "CmGLSupport.h"
-#include "CmHardwarePixelBuffer.h"
+#include "CmPixelBuffer.h"
 
 namespace CamelotEngine {
 
@@ -61,7 +61,7 @@ namespace CamelotEngine {
 			@remarks	The buffer is invalidated when the resource is unloaded or destroyed.
 						Do not use it after the lifetime of the containing texture.
 		*/
-		HardwarePixelBufferPtr getBuffer(UINT32 face, UINT32 mipmap);
+		PixelBufferPtr getBuffer(UINT32 face, UINT32 mipmap);
 
     protected:
 		friend class GLTextureManager;
@@ -91,10 +91,10 @@ namespace CamelotEngine {
     private:
         GLuint mTextureID;
         GLSupport& mGLSupport;
-		HardwarePixelBufferPtr mLockedBuffer;
+		PixelBufferPtr mLockedBuffer;
 		
 		/// Vector of pointers to subsurfaces
-		typedef vector<HardwarePixelBufferPtr>::type SurfaceList;
+		typedef vector<PixelBufferPtr>::type SurfaceList;
 		SurfaceList	mSurfaceList;
     };
 

CamelotGLRenderer/Include/CmGLHardwareVertexBuffer.h → CamelotGLRenderer/Include/CmGLVertexBuffer.h

@@ -29,12 +29,12 @@ THE SOFTWARE.
 #define __GLHARDWAREVERTEXBUFFER_H__
 
 #include "CmGLPrerequisites.h"
-#include "CmHardwareVertexBuffer.h"
+#include "CmVertexBuffer.h"
 
 namespace CamelotEngine {
 
     /// Specialisation of HardwareVertexBuffer for OpenGL
-    class CM_RSGL_EXPORT GLHardwareVertexBuffer : public HardwareVertexBuffer 
+    class CM_RSGL_EXPORT GLVertexBuffer : public VertexBuffer 
     {
     private:
         GLuint mBufferId;
@@ -51,8 +51,8 @@ namespace CamelotEngine {
         /** See HardwareBuffer. */
         void unlockImpl(void);
     public:
-        GLHardwareVertexBuffer(HardwareBufferManagerBase* mgr, UINT32 vertexSize, UINT32 numVertices, GpuBufferUsage usage); 
-        ~GLHardwareVertexBuffer();
+        GLVertexBuffer(HardwareBufferManagerBase* mgr, UINT32 vertexSize, UINT32 numVertices, GpuBufferUsage usage); 
+        ~GLVertexBuffer();
         /** See HardwareBuffer. */
         void readData(UINT32 offset, UINT32 length, void* pDest);
         /** See HardwareBuffer. */

CamelotGLRenderer/Source/CmGLDepthStencilBuffer.cpp

@@ -1,5 +1,5 @@
 #include "CmGLDepthStencilBuffer.h"
-#include "CmGLHardwarePixelBuffer.h"
+#include "CmGLPixelBuffer.h"
 #include "CmGLPixelFormat.h"
 
 namespace CamelotEngine

CamelotGLRenderer/Source/CmGLFrameBufferObject.cpp

@@ -28,7 +28,7 @@ THE SOFTWARE.
 
 #include "CmGLFrameBufferObject.h"
 #include "CmGLPixelFormat.h"
-#include "CmGLHardwarePixelBuffer.h"
+#include "CmGLPixelBuffer.h"
 #include "CmGLRenderTexture.h"
 
 namespace CamelotEngine 

CamelotGLRenderer/Source/CmGLHardwareBufferManager.cpp

@@ -26,8 +26,8 @@ THE SOFTWARE.
 -----------------------------------------------------------------------------
 */
 #include "CmGLHardwareBufferManager.h"
-#include "CmGLHardwareVertexBuffer.h"
-#include "CmGLHardwareIndexBuffer.h"
+#include "CmGLVertexBuffer.h"
+#include "CmGLIndexBuffer.h"
 #include "CmGLGenericBuffer.h"
 #include "CmHardwareBuffer.h"
 #include "CmGLGpuParamBlock.h"
@@ -85,8 +85,8 @@ namespace CamelotEngine {
     HardwareVertexBufferPtr GLHardwareBufferManagerBase::createVertexBuffer(
         UINT32 vertexSize, UINT32 numVerts, GpuBufferUsage usage, bool streamOut)
     {
-		GLHardwareVertexBuffer* buf = 
-			new GLHardwareVertexBuffer(this, vertexSize, numVerts, usage);
+		GLVertexBuffer* buf = 
+			new GLVertexBuffer(this, vertexSize, numVerts, usage);
 		{
 			mVertexBuffers.insert(buf);
 		}
@@ -95,11 +95,11 @@ namespace CamelotEngine {
     //-----------------------------------------------------------------------
     HardwareIndexBufferPtr 
     GLHardwareBufferManagerBase::createIndexBuffer(
-        HardwareIndexBuffer::IndexType itype, UINT32 numIndexes, 
+        IndexBuffer::IndexType itype, UINT32 numIndexes, 
         GpuBufferUsage usage)
     {
-		GLHardwareIndexBuffer* buf = 
-			new GLHardwareIndexBuffer(this, itype, numIndexes, usage);
+		GLIndexBuffer* buf = 
+			new GLIndexBuffer(this, itype, numIndexes, usage);
 		{
 			mIndexBuffers.insert(buf);
 		}

CamelotGLRenderer/Source/CmGLHardwareIndexBuffer.cpp → CamelotGLRenderer/Source/CmGLIndexBuffer.cpp

@@ -25,16 +25,16 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 -----------------------------------------------------------------------------
 */
-#include "CmGLHardwareIndexBuffer.h"
+#include "CmGLIndexBuffer.h"
 #include "CmGLHardwareBufferManager.h"
 #include "CmException.h"
 
 namespace CamelotEngine {
 
 	//---------------------------------------------------------------------
-    GLHardwareIndexBuffer::GLHardwareIndexBuffer(HardwareBufferManagerBase* mgr, IndexType idxType,
+    GLIndexBuffer::GLIndexBuffer(HardwareBufferManagerBase* mgr, IndexType idxType,
         UINT32 numIndexes, GpuBufferUsage usage)
-        : HardwareIndexBuffer(mgr, idxType, numIndexes, usage, false)
+        : IndexBuffer(mgr, idxType, numIndexes, usage, false)
     {
         glGenBuffersARB( 1, &mBufferId );
 
@@ -53,12 +53,12 @@ namespace CamelotEngine {
         //std::cerr << "creating index buffer " << mBufferId << std::endl;
     }
 	//---------------------------------------------------------------------
-    GLHardwareIndexBuffer::~GLHardwareIndexBuffer()
+    GLIndexBuffer::~GLIndexBuffer()
     {
         glDeleteBuffersARB(1, &mBufferId);
     }
 	//---------------------------------------------------------------------
-    void* GLHardwareIndexBuffer::lockImpl(UINT32 offset, 
+    void* GLIndexBuffer::lockImpl(UINT32 offset, 
         UINT32 length, GpuLockOptions options)
     {
         GLenum access = 0;
@@ -130,7 +130,7 @@ namespace CamelotEngine {
 		return retPtr;
     }
 	//---------------------------------------------------------------------
-	void GLHardwareIndexBuffer::unlockImpl(void)
+	void GLIndexBuffer::unlockImpl(void)
     {
 		if (mLockedToScratch)
 		{
@@ -162,14 +162,14 @@ namespace CamelotEngine {
         mIsLocked = false;
     }
 	//---------------------------------------------------------------------
-    void GLHardwareIndexBuffer::readData(UINT32 offset, UINT32 length, 
+    void GLIndexBuffer::readData(UINT32 offset, UINT32 length, 
         void* pDest)
     {
 		glBindBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB, mBufferId );
 		glGetBufferSubDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB, offset, length, pDest);
     }
 	//---------------------------------------------------------------------
-    void GLHardwareIndexBuffer::writeData(UINT32 offset, UINT32 length, 
+    void GLIndexBuffer::writeData(UINT32 offset, UINT32 length, 
             const void* pSource, bool discardWholeBuffer)
     {
         glBindBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB, mBufferId );

CamelotGLRenderer/Source/CmGLMultiRenderTexture.cpp

@@ -25,7 +25,7 @@ namespace CamelotEngine
 			surfaceDesc.zoffset = 0;
 
 			GLTexture* glTexture = static_cast<GLTexture*>(texture.get());
-			surfaceDesc.buffer = std::static_pointer_cast<GLHardwarePixelBuffer>(glTexture->getBuffer(face, mipLevel));
+			surfaceDesc.buffer = std::static_pointer_cast<GLPixelBuffer>(glTexture->getBuffer(face, mipLevel));
 
 			mFB->bindSurface(surfaceIdx, surfaceDesc);
 		}

CamelotGLRenderer/Source/CmGLHardwareOcclusionQuery.cpp → CamelotGLRenderer/Source/CmGLOcclusionQuery.cpp

@@ -26,7 +26,7 @@ THE SOFTWARE.
 -----------------------------------------------------------------------------
 */
 
-#include "CmGLHardwareOcclusionQuery.h"
+#include "CmGLOcclusionQuery.h"
 #include "CmException.h"
 
 namespace CamelotEngine {
@@ -46,7 +46,7 @@ namespace CamelotEngine {
   * Default object constructor
   * 
   */
-GLHardwareOcclusionQuery::GLHardwareOcclusionQuery() 
+GLOcclusionQuery::GLOcclusionQuery() 
 { 
 	// Check for hardware occlusion support
     if(GLEW_VERSION_1_5 || GLEW_ARB_occlusion_query)
@@ -68,7 +68,7 @@ GLHardwareOcclusionQuery::GLHardwareOcclusionQuery()
 /**
   * Object destructor
   */
-GLHardwareOcclusionQuery::~GLHardwareOcclusionQuery() 
+GLOcclusionQuery::~GLOcclusionQuery() 
 { 
     if(GLEW_VERSION_1_5 || GLEW_ARB_occlusion_query)
 	{
@@ -80,7 +80,7 @@ GLHardwareOcclusionQuery::~GLHardwareOcclusionQuery()
 	}
 }
 //------------------------------------------------------------------
-void GLHardwareOcclusionQuery::beginOcclusionQuery() 
+void GLOcclusionQuery::beginOcclusionQuery() 
 { 
     if(GLEW_VERSION_1_5 || GLEW_ARB_occlusion_query)
 	{
@@ -92,7 +92,7 @@ void GLHardwareOcclusionQuery::beginOcclusionQuery()
 	}
 }
 //------------------------------------------------------------------
-void GLHardwareOcclusionQuery::endOcclusionQuery() 
+void GLOcclusionQuery::endOcclusionQuery() 
 { 
     if(GLEW_VERSION_1_5 || GLEW_ARB_occlusion_query)
 	{
@@ -105,7 +105,7 @@ void GLHardwareOcclusionQuery::endOcclusionQuery()
 	
 }
 //------------------------------------------------------------------
-bool GLHardwareOcclusionQuery::pullOcclusionQuery( unsigned int* NumOfFragments ) 
+bool GLOcclusionQuery::pullOcclusionQuery( unsigned int* NumOfFragments ) 
 {
     if(GLEW_VERSION_1_5 || GLEW_ARB_occlusion_query)
 	{
@@ -123,7 +123,7 @@ bool GLHardwareOcclusionQuery::pullOcclusionQuery( unsigned int* NumOfFragments
 	return false;
 }
 //------------------------------------------------------------------
-bool GLHardwareOcclusionQuery::isStillOutstanding(void)
+bool GLOcclusionQuery::isStillOutstanding(void)
 {    
       GLuint available;
 

CamelotGLRenderer/Source/CmGLHardwarePixelBuffer.cpp → CamelotGLRenderer/Source/CmGLPixelBuffer.cpp

@@ -25,7 +25,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 -----------------------------------------------------------------------------
 */
-#include "CmGLHardwarePixelBuffer.h"
+#include "CmGLPixelBuffer.h"
 #include "CmGLTexture.h"
 #include "CmGLSupport.h"
 #include "CmGLPixelFormat.h"
@@ -36,10 +36,10 @@ THE SOFTWARE.
 namespace CamelotEngine 
 {
 	//----------------------------------------------------------------------------- 
-	GLHardwarePixelBuffer::GLHardwarePixelBuffer(UINT32 inWidth, UINT32 inHeight, UINT32 inDepth,
+	GLPixelBuffer::GLPixelBuffer(UINT32 inWidth, UINT32 inHeight, UINT32 inDepth,
 					PixelFormat inFormat,
 					GpuBufferUsage usage):
-		  HardwarePixelBuffer(inWidth, inHeight, inDepth, inFormat, usage, false),
+		  PixelBuffer(inWidth, inHeight, inDepth, inFormat, usage, false),
 		  mBuffer(inWidth, inHeight, inDepth, inFormat),
 		  mGLInternalFormat(GL_NONE)
 	{
@@ -47,13 +47,13 @@ namespace CamelotEngine
 	}
 
 	//-----------------------------------------------------------------------------  
-	GLHardwarePixelBuffer::~GLHardwarePixelBuffer()
+	GLPixelBuffer::~GLPixelBuffer()
 	{
 		// Force free buffer
 		delete [] (UINT8*)mBuffer.data;
 	}
 	//-----------------------------------------------------------------------------  
-	void GLHardwarePixelBuffer::allocateBuffer()
+	void GLPixelBuffer::allocateBuffer()
 	{
 		if(mBuffer.data)
 			// Already allocated
@@ -62,7 +62,7 @@ namespace CamelotEngine
 		// TODO: use PBO if we're HBU_DYNAMIC
 	}
 	//-----------------------------------------------------------------------------  
-	void GLHardwarePixelBuffer::freeBuffer()
+	void GLPixelBuffer::freeBuffer()
 	{
 		// Free buffer if we're STATIC to save memory
 		if(mUsage & GBU_STATIC)
@@ -72,7 +72,7 @@ namespace CamelotEngine
 		}
 	}
 	//-----------------------------------------------------------------------------  
-	PixelData GLHardwarePixelBuffer::lockImpl(const Box lockBox,  GpuLockOptions options)
+	PixelData GLPixelBuffer::lockImpl(const Box lockBox,  GpuLockOptions options)
 	{
 		allocateBuffer();
 		if(options != GBL_WRITE_ONLY_DISCARD) 
@@ -85,7 +85,7 @@ namespace CamelotEngine
 		return mBuffer.getSubVolume(lockBox);
 	}
 	//-----------------------------------------------------------------------------  
-	void GLHardwarePixelBuffer::unlockImpl(void)
+	void GLPixelBuffer::unlockImpl(void)
 	{
 		if (mCurrentLockOptions != GBL_READ_ONLY)
 		{
@@ -97,7 +97,7 @@ namespace CamelotEngine
 	}
 
 	//-----------------------------------------------------------------------------  
-	void GLHardwarePixelBuffer::blitFromMemory(const PixelData &src, const Box &dstBox)
+	void GLPixelBuffer::blitFromMemory(const PixelData &src, const Box &dstBox)
 	{
 		if(!mBuffer.contains(dstBox))
 			CM_EXCEPT(InvalidParametersException, "destination box out of range");
@@ -133,7 +133,7 @@ namespace CamelotEngine
 		freeBuffer();
 	}
 	//-----------------------------------------------------------------------------  
-	void GLHardwarePixelBuffer::blitToMemory(const Box &srcBox, const PixelData &dst)
+	void GLPixelBuffer::blitToMemory(const Box &srcBox, const PixelData &dst)
 	{
 		if(!mBuffer.contains(srcBox))
 			CM_EXCEPT(InvalidParametersException, "source box out of range");
@@ -171,18 +171,18 @@ namespace CamelotEngine
 		}
 	}
 	//-----------------------------------------------------------------------------
-	void GLHardwarePixelBuffer::upload(const PixelData &data, const Box &dest)
+	void GLPixelBuffer::upload(const PixelData &data, const Box &dest)
 	{
 		CM_EXCEPT(RenderingAPIException, 
 			"Upload not possible for this pixelbuffer type");
 	}
 	//-----------------------------------------------------------------------------  
-	void GLHardwarePixelBuffer::download(const PixelData &data)
+	void GLPixelBuffer::download(const PixelData &data)
 	{
 		CM_EXCEPT(RenderingAPIException, "Download not possible for this pixelbuffer type");
 	}
 	//-----------------------------------------------------------------------------  
-	void GLHardwarePixelBuffer::bindToFramebuffer(GLenum attachment, UINT32 zoffset)
+	void GLPixelBuffer::bindToFramebuffer(GLenum attachment, UINT32 zoffset)
 	{
 		CM_EXCEPT(RenderingAPIException, "Framebuffer bind not possible for this pixelbuffer type");
 	}
@@ -190,7 +190,7 @@ namespace CamelotEngine
 	GLTextureBuffer::GLTextureBuffer(const String &baseName, GLenum target, GLuint id, 
 									 GLint face, GLint level, GpuBufferUsage usage, bool crappyCard, 
 									 bool writeGamma, UINT32 fsaa):
-		GLHardwarePixelBuffer(0, 0, 0, PF_UNKNOWN, usage),
+		GLPixelBuffer(0, 0, 0, PF_UNKNOWN, usage),
 		mTarget(target), mFaceTarget(0), mTextureID(id), mFace(face), mLevel(level),
 		mSoftwareMipmap(crappyCard)
 	{
@@ -460,7 +460,7 @@ namespace CamelotEngine
 		}
 	}
 	//-----------------------------------------------------------------------------  
-	void GLTextureBuffer::blit(const HardwarePixelBufferPtr &src, const Box &srcBox, const Box &dstBox)
+	void GLTextureBuffer::blit(const PixelBufferPtr &src, const Box &srcBox, const Box &dstBox)
 	{
 		GLTextureBuffer *srct = static_cast<GLTextureBuffer *>(src.get());
 		/// Check for FBO support first
@@ -476,7 +476,7 @@ namespace CamelotEngine
 		}
 		else
 		{
-			GLHardwarePixelBuffer::blit(src, srcBox, dstBox);
+			GLPixelBuffer::blit(src, srcBox, dstBox);
 		}
 	}
 
@@ -683,7 +683,7 @@ namespace CamelotEngine
 			src_orig.getHeight() == dstBox.getHeight() &&
 			src_orig.getDepth() == dstBox.getDepth()))
 		{
-			GLHardwarePixelBuffer::blitFromMemory(src_orig, dstBox);
+			GLPixelBuffer::blitFromMemory(src_orig, dstBox);
 			return;
 		}
 		if(!mBuffer.contains(dstBox))
@@ -749,7 +749,7 @@ namespace CamelotEngine
 	//********* GLRenderBuffer
 	//----------------------------------------------------------------------------- 
 	GLRenderBuffer::GLRenderBuffer(GLenum format, UINT32 width, UINT32 height, GLsizei numSamples):
-		GLHardwarePixelBuffer(width, height, 1, GLPixelUtil::getClosestEngineFormat(format), GBU_DYNAMIC),
+		GLPixelBuffer(width, height, 1, GLPixelUtil::getClosestEngineFormat(format), GBU_DYNAMIC),
 		mRenderbufferID(0)
 	{
 		mGLInternalFormat = format;

CamelotGLRenderer/Source/CmGLRenderSystem.cpp

@@ -31,15 +31,15 @@ THE SOFTWARE.s
 #include "CmRenderSystem.h"
 #include "CmCamera.h"
 #include "CmGLTextureManager.h"
-#include "CmGLHardwareVertexBuffer.h"
-#include "CmGLHardwareIndexBuffer.h"
+#include "CmGLVertexBuffer.h"
+#include "CmGLIndexBuffer.h"
 #include "CmGLUtil.h"
 #include "CmGLSLGpuProgram.h"
 #include "CmGLSLProgram.h"
 #include "CmGLGpuProgramManager.h"
 #include "CmException.h"
 #include "CmGLSLExtSupport.h"
-#include "CmGLHardwareOcclusionQuery.h"
+#include "CmGLOcclusionQuery.h"
 #include "CmGLContext.h"
 #include "CmAsyncOp.h"
 #include "CmBlendState.h"
@@ -696,7 +696,7 @@ namespace CamelotEngine
 
 			HardwareVertexBufferPtr vertexBuffer = op.vertexData->vertexBufferBinding->getBuffer(elem->getSource());
 
-			glBindBuffer(GL_ARRAY_BUFFER, static_cast<const GLHardwareVertexBuffer*>(vertexBuffer.get())->getGLBufferId());
+			glBindBuffer(GL_ARRAY_BUFFER, static_cast<const GLVertexBuffer*>(vertexBuffer.get())->getGLBufferId());
 			pBufferData = VBO_BUFFER_OFFSET(elem->getOffset());
 
 			if (op.vertexData->vertexStart)
@@ -763,12 +763,12 @@ namespace CamelotEngine
 		if (op.useIndexes)
 		{
 			glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 
-				static_cast<GLHardwareIndexBuffer*>(
+				static_cast<GLIndexBuffer*>(
 				op.indexData->indexBuffer.get())->getGLBufferId());
 
 			pBufferData = VBO_BUFFER_OFFSET(op.indexData->indexStart * op.indexData->indexBuffer->getIndexSize());
 
-			GLenum indexType = (op.indexData->indexBuffer->getType() == HardwareIndexBuffer::IT_16BIT) ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT;
+			GLenum indexType = (op.indexData->indexBuffer->getType() == IndexBuffer::IT_16BIT) ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT;
 
 			glDrawElements(primType, op.indexData->indexCount, indexType, pBufferData);
 		}

CamelotGLRenderer/Source/CmGLRenderTexture.cpp

@@ -28,7 +28,7 @@ THE SOFTWARE.
 #include "CmGLRenderTexture.h"
 #include "CmGLPixelFormat.h"
 #include "CmGLDepthStencilBuffer.h"
-#include "CmGLHardwarePixelBuffer.h"
+#include "CmGLPixelBuffer.h"
 
 namespace CamelotEngine 
 {
@@ -55,7 +55,7 @@ namespace CamelotEngine
 		surfaceDesc.zoffset = 0;
 
 		GLTexture* glTexture = static_cast<GLTexture*>(mSurface.texture.get());
-		surfaceDesc.buffer = std::static_pointer_cast<GLHardwarePixelBuffer>(glTexture->getBuffer(mSurface.face, mSurface.mipLevel));
+		surfaceDesc.buffer = std::static_pointer_cast<GLPixelBuffer>(glTexture->getBuffer(mSurface.face, mSurface.mipLevel));
 
 		mFB->bindSurface(0, surfaceDesc);
 

CamelotGLRenderer/Source/CmGLTexture.cpp

@@ -29,7 +29,7 @@ THE SOFTWARE.
 #include "CmGLTexture.h"
 #include "CmGLSupport.h"
 #include "CmGLPixelFormat.h"
-#include "CmGLHardwarePixelBuffer.h"
+#include "CmGLPixelBuffer.h"
 
 //#include "CmTextureManager.h"
 #include "CmCamera.h"
@@ -268,9 +268,9 @@ namespace CamelotEngine {
 		{
 			for(UINT32 mip=0; mip<=getNumMipmaps(); mip++)
 			{
-                GLHardwarePixelBuffer *buf = new GLTextureBuffer("", getGLTextureTarget(), mTextureID, face, mip,
+                GLPixelBuffer *buf = new GLTextureBuffer("", getGLTextureTarget(), mTextureID, face, mip,
 						static_cast<GpuBufferUsage>(mUsage), false, mHwGamma, mFSAA);
-				mSurfaceList.push_back(HardwarePixelBufferPtr(buf));
+				mSurfaceList.push_back(PixelBufferPtr(buf));
                 
                 /// Check for error
                 if(buf->getWidth()==0 || buf->getHeight()==0 || buf->getDepth()==0)
@@ -286,7 +286,7 @@ namespace CamelotEngine {
 	}
 	
 	//---------------------------------------------------------------------------------------------
-	HardwarePixelBufferPtr GLTexture::getBuffer(UINT32 face, UINT32 mipmap)
+	PixelBufferPtr GLTexture::getBuffer(UINT32 face, UINT32 mipmap)
 	{
 		THROW_IF_NOT_RENDER_THREAD;
 

CamelotGLRenderer/Source/CmGLHardwareVertexBuffer.cpp → CamelotGLRenderer/Source/CmGLVertexBuffer.cpp

@@ -26,15 +26,15 @@ THE SOFTWARE.
 -----------------------------------------------------------------------------
 */
 #include "CmGLHardwareBufferManager.h"
-#include "CmGLHardwareVertexBuffer.h"
+#include "CmGLVertexBuffer.h"
 #include "CmException.h"
 
 namespace CamelotEngine {
 
 	//---------------------------------------------------------------------
-    GLHardwareVertexBuffer::GLHardwareVertexBuffer(HardwareBufferManagerBase* mgr, UINT32 vertexSize, 
+    GLVertexBuffer::GLVertexBuffer(HardwareBufferManagerBase* mgr, UINT32 vertexSize, 
         UINT32 numVertices, GpuBufferUsage usage)
-        : HardwareVertexBuffer(mgr, vertexSize, numVertices, usage, false)
+        : VertexBuffer(mgr, vertexSize, numVertices, usage, false)
     {
         glGenBuffersARB( 1, &mBufferId );
 
@@ -53,12 +53,12 @@ namespace CamelotEngine {
         //std::cerr << "creating vertex buffer = " << mBufferId << std::endl;
     }
 	//---------------------------------------------------------------------
-    GLHardwareVertexBuffer::~GLHardwareVertexBuffer()
+    GLVertexBuffer::~GLVertexBuffer()
     {
         glDeleteBuffersARB(1, &mBufferId);
     }
 	//---------------------------------------------------------------------
-    void* GLHardwareVertexBuffer::lockImpl(UINT32 offset, 
+    void* GLVertexBuffer::lockImpl(UINT32 offset, 
         UINT32 length, GpuLockOptions options)
     {
         GLenum access = 0;
@@ -132,7 +132,7 @@ namespace CamelotEngine {
 		return retPtr;
     }
 	//---------------------------------------------------------------------
-	void GLHardwareVertexBuffer::unlockImpl(void)
+	void GLVertexBuffer::unlockImpl(void)
     {
 		if (mLockedToScratch)
 		{
@@ -163,7 +163,7 @@ namespace CamelotEngine {
         mIsLocked = false;
     }
 	//---------------------------------------------------------------------
-    void GLHardwareVertexBuffer::readData(UINT32 offset, UINT32 length, 
+    void GLVertexBuffer::readData(UINT32 offset, UINT32 length, 
         void* pDest)
     {
         // get data from the real buffer
@@ -172,7 +172,7 @@ namespace CamelotEngine {
         glGetBufferSubDataARB(GL_ARRAY_BUFFER_ARB, offset, length, pDest);
     }
 	//---------------------------------------------------------------------
-    void GLHardwareVertexBuffer::writeData(UINT32 offset, UINT32 length, 
+    void GLVertexBuffer::writeData(UINT32 offset, UINT32 length, 
             const void* pSource, bool discardWholeBuffer)
     {
         glBindBufferARB(GL_ARRAY_BUFFER_ARB, mBufferId);

CamelotRenderer/CamelotRenderer.vcxproj

@@ -202,10 +202,10 @@
     <ClInclude Include="Include\CmGpuProgramRTTI.h" />
     <ClInclude Include="Include\CmHardwareBuffer.h" />
     <ClInclude Include="Include\CmHardwareBufferManager.h" />
-    <ClInclude Include="Include\CmHardwareIndexBuffer.h" />
-    <ClInclude Include="Include\CmHardwareOcclusionQuery.h" />
-    <ClInclude Include="Include\CmHardwarePixelBuffer.h" />
-    <ClInclude Include="Include\CmHardwareVertexBuffer.h" />
+    <ClInclude Include="Include\CmIndexBuffer.h" />
+    <ClInclude Include="Include\CmOcclusionQuery.h" />
+    <ClInclude Include="Include\CmPixelBuffer.h" />
+    <ClInclude Include="Include\CmVertexBuffer.h" />
     <ClInclude Include="Include\CmHighLevelGpuProgram.h" />
     <ClInclude Include="Include\CmHighLevelGpuProgramManager.h" />
     <ClInclude Include="Include\CmImporter.h" />
@@ -287,10 +287,10 @@
     <ClCompile Include="Source\CmGpuProgramManager.cpp" />
     <ClCompile Include="Source\CmGpuProgramParams.cpp" />
     <ClCompile Include="Source\CmHardwareBufferManager.cpp" />
-    <ClCompile Include="Source\CmHardwareIndexBuffer.cpp" />
-    <ClCompile Include="Source\CmHardwareOcclusionQuery.cpp" />
-    <ClCompile Include="Source\CmHardwarePixelBuffer.cpp" />
-    <ClCompile Include="Source\CmHardwareVertexBuffer.cpp" />
+    <ClCompile Include="Source\CmIndexBuffer.cpp" />
+    <ClCompile Include="Source\CmOcclusionQuery.cpp" />
+    <ClCompile Include="Source\CmPixelBuffer.cpp" />
+    <ClCompile Include="Source\CmVertexBuffer.cpp" />
     <ClCompile Include="Source\CmHighLevelGpuProgram.cpp" />
     <ClCompile Include="Source\CmHighLevelGpuProgramManager.cpp" />
     <ClCompile Include="Source\CmImporter.cpp" />

CamelotRenderer/CamelotRenderer.vcxproj.filters

@@ -143,18 +143,6 @@
     <ClInclude Include="Include\CmHighLevelGpuProgram.h">
       <Filter>Header Files\RenderSystem</Filter>
     </ClInclude>
-    <ClInclude Include="Include\CmHardwareVertexBuffer.h">
-      <Filter>Header Files\RenderSystem</Filter>
-    </ClInclude>
-    <ClInclude Include="Include\CmHardwarePixelBuffer.h">
-      <Filter>Header Files\RenderSystem</Filter>
-    </ClInclude>
-    <ClInclude Include="Include\CmHardwareOcclusionQuery.h">
-      <Filter>Header Files\RenderSystem</Filter>
-    </ClInclude>
-    <ClInclude Include="Include\CmHardwareIndexBuffer.h">
-      <Filter>Header Files\RenderSystem</Filter>
-    </ClInclude>
     <ClInclude Include="Include\CmHardwareBuffer.h">
       <Filter>Header Files\RenderSystem</Filter>
     </ClInclude>
@@ -362,6 +350,18 @@
     <ClInclude Include="Include\CmGenericBufferView.h">
       <Filter>Header Files\RenderSystem</Filter>
     </ClInclude>
+    <ClInclude Include="Include\CmIndexBuffer.h">
+      <Filter>Header Files\RenderSystem</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\CmOcclusionQuery.h">
+      <Filter>Header Files\RenderSystem</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\CmPixelBuffer.h">
+      <Filter>Header Files\RenderSystem</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\CmVertexBuffer.h">
+      <Filter>Header Files\RenderSystem</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Source\CamelotRenderer.cpp">
@@ -394,18 +394,6 @@
     <ClCompile Include="Source\CmHardwareBufferManager.cpp">
       <Filter>Source Files\RenderSystem</Filter>
     </ClCompile>
-    <ClCompile Include="Source\CmHardwareIndexBuffer.cpp">
-      <Filter>Source Files\RenderSystem</Filter>
-    </ClCompile>
-    <ClCompile Include="Source\CmHardwareOcclusionQuery.cpp">
-      <Filter>Source Files\RenderSystem</Filter>
-    </ClCompile>
-    <ClCompile Include="Source\CmHardwarePixelBuffer.cpp">
-      <Filter>Source Files\RenderSystem</Filter>
-    </ClCompile>
-    <ClCompile Include="Source\CmHardwareVertexBuffer.cpp">
-      <Filter>Source Files\RenderSystem</Filter>
-    </ClCompile>
     <ClCompile Include="Source\CmHighLevelGpuProgram.cpp">
       <Filter>Source Files\RenderSystem</Filter>
     </ClCompile>
@@ -547,5 +535,17 @@
     <ClCompile Include="Source\CmGenericBufferView.cpp">
       <Filter>Source Files\RenderSystem</Filter>
     </ClCompile>
+    <ClCompile Include="Source\CmIndexBuffer.cpp">
+      <Filter>Source Files\RenderSystem</Filter>
+    </ClCompile>
+    <ClCompile Include="Source\CmOcclusionQuery.cpp">
+      <Filter>Source Files\RenderSystem</Filter>
+    </ClCompile>
+    <ClCompile Include="Source\CmPixelBuffer.cpp">
+      <Filter>Source Files\RenderSystem</Filter>
+    </ClCompile>
+    <ClCompile Include="Source\CmVertexBuffer.cpp">
+      <Filter>Source Files\RenderSystem</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

CamelotRenderer/Include/CmHardwareBufferManager.h

@@ -32,8 +32,8 @@ THE SOFTWARE.
 #include "CmPrerequisites.h"
 
 #include "CmModule.h"
-#include "CmHardwareVertexBuffer.h"
-#include "CmHardwareIndexBuffer.h"
+#include "CmVertexBuffer.h"
+#include "CmIndexBuffer.h"
 #include "CmGpuParamBlock.h"
 
 namespace CamelotEngine {
@@ -63,8 +63,8 @@ namespace CamelotEngine {
             members will cause notify back to this class, and then will access to this
             two members.
         */
-        typedef set<HardwareVertexBuffer*>::type VertexBufferList;
-        typedef set<HardwareIndexBuffer*>::type IndexBufferList;
+        typedef set<VertexBuffer*>::type VertexBufferList;
+        typedef set<IndexBuffer*>::type IndexBufferList;
 		typedef set<HardwareConstantBuffer*>::type ConstantBufferList;
         VertexBufferList mVertexBuffers;
         IndexBufferList mIndexBuffers;
@@ -121,7 +121,7 @@ namespace CamelotEngine {
         @param usage One or more members of the HardwareBuffer::Usage enumeration.
         */
 		virtual HardwareIndexBufferPtr 
-            createIndexBuffer(HardwareIndexBuffer::IndexType itype, UINT32 numIndexes, 
+            createIndexBuffer(IndexBuffer::IndexType itype, UINT32 numIndexes, 
 			GpuBufferUsage usage) = 0;
 
 		/**
@@ -156,9 +156,9 @@ namespace CamelotEngine {
 		virtual void destroyVertexBufferBinding(VertexBufferBinding* binding);
 
 		/// Notification that a hardware vertex buffer has been destroyed
-		void _notifyVertexBufferDestroyed(HardwareVertexBuffer* buf);
+		void _notifyVertexBufferDestroyed(VertexBuffer* buf);
 		/// Notification that a hardware index buffer has been destroyed
-		void _notifyIndexBufferDestroyed(HardwareIndexBuffer* buf);
+		void _notifyIndexBufferDestroyed(IndexBuffer* buf);
 	};
 
     /** Singleton wrapper for hardware buffer manager. */
@@ -176,7 +176,7 @@ namespace CamelotEngine {
 			return mImpl->createVertexBuffer(vertexSize, numVerts, usage, streamOut);
 		}
 		/** @copydoc HardwareBufferManagerInterface::createIndexBuffer */
-		HardwareIndexBufferPtr createIndexBuffer(HardwareIndexBuffer::IndexType itype, UINT32 numIndexes, GpuBufferUsage usage)
+		HardwareIndexBufferPtr createIndexBuffer(IndexBuffer::IndexType itype, UINT32 numIndexes, GpuBufferUsage usage)
 		{
 			return mImpl->createIndexBuffer(itype, numIndexes, usage);
 		}
@@ -211,12 +211,12 @@ namespace CamelotEngine {
 			mImpl->destroyVertexBufferBinding(binding);
 		}
 		/** @copydoc HardwareBufferManagerInterface::_notifyVertexBufferDestroyed */
-		void _notifyVertexBufferDestroyed(HardwareVertexBuffer* buf)
+		void _notifyVertexBufferDestroyed(VertexBuffer* buf)
 		{
 			mImpl->_notifyVertexBufferDestroyed(buf);
 		}
 		/** @copydoc HardwareBufferManagerInterface::_notifyIndexBufferDestroyed */
-		void _notifyIndexBufferDestroyed(HardwareIndexBuffer* buf)
+		void _notifyIndexBufferDestroyed(IndexBuffer* buf)
 		{
 			mImpl->_notifyIndexBufferDestroyed(buf);
 		}            

CamelotRenderer/Include/CmHardwareIndexBuffer.h → CamelotRenderer/Include/CmIndexBuffer.h

@@ -42,7 +42,7 @@ namespace CamelotEngine {
 	*  @{
 	*/
 	/** Specialisation of HardwareBuffer for vertex index buffers, still abstract. */
-    class CM_EXPORT HardwareIndexBuffer : public HardwareBuffer
+    class CM_EXPORT IndexBuffer : public HardwareBuffer
     {
 	    public:
 		    enum IndexType {
@@ -58,9 +58,9 @@ namespace CamelotEngine {
 
 	    public:
 		    /// Should be called by HardwareBufferManager
-		    HardwareIndexBuffer(HardwareBufferManagerBase* mgr, IndexType idxType, UINT32 numIndexes, GpuBufferUsage usage,
+		    IndexBuffer(HardwareBufferManagerBase* mgr, IndexType idxType, UINT32 numIndexes, GpuBufferUsage usage,
                 bool useSystemMemory);
-            ~HardwareIndexBuffer();
+            ~IndexBuffer();
 			/// Return the manager of this buffer, if any
 			HardwareBufferManagerBase* getManager() const { return mMgr; }
     		/// Get the type of indexes used in this buffer
@@ -73,7 +73,7 @@ namespace CamelotEngine {
 		    // NB subclasses should override lock, unlock, readData, writeData
     };
 
-	typedef std::shared_ptr<HardwareIndexBuffer> HardwareIndexBufferPtr;
+	typedef std::shared_ptr<IndexBuffer> HardwareIndexBufferPtr;
 	/** @} */
 }
 #endif

CamelotRenderer/Include/CmMeshData.h

@@ -2,7 +2,7 @@
 
 #include "CmPrerequisites.h"
 #include "CmIReflectable.h"
-#include "CmHardwareVertexBuffer.h"
+#include "CmVertexBuffer.h"
 
 namespace CamelotEngine
 {

CamelotRenderer/Include/CmHardwareOcclusionQuery.h → CamelotRenderer/Include/CmOcclusionQuery.h

@@ -48,7 +48,7 @@ namespace CamelotEngine {
   * @author Lee Sandberg
   * Updated on 13/8/2005 by Tuan Kuranes email: [email protected]
   */
-	class CM_EXPORT HardwareOcclusionQuery
+	class CM_EXPORT OcclusionQuery
 {
 //----------------------------------------------------------------------
 // Public methods
@@ -62,12 +62,12 @@ public:
 	  * Default object constructor
 	  * 
 	  */
-	HardwareOcclusionQuery();
+	OcclusionQuery();
 
 	/**
 	  * Object destructor
 	  */
-	virtual ~HardwareOcclusionQuery();
+	virtual ~OcclusionQuery();
 
 	/**
 	  * Starts the hardware occlusion query

CamelotRenderer/Include/CmHardwarePixelBuffer.h → CamelotRenderer/Include/CmPixelBuffer.h

@@ -47,7 +47,7 @@ namespace CamelotEngine {
     	or in main memory depending on its usage. One mipmap level of a
     	texture is an example of a HardwarePixelBuffer.
     */
-    class CM_EXPORT HardwarePixelBuffer : public HardwareBuffer
+    class CM_EXPORT PixelBuffer : public HardwareBuffer
     {
     protected: 
         // Extents
@@ -71,9 +71,9 @@ namespace CamelotEngine {
 		friend class RenderTexture;
     public:
         /// Should be called by HardwareBufferManager
-        HardwarePixelBuffer(UINT32 mWidth, UINT32 mHeight, UINT32 mDepth,
+        PixelBuffer(UINT32 mWidth, UINT32 mHeight, UINT32 mDepth,
                 PixelFormat mFormat, GpuBufferUsage usage, bool useSystemMemory);
-        ~HardwarePixelBuffer();
+        ~PixelBuffer();
 
         /** make every lock method from HardwareBuffer available.
         See http://www.research.att.com/~bs/bs_faq2.html#overloadderived
@@ -112,14 +112,14 @@ namespace CamelotEngine {
             but it is faster to pass the source image in the right dimensions.
 			@note Only call this function when both  buffers are unlocked. 
          */        
-        virtual void blit(const HardwarePixelBufferPtr &src, const Box &srcBox, const Box &dstBox);
+        virtual void blit(const PixelBufferPtr &src, const Box &srcBox, const Box &dstBox);
 
 		/** Convenience function that blits the entire source pixel buffer to this buffer. 
 			If source and destination dimensions don't match, scaling is done.
 			@param src		PixelBox containing the source pixels and format in memory
 			@note Only call this function when the buffer is unlocked. 
 		*/
-		void blit(const HardwarePixelBufferPtr &src); 
+		void blit(const PixelBufferPtr &src); 
 		
 		/** Copies a region from normal memory to a region of this pixelbuffer. The source
 			image can be in any pixel format supported by OGRE, and in any size. 

CamelotRenderer/Include/CmPrerequisites.h

@@ -69,10 +69,10 @@ namespace CamelotEngine {
     class Color;
     class GpuProgram;
     class GpuProgramManager;
-    class HardwareIndexBuffer;
-    class HardwareOcclusionQuery;
-    class HardwareVertexBuffer;
-	class HardwarePixelBuffer;
+    class IndexBuffer;
+    class OcclusionQuery;
+    class VertexBuffer;
+	class PixelBuffer;
 	class GenericBuffer;
 	class HighLevelGpuProgram;
 	class HighLevelGpuProgramManager;
@@ -146,7 +146,7 @@ namespace CamelotEngine
 {
 	typedef std::shared_ptr<GpuProgram> GpuProgramPtr;
 	typedef std::shared_ptr<HighLevelGpuProgram> HighLevelGpuProgramPtr;
-	typedef std::shared_ptr<HardwarePixelBuffer> HardwarePixelBufferPtr;
+	typedef std::shared_ptr<PixelBuffer> PixelBufferPtr;
 	typedef std::shared_ptr<GenericBuffer> GenericBufferPtr;
 	typedef std::shared_ptr<VertexDeclaration> VertexDeclarationPtr;
 	typedef std::shared_ptr<Mesh> MeshPtr;

CamelotRenderer/Include/CmHardwareVertexBuffer.h → CamelotRenderer/Include/CmVertexBuffer.h

@@ -44,7 +44,7 @@ namespace CamelotEngine {
 	*  @{
 	*/
 	/** Specialisation of HardwareBuffer for a vertex buffer. */
-    class CM_EXPORT HardwareVertexBuffer : public HardwareBuffer
+    class CM_EXPORT VertexBuffer : public HardwareBuffer
     {
 	    protected:
 			HardwareBufferManagerBase* mMgr;
@@ -53,9 +53,9 @@ namespace CamelotEngine {
 
 	    public:
 		    /// Should be called by HardwareBufferManager
-		    HardwareVertexBuffer(HardwareBufferManagerBase* mgr, UINT32 vertexSize, UINT32 numVertices,
+		    VertexBuffer(HardwareBufferManagerBase* mgr, UINT32 vertexSize, UINT32 numVertices,
                 GpuBufferUsage usage, bool useSystemMemory);
-            ~HardwareVertexBuffer();
+            ~VertexBuffer();
 			/// Return the manager of this buffer, if any
 			HardwareBufferManagerBase* getManager() const { return mMgr; }
             /// Gets the size in bytes of a single vertex in this buffer
@@ -64,7 +64,7 @@ namespace CamelotEngine {
             UINT32 getNumVertices(void) const { return mNumVertices; }
     };
 
-	typedef std::shared_ptr<HardwareVertexBuffer> HardwareVertexBufferPtr;
+	typedef std::shared_ptr<VertexBuffer> HardwareVertexBufferPtr;
 
 	/** Records the state of all the vertex buffer bindings required to provide a vertex declaration
 		with the input data it needs for the vertex elements.

CamelotRenderer/Include/CmVertexDeclarationRTTI.h

@@ -2,7 +2,7 @@
 
 #include "CmPrerequisites.h"
 #include "CmRTTIType.h"
-#include "CmHardwareVertexBuffer.h"
+#include "CmVertexBuffer.h"
 
 namespace CamelotEngine
 {

CamelotRenderer/Include/CmVertexIndexData.h

@@ -30,8 +30,8 @@ THE SOFTWARE.
 
 #include "CmPrerequisites.h"
 #include "CmVertexDeclaration.h"
-#include "CmHardwareVertexBuffer.h"
-#include "CmHardwareIndexBuffer.h"
+#include "CmVertexBuffer.h"
+#include "CmIndexBuffer.h"
 
 namespace CamelotEngine {
 	/** \addtogroup Core

CamelotRenderer/Source/CmCamera.cpp

@@ -34,8 +34,8 @@ THE SOFTWARE.
 #include "CmAxisAlignedBox.h"
 #include "CmSphere.h"
 #include "CmHardwareBufferManager.h"
-#include "CmHardwareVertexBuffer.h"
-#include "CmHardwareIndexBuffer.h"
+#include "CmVertexBuffer.h"
+#include "CmIndexBuffer.h"
 #include "CmException.h"
 #include "CmRenderSystem.h"
 #include "CmGameObject.h"

CamelotRenderer/Source/CmHardwareBufferManager.cpp

@@ -105,7 +105,7 @@ namespace CamelotEngine {
         mVertexBufferBindings.clear();
     }
 	//-----------------------------------------------------------------------
-	void HardwareBufferManagerBase::_notifyVertexBufferDestroyed(HardwareVertexBuffer* buf)
+	void HardwareBufferManagerBase::_notifyVertexBufferDestroyed(VertexBuffer* buf)
 	{
 		VertexBufferList::iterator i = mVertexBuffers.find(buf);
 		if (i != mVertexBuffers.end())
@@ -115,7 +115,7 @@ namespace CamelotEngine {
 		}
 	}
 	//-----------------------------------------------------------------------
-	void HardwareBufferManagerBase::_notifyIndexBufferDestroyed(HardwareIndexBuffer* buf)
+	void HardwareBufferManagerBase::_notifyIndexBufferDestroyed(IndexBuffer* buf)
 	{
 		IndexBufferList::iterator i = mIndexBuffers.find(buf);
 		if (i != mIndexBuffers.end())

CamelotRenderer/Source/CmHardwareIndexBuffer.cpp → CamelotRenderer/Source/CmIndexBuffer.cpp

@@ -26,13 +26,13 @@ THE SOFTWARE.
 -----------------------------------------------------------------------------
 */
 
-#include "CmHardwareIndexBuffer.h"
+#include "CmIndexBuffer.h"
 #include "CmHardwareBufferManager.h"
 
 namespace CamelotEngine {
 
     //-----------------------------------------------------------------------------
-    HardwareIndexBuffer::HardwareIndexBuffer(HardwareBufferManagerBase* mgr, IndexType idxType, 
+    IndexBuffer::IndexBuffer(HardwareBufferManagerBase* mgr, IndexType idxType, 
         UINT32 numIndexes, GpuBufferUsage usage, 
         bool useSystemMemory) 
         : HardwareBuffer(usage, useSystemMemory)
@@ -53,7 +53,7 @@ namespace CamelotEngine {
         mSizeInBytes = mIndexSize * mNumIndexes;
     }
     //-----------------------------------------------------------------------------
-    HardwareIndexBuffer::~HardwareIndexBuffer()
+    IndexBuffer::~IndexBuffer()
     {
 		if (mMgr)
 		{

CamelotRenderer/Source/CmMesh.cpp

@@ -56,7 +56,7 @@ namespace CamelotEngine
 
 		mIndexData->indexCount = meshData->indexCount;
 		mIndexData->indexBuffer = HardwareBufferManager::instance().createIndexBuffer(
-			HardwareIndexBuffer::IT_32BIT,
+			IndexBuffer::IT_32BIT,
 			mIndexData->indexCount, 
 			GBU_STATIC);
 

CamelotRenderer/Source/CmHardwareOcclusionQuery.cpp → CamelotRenderer/Source/CmOcclusionQuery.cpp

@@ -26,17 +26,17 @@ THE SOFTWARE.
 -----------------------------------------------------------------------------
 */
 
-#include "CmHardwareOcclusionQuery.h"
+#include "CmOcclusionQuery.h"
 
 namespace CamelotEngine {
 
 
-    HardwareOcclusionQuery::HardwareOcclusionQuery() : 
+    OcclusionQuery::OcclusionQuery() : 
         mPixelCount(0),
         mIsQueryResultStillOutstanding(false)
     {
     }
-    HardwareOcclusionQuery::~HardwareOcclusionQuery()
+    OcclusionQuery::~OcclusionQuery()
     {
     }
 

CamelotRenderer/Source/CmHardwarePixelBuffer.cpp → CamelotRenderer/Source/CmPixelBuffer.cpp

@@ -25,14 +25,14 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 -----------------------------------------------------------------------------
 */
-#include "CmHardwarePixelBuffer.h"
+#include "CmPixelBuffer.h"
 #include "CmException.h"
 
 namespace CamelotEngine 
 {
   
     //-----------------------------------------------------------------------------    
-    HardwarePixelBuffer::HardwarePixelBuffer(UINT32 width, UINT32 height, UINT32 depth,
+    PixelBuffer::PixelBuffer(UINT32 width, UINT32 height, UINT32 depth,
             PixelFormat format,
             GpuBufferUsage usage, bool useSystemMemory):
         HardwareBuffer(usage, useSystemMemory),
@@ -46,12 +46,12 @@ namespace CamelotEngine
     }
     
     //-----------------------------------------------------------------------------    
-    HardwarePixelBuffer::~HardwarePixelBuffer()
+    PixelBuffer::~PixelBuffer()
     {
     }
     
     //-----------------------------------------------------------------------------    
-    void* HardwarePixelBuffer::lock(UINT32 offset, UINT32 length, GpuLockOptions options)
+    void* PixelBuffer::lock(UINT32 offset, UINT32 length, GpuLockOptions options)
     {
         assert(!isLocked() && "Cannot lock this buffer, it is already locked!");
         assert(offset == 0 && length == mSizeInBytes && "Cannot lock memory region, most lock box or entire buffer");
@@ -62,7 +62,7 @@ namespace CamelotEngine
     }
     
     //-----------------------------------------------------------------------------    
-    const PixelData& HardwarePixelBuffer::lock(const Box& lockBox, GpuLockOptions options)
+    const PixelData& PixelBuffer::lock(const Box& lockBox, GpuLockOptions options)
     {
         // Lock the real buffer if there is no shadow buffer 
         mCurrentLock = lockImpl(lockBox, options);
@@ -72,7 +72,7 @@ namespace CamelotEngine
     }
     
     //-----------------------------------------------------------------------------    
-    const PixelData& HardwarePixelBuffer::getCurrentLock() 
+    const PixelData& PixelBuffer::getCurrentLock() 
 	{ 
         assert(isLocked() && "Cannot get current lock: buffer not locked");
         
@@ -81,14 +81,14 @@ namespace CamelotEngine
     
     //-----------------------------------------------------------------------------    
     /// Internal implementation of lock()
-    void* HardwarePixelBuffer::lockImpl(UINT32 offset, UINT32 length, GpuLockOptions options)
+    void* PixelBuffer::lockImpl(UINT32 offset, UINT32 length, GpuLockOptions options)
     {
 		CM_EXCEPT(InternalErrorException, "lockImpl(offset,length) is not valid for PixelBuffers and should never be called");
     }
 
     //-----------------------------------------------------------------------------    
 
-    void HardwarePixelBuffer::blit(const HardwarePixelBufferPtr &src, const Box &srcBox, const Box &dstBox)
+    void PixelBuffer::blit(const PixelBufferPtr &src, const Box &srcBox, const Box &dstBox)
 	{
 		if(isLocked() || src->isLocked())
 		{
@@ -127,7 +127,7 @@ namespace CamelotEngine
 		src->unlock();
 	}
     //-----------------------------------------------------------------------------       
-    void HardwarePixelBuffer::blit(const HardwarePixelBufferPtr &src)
+    void PixelBuffer::blit(const PixelBufferPtr &src)
     {
         blit(src, 
             Box(0,0,0,src->getWidth(),src->getHeight(),src->getDepth()), 
@@ -135,7 +135,7 @@ namespace CamelotEngine
         );
     }
     //-----------------------------------------------------------------------------    
-	void HardwarePixelBuffer::readData(UINT32 offset, UINT32 length, void* pDest)
+	void PixelBuffer::readData(UINT32 offset, UINT32 length, void* pDest)
 	{
 		// TODO
 		CM_EXCEPT(NotImplementedException,
@@ -143,7 +143,7 @@ namespace CamelotEngine
 	}
 	//-----------------------------------------------------------------------------    
 
-	void HardwarePixelBuffer::writeData(UINT32 offset, UINT32 length, const void* pSource,
+	void PixelBuffer::writeData(UINT32 offset, UINT32 length, const void* pSource,
 			bool discardWholeBuffer)
 	{
 		// TODO

CamelotRenderer/Source/CmRenderSystem.cpp

@@ -37,8 +37,8 @@ THE SOFTWARE.
 #include "CmException.h"
 #include "CmRenderTarget.h"
 #include "CmRenderWindow.h"
-#include "CmHardwarePixelBuffer.h"
-#include "CmHardwareOcclusionQuery.h"
+#include "CmPixelBuffer.h"
+#include "CmOcclusionQuery.h"
 #include "CmCommandQueue.h"
 #include "CmDeferredRenderContext.h"
 #include "boost/bind.hpp"

CamelotRenderer/Source/CmRenderTexture.cpp

@@ -28,7 +28,7 @@ THE SOFTWARE.
 
 #include "CmRenderTexture.h"
 #include "CmException.h"
-#include "CmHardwarePixelBuffer.h"
+#include "CmPixelBuffer.h"
 #include "CmTexture.h"
 #include "CmTextureManager.h"
 #include "CmDepthStencilBuffer.h"

CamelotRenderer/Source/CmTexture.cpp

@@ -25,7 +25,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 -----------------------------------------------------------------------------
 */
-#include "CmHardwarePixelBuffer.h"
+#include "CmPixelBuffer.h"
 #include "CmTexture.h"
 #include "CmTextureRTTI.h"
 #include "CmDataStream.h"

CamelotRenderer/Source/CmHardwareVertexBuffer.cpp → CamelotRenderer/Source/CmVertexBuffer.cpp

@@ -26,7 +26,7 @@ THE SOFTWARE.
 -----------------------------------------------------------------------------
 */
 
-#include "CmHardwareVertexBuffer.h"
+#include "CmVertexBuffer.h"
 #include "CmColor.h"
 #include "CmException.h"
 #include "CmHardwareBufferManager.h"
@@ -36,7 +36,7 @@ THE SOFTWARE.
 namespace CamelotEngine {
 
     //-----------------------------------------------------------------------------
-    HardwareVertexBuffer::HardwareVertexBuffer(HardwareBufferManagerBase* mgr, UINT32 vertexSize,  
+    VertexBuffer::VertexBuffer(HardwareBufferManagerBase* mgr, UINT32 vertexSize,  
         UINT32 numVertices, GpuBufferUsage usage, 
         bool useSystemMemory) 
         : HardwareBuffer(usage, useSystemMemory), 
@@ -49,7 +49,7 @@ namespace CamelotEngine {
 
     }
     //-----------------------------------------------------------------------------
-    HardwareVertexBuffer::~HardwareVertexBuffer()
+    VertexBuffer::~VertexBuffer()
     {
 		if (mMgr)
 		{

CamelotRenderer/Source/CmVertexIndexData.cpp

@@ -28,8 +28,8 @@ THE SOFTWARE.
 
 #include "CmVertexIndexData.h"
 #include "CmHardwareBufferManager.h"
-#include "CmHardwareVertexBuffer.h"
-#include "CmHardwareIndexBuffer.h"
+#include "CmVertexBuffer.h"
+#include "CmIndexBuffer.h"
 #include "CmVector3.h"
 #include "CmAxisAlignedBox.h"
 #include "CmException.h"
@@ -587,7 +587,7 @@ namespace CamelotEngine {
 		UINT32 i, j;
 		UINT16 *source = 0;
 
-		if (indexBuffer->getType() == HardwareIndexBuffer::IT_16BIT)
+		if (indexBuffer->getType() == IndexBuffer::IT_16BIT)
 		{
 			triangles = (Triangle*) malloc(sizeof(Triangle) * nTriangles);
 			source = (UINT16 *)buffer;
@@ -632,7 +632,7 @@ namespace CamelotEngine {
 			}
 		}
 
-		if (indexBuffer->getType() == HardwareIndexBuffer::IT_16BIT)
+		if (indexBuffer->getType() == IndexBuffer::IT_16BIT)
 		{
 			// reorder the indexbuffer
 			j = 0;
@@ -686,7 +686,7 @@ namespace CamelotEngine {
 
 		UINT16 *shortbuffer = (UINT16 *)indexBuffer->lock(GBL_READ_ONLY);
 
-		if (indexBuffer->getType() == HardwareIndexBuffer::IT_16BIT)
+		if (indexBuffer->getType() == IndexBuffer::IT_16BIT)
 			for (unsigned int i = 0; i < indexBuffer->getNumIndexes(); ++i)
 				inCache(shortbuffer[i]);
 		else