Renamed GenericBuffer to GpuBuffer

CamelotD3D11RenderSystem/CamelotD3D11RenderSystem.vcxproj

@@ -148,8 +148,8 @@
   <ItemGroup>
     <ClInclude Include="Include\CmD3D11BlendState.h" />
     <ClInclude Include="Include\CmD3D11DepthStencilState.h" />
-    <ClInclude Include="Include\CmD3D11GenericBuffer.h" />
-    <ClInclude Include="Include\CmD3D11GenericBufferView.h" />
+    <ClInclude Include="Include\CmD3D11GpuBuffer.h" />
+    <ClInclude Include="Include\CmD3D11GpuBufferView.h" />
     <ClInclude Include="Include\CmD3D11HardwareBufferManager.h" />
     <ClInclude Include="Include\CmD3D11Device.h" />
     <ClInclude Include="Include\CmD3D11Driver.h" />
@@ -187,8 +187,8 @@
     <ClCompile Include="Source\CmD3D11Device.cpp" />
     <ClCompile Include="Source\CmD3D11Driver.cpp" />
     <ClCompile Include="Source\CmD3D11DriverList.cpp" />
-    <ClCompile Include="Source\CmD3D11GenericBuffer.cpp" />
-    <ClCompile Include="Source\CmD3D11GenericBufferView.cpp" />
+    <ClCompile Include="Source\CmD3D11GpuBuffer.cpp" />
+    <ClCompile Include="Source\CmD3D11GpuBufferView.cpp" />
     <ClCompile Include="Source\CmD3D11GpuParamBlock.cpp" />
     <ClCompile Include="Source\CmD3D11GpuProgram.cpp" />
     <ClCompile Include="Source\CmD3D11GpuProgramManager.cpp" />

CamelotD3D11RenderSystem/CamelotD3D11RenderSystem.vcxproj.filters

@@ -99,12 +99,6 @@
     <ClInclude Include="Include\CmD3D11RenderWindowManager.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="Include\CmD3D11GenericBuffer.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="Include\CmD3D11GenericBufferView.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
     <ClInclude Include="Include\CmD3D11IndexBuffer.h">
       <Filter>Header Files</Filter>
     </ClInclude>
@@ -120,6 +114,12 @@
     <ClInclude Include="Include\CmD3D11HLSLParamParser.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="Include\CmD3D11GpuBuffer.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\CmD3D11GpuBufferView.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Source\CmD3D11GpuProgram.cpp">
@@ -197,12 +197,6 @@
     <ClCompile Include="Source\CmD3D11RenderWindowManager.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="Source\CmD3D11GenericBuffer.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="Source\CmD3D11GenericBufferView.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
     <ClCompile Include="Source\CmD3D11VertexBuffer.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
@@ -221,5 +215,11 @@
     <ClCompile Include="Source\CmD3D11HLSLParamParser.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="Source\CmD3D11GpuBuffer.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Source\CmD3D11GpuBufferView.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

CamelotD3D11RenderSystem/Include/CmD3D11GenericBufferView.h

@@ -1,22 +0,0 @@
-#pragma once
-
-#include "CmD3D11Prerequisites.h"
-#include "CmGenericBuffer.h"
-#include "CmGenericBufferView.h"
-
-namespace CamelotEngine
-{
-	class CM_D3D11_EXPORT D3D11GenericBufferView : public GenericBufferView
-	{
-	public:
-		D3D11GenericBufferView(ID3D11Buffer* buffer, GenericBufferType type, UINT32 firstElement, UINT32 elementWidth, UINT32 numElements, bool randomGpuWrite, bool useCounter = false);
-		virtual ~D3D11GenericBufferView();
-
-	private:
-		ID3D11ShaderResourceView* mSRV;
-		ID3D11UnorderedAccessView* mUAV;
-
-		ID3D11ShaderResourceView* createSRV(ID3D11Buffer* buffer, GenericBufferType type, UINT32 firstElement, UINT32 elementWidth, UINT32 numElements);
-		ID3D11UnorderedAccessView* createUAV(ID3D11Buffer* buffer, GenericBufferType type, UINT32 firstElement, UINT32 numElements, bool useCounter);
-	};
-}

CamelotD3D11RenderSystem/Include/CmD3D11GenericBuffer.h → CamelotD3D11RenderSystem/Include/CmD3D11GpuBuffer.h

@@ -1,16 +1,16 @@
 #pragma once
 
 #include "CmD3D11Prerequisites.h"
-#include "CmGenericBuffer.h"
+#include "CmGpuBuffer.h"
 #include "CmCommonEnums.h"
 
 namespace CamelotEngine 
 {
-	class CM_D3D11_EXPORT D3D11GenericBuffer : public GenericBuffer
+	class CM_D3D11_EXPORT D3D11GpuBuffer : public GpuBuffer
     {
     public:
-		D3D11GenericBuffer(UINT32 elementCount, UINT32 elementSize, GenericBufferType type, GpuBufferUsage usage, bool randomGpuWrite = false, bool useCounter = false);
-        ~D3D11GenericBuffer();
+		D3D11GpuBuffer(UINT32 elementCount, UINT32 elementSize, GpuBufferType type, GpuBufferUsage usage, bool randomGpuWrite = false, bool useCounter = false);
+        ~D3D11GpuBuffer();
 
 		/**
 		 * @copydoc GenericBuffer::lockImpl
@@ -36,13 +36,13 @@ namespace CamelotEngine
 		/**
 		* @copydoc GenericBuffer::copyData
 		*/
-		void copyData(GenericBuffer& srcBuffer, UINT32 srcOffset, 
+		void copyData(GpuBuffer& srcBuffer, UINT32 srcOffset, 
 			UINT32 dstOffset, UINT32 length, bool discardWholeBuffer = false);
 
 	protected:
 		D3D11HardwareBuffer* mBuffer;
 
-		virtual GenericBufferView* createView(UINT32 firstElement, UINT32 elementWidth, UINT32 numElements, bool randomGpuWrite);
-		virtual void destroyView(GenericBufferView* view);
+		virtual GpuBufferView* createView(UINT32 firstElement, UINT32 elementWidth, UINT32 numElements, bool randomGpuWrite);
+		virtual void destroyView(GpuBufferView* view);
     };
 }

CamelotD3D11RenderSystem/Include/CmD3D11GpuBufferView.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "CmD3D11Prerequisites.h"
+#include "CmGpuBuffer.h"
+#include "CmGpuBufferView.h"
+
+namespace CamelotEngine
+{
+	class CM_D3D11_EXPORT D3D11GpuBufferView : public GpuBufferView
+	{
+	public:
+		D3D11GpuBufferView(ID3D11Buffer* buffer, GpuBufferType type, UINT32 firstElement, UINT32 elementWidth, UINT32 numElements, bool randomGpuWrite, bool useCounter = false);
+		virtual ~D3D11GpuBufferView();
+
+	private:
+		ID3D11ShaderResourceView* mSRV;
+		ID3D11UnorderedAccessView* mUAV;
+
+		ID3D11ShaderResourceView* createSRV(ID3D11Buffer* buffer, GpuBufferType type, UINT32 firstElement, UINT32 elementWidth, UINT32 numElements);
+		ID3D11UnorderedAccessView* createUAV(ID3D11Buffer* buffer, GpuBufferType type, UINT32 firstElement, UINT32 numElements, bool useCounter);
+	};
+}

CamelotD3D11RenderSystem/Include/CmD3D11HardwareBufferManager.h

@@ -32,7 +32,7 @@ namespace CamelotEngine
 		 *  - Counter can only be used with STRUCTURED buffer type
 		 */
 		GenericBufferPtr createGenericBuffer(UINT32 elementCount, UINT32 elementSize, 
-			GenericBufferType type, GpuBufferUsage usage, bool randomGpuWrite = false, bool useCounter = false);
+			GpuBufferType type, GpuBufferUsage usage, bool randomGpuWrite = false, bool useCounter = false);
 
 	protected:     
 		/// Internal method for creates a new vertex declaration, may be overridden by certain rendering APIs

CamelotD3D11RenderSystem/Source/CmD3D11GenericBuffer.cpp → CamelotD3D11RenderSystem/Source/CmD3D11GpuBuffer.cpp

@@ -1,5 +1,5 @@
-#include "CmD3D11GenericBuffer.h"
-#include "CmD3D11GenericBufferView.h"
+#include "CmD3D11GpuBuffer.h"
+#include "CmD3D11GpuBufferView.h"
 #include "CmD3D11RenderSystem.h"
 #include "CmD3D11HardwareBuffer.h"
 #include "CmD3D11Device.h"
@@ -7,8 +7,8 @@
 
 namespace CamelotEngine
 {
-	D3D11GenericBuffer::D3D11GenericBuffer(UINT32 elementCount, UINT32 elementSize, GenericBufferType type, GpuBufferUsage usage, bool randomGpuWrite, bool useCounter) 
-		: GenericBuffer(elementCount, elementSize, type, usage, randomGpuWrite, useCounter), mBuffer(nullptr)
+	D3D11GpuBuffer::D3D11GpuBuffer(UINT32 elementCount, UINT32 elementSize, GpuBufferType type, GpuBufferUsage usage, bool randomGpuWrite, bool useCounter) 
+		: GpuBuffer(elementCount, elementSize, type, usage, randomGpuWrite, useCounter), mBuffer(nullptr)
 	{
 		D3D11HardwareBuffer::BufferType bufferType;
 		D3D11RenderSystem* d3d11rs = static_cast<D3D11RenderSystem*>(D3D11RenderSystem::instancePtr());
@@ -33,47 +33,47 @@ namespace CamelotEngine
 			d3d11rs->getPrimaryDevice(), false, false, randomGpuWrite, useCounter);
 	}
 
-	D3D11GenericBuffer::~D3D11GenericBuffer()
+	D3D11GpuBuffer::~D3D11GpuBuffer()
 	{
 		delete mBuffer;
 
 		clearBufferViews();
 	}
 
-	void* D3D11GenericBuffer::lock(UINT32 offset, UINT32 length, GpuLockOptions options)
+	void* D3D11GpuBuffer::lock(UINT32 offset, UINT32 length, GpuLockOptions options)
 	{
 		return mBuffer->lock(offset, length, options);
 	}
 
-	void D3D11GenericBuffer::unlock()
+	void D3D11GpuBuffer::unlock()
 	{
 		mBuffer->unlock();
 	}
 
-	void D3D11GenericBuffer::readData(UINT32 offset, UINT32 length, void* pDest)
+	void D3D11GpuBuffer::readData(UINT32 offset, UINT32 length, void* pDest)
 	{
 		mBuffer->readData(offset, length, pDest);
 	}
 
-	void D3D11GenericBuffer::writeData(UINT32 offset, UINT32 length, const void* pSource, bool discardWholeBuffer)
+	void D3D11GpuBuffer::writeData(UINT32 offset, UINT32 length, const void* pSource, bool discardWholeBuffer)
 	{
 		mBuffer->writeData(offset, length, pSource, discardWholeBuffer);
 	}
 
-	void D3D11GenericBuffer::copyData(GenericBuffer& srcBuffer, UINT32 srcOffset, 
+	void D3D11GpuBuffer::copyData(GpuBuffer& srcBuffer, UINT32 srcOffset, 
 		UINT32 dstOffset, UINT32 length, bool discardWholeBuffer)
 	{
-		D3D11GenericBuffer* d3d11SrcBuffer = static_cast<D3D11GenericBuffer*>(&srcBuffer);
+		D3D11GpuBuffer* d3d11SrcBuffer = static_cast<D3D11GpuBuffer*>(&srcBuffer);
 
 		mBuffer->copyData(*d3d11SrcBuffer->mBuffer, srcOffset, dstOffset, length, discardWholeBuffer);
 	}
 
-	GenericBufferView* D3D11GenericBuffer::createView(UINT32 firstElement, UINT32 elementWidth, UINT32 numElements, bool randomGpuWrite)
+	GpuBufferView* D3D11GpuBuffer::createView(UINT32 firstElement, UINT32 elementWidth, UINT32 numElements, bool randomGpuWrite)
 	{
-		return new D3D11GenericBufferView(mBuffer->getD3DBuffer(), mType, firstElement, elementWidth, numElements, randomGpuWrite, mUseCounter);
+		return new D3D11GpuBufferView(mBuffer->getD3DBuffer(), mType, firstElement, elementWidth, numElements, randomGpuWrite, mUseCounter);
 	}
 
-	void D3D11GenericBuffer::destroyView(GenericBufferView* view)
+	void D3D11GpuBuffer::destroyView(GpuBufferView* view)
 	{
 		delete view;
 	}

CamelotD3D11RenderSystem/Source/CmD3D11GenericBufferView.cpp → CamelotD3D11RenderSystem/Source/CmD3D11GpuBufferView.cpp

@@ -1,13 +1,13 @@
-#include "CmD3D11GenericBufferView.h"
+#include "CmD3D11GpuBufferView.h"
 #include "CmD3D11RenderSystem.h"
 #include "CmD3D11Device.h"
 #include "CmException.h"
 
 namespace CamelotEngine
 {
-	D3D11GenericBufferView::D3D11GenericBufferView(ID3D11Buffer* buffer, GenericBufferType type, 
+	D3D11GpuBufferView::D3D11GpuBufferView(ID3D11Buffer* buffer, GpuBufferType type, 
 		UINT32 firstElement, UINT32 elementWidth, UINT32 numElements, bool randomGpuWrite, bool useCounter)
-		:GenericBufferView(firstElement, elementWidth, numElements, randomGpuWrite), mSRV(nullptr), mUAV(nullptr)
+		:GpuBufferView(firstElement, elementWidth, numElements, randomGpuWrite), mSRV(nullptr), mUAV(nullptr)
 	{
 		if(randomGpuWrite)
 			mSRV = createSRV(buffer, type, firstElement, elementWidth, numElements);
@@ -15,14 +15,14 @@ namespace CamelotEngine
 			mUAV = createUAV(buffer, type, firstElement, numElements, useCounter);
 	}
 
-	D3D11GenericBufferView::~D3D11GenericBufferView()
+	D3D11GpuBufferView::~D3D11GpuBufferView()
 	{
 		SAFE_RELEASE(mSRV);
 		SAFE_RELEASE(mUAV);
 	}
 
-	ID3D11ShaderResourceView* D3D11GenericBufferView::createSRV(ID3D11Buffer* buffer, 
-		GenericBufferType type, UINT32 firstElement, UINT32 elementWidth, UINT32 numElements)
+	ID3D11ShaderResourceView* D3D11GpuBufferView::createSRV(ID3D11Buffer* buffer, 
+		GpuBufferType type, UINT32 firstElement, UINT32 elementWidth, UINT32 numElements)
 	{
 		if(type == GBT_APPENDCONSUME)
 			CM_EXCEPT(InvalidParametersException, "Cannot create ShaderResourceView for an append/consume buffer.");
@@ -67,8 +67,8 @@ namespace CamelotEngine
 		return srv;
 	}
 
-	ID3D11UnorderedAccessView* D3D11GenericBufferView::createUAV(ID3D11Buffer* buffer, 
-		GenericBufferType type, UINT32 firstElement, UINT32 numElements, bool useCounter)
+	ID3D11UnorderedAccessView* D3D11GpuBufferView::createUAV(ID3D11Buffer* buffer, 
+		GpuBufferType type, UINT32 firstElement, UINT32 numElements, bool useCounter)
 	{
 		D3D11_UNORDERED_ACCESS_VIEW_DESC desc;
 		ZeroMemory(&desc, sizeof(desc));

CamelotD3D11RenderSystem/Source/CmD3D11HardwareBufferManager.cpp

@@ -1,7 +1,7 @@
 #include "CmD3D11HardwareBufferManager.h"
 #include "CmD3D11VertexBuffer.h"
 #include "CmD3D11IndexBuffer.h"
-#include "CmD3D11GenericBuffer.h"
+#include "CmD3D11GpuBuffer.h"
 #include "CmD3D11GpuParamBlock.h"
 #include "CmGpuParamDesc.h"
 
@@ -50,9 +50,9 @@ namespace CamelotEngine
 	}
 
 	GenericBufferPtr D3D11HardwareBufferManager::createGenericBuffer(UINT32 elementCount, UINT32 elementSize, 
-		GenericBufferType type, GpuBufferUsage usage, bool randomGpuWrite, bool useCounter)
+		GpuBufferType type, GpuBufferUsage usage, bool randomGpuWrite, bool useCounter)
 	{
-		return GenericBufferPtr(new D3D11GenericBuffer(elementCount, elementSize, type, usage, randomGpuWrite, useCounter));
+		return GenericBufferPtr(new D3D11GpuBuffer(elementCount, elementSize, type, usage, randomGpuWrite, useCounter));
 	}
 
 	VertexDeclarationPtr D3D11HardwareBufferManager::createVertexDeclarationImpl(void)

CamelotD3D9Renderer/CamelotD3D9Renderer.vcxproj

@@ -151,7 +151,7 @@
     <ClInclude Include="Include\CmD3D9DeviceManager.h" />
     <ClInclude Include="Include\CmD3D9Driver.h" />
     <ClInclude Include="Include\CmD3D9DriverList.h" />
-    <ClInclude Include="Include\CmD3D9GenericBuffer.h" />
+    <ClInclude Include="Include\CmD3D9GpuBuffer.h" />
     <ClInclude Include="Include\CmD3D9GpuProgram.h" />
     <ClInclude Include="Include\CmD3D9GpuProgramManager.h" />
     <ClInclude Include="Include\CmD3D9HardwareBufferManager.h" />
@@ -184,7 +184,7 @@
     <ClCompile Include="Source\CmD3D9DeviceManager.cpp" />
     <ClCompile Include="Source\CmD3D9Driver.cpp" />
     <ClCompile Include="Source\CmD3D9DriverList.cpp" />
-    <ClCompile Include="Source\CmD3D9GenericBuffer.cpp" />
+    <ClCompile Include="Source\CmD3D9GpuBuffer.cpp" />
     <ClCompile Include="Source\CmD3D9GpuProgram.cpp" />
     <ClCompile Include="Source\CmD3D9GpuProgramManager.cpp" />
     <ClCompile Include="Source\CmD3D9HardwareBufferManager.cpp" />

CamelotD3D9Renderer/CamelotD3D9Renderer.vcxproj.filters

@@ -93,9 +93,6 @@
     <ClInclude Include="Include\CmD3D9MultiRenderTexture.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="Include\CmD3D9GenericBuffer.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
     <ClInclude Include="Include\CmD3D9VertexBuffer.h">
       <Filter>Header Files</Filter>
     </ClInclude>
@@ -108,6 +105,9 @@
     <ClInclude Include="Include\CmD3D9IndexBuffer.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="Include\CmD3D9GpuBuffer.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Source\CmD3D9Device.cpp">
@@ -182,9 +182,6 @@
     <ClCompile Include="Source\CmD3D9MultiRenderTexture.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="Source\CmD3D9GenericBuffer.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
     <ClCompile Include="Source\CmD3D9IndexBuffer.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
@@ -197,5 +194,8 @@
     <ClCompile Include="Source\CmD3D9VertexBuffer.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="Source\CmD3D9GpuBuffer.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

CamelotD3D9Renderer/Include/CmD3D9GenericBuffer.h → CamelotD3D9Renderer/Include/CmD3D9GpuBuffer.h

@@ -1,15 +1,15 @@
 #pragma once
 
 #include "CmD3D9Prerequisites.h"
-#include "CmGenericBuffer.h"
+#include "CmGpuBuffer.h"
 
 namespace CamelotEngine
 {
-	class CM_D3D9_EXPORT D3D9GenericBuffer : public GenericBuffer
+	class CM_D3D9_EXPORT D3D9GpuBuffer : public GpuBuffer
 	{
 	public:
-		D3D9GenericBuffer(UINT32 elementCount, UINT32 elementSize, GenericBufferType type, GpuBufferUsage usage, bool randomGpuWrite = false, bool useCounter = false);
-        ~D3D9GenericBuffer();
+		D3D9GpuBuffer(UINT32 elementCount, UINT32 elementSize, GpuBufferType type, GpuBufferUsage usage, bool randomGpuWrite = false, bool useCounter = false);
+        ~D3D9GpuBuffer();
 
 		/**
 		 * @copydoc GenericBuffer::lockImpl
@@ -35,11 +35,11 @@ namespace CamelotEngine
 		/**
 		* @copydoc GenericBuffer::copyData
 		*/
-		void copyData(GenericBuffer& srcBuffer, UINT32 srcOffset, 
+		void copyData(GpuBuffer& srcBuffer, UINT32 srcOffset, 
 			UINT32 dstOffset, UINT32 length, bool discardWholeBuffer = false);
 
 	protected:
-		virtual GenericBufferView* createView(UINT32 firstElement, UINT32 elementWidth, UINT32 numElements, bool randomGpuWrite);
-		virtual void destroyView(GenericBufferView* view);
+		virtual GpuBufferView* createView(UINT32 firstElement, UINT32 elementWidth, UINT32 numElements, bool randomGpuWrite);
+		virtual void destroyView(GpuBufferView* view);
 	};
 }

CamelotD3D9Renderer/Include/CmD3D9HardwareBufferManager.h

@@ -65,7 +65,7 @@ namespace CamelotEngine {
 		 * DirectX 9 does not support generic buffers so this method will return a dummy instance.
 		 */
 		GenericBufferPtr createGenericBuffer(UINT32 elementCount, UINT32 elementSize, 
-			GenericBufferType type, GpuBufferUsage usage, bool randomGpuWrite = false, bool useCounter = false);
+			GpuBufferType type, GpuBufferUsage usage, bool randomGpuWrite = false, bool useCounter = false);
     };
 }
 

CamelotD3D9Renderer/Source/CmD3D9GenericBuffer.cpp

@@ -1,47 +0,0 @@
-#include "CmD3D9GenericBuffer.h"
-#include "CmDebug.h"
-
-namespace CamelotEngine
-{
-	D3D9GenericBuffer::D3D9GenericBuffer(UINT32 elementCount, UINT32 elementSize, GenericBufferType type, GpuBufferUsage usage, bool randomGpuWrite, bool useCounter) 
-		: GenericBuffer(elementCount, elementSize, type, usage, randomGpuWrite, useCounter)
-	{
-		LOGWRN("Generic buffers are not supported in DirectX 9. Creating a dummy buffer. All operations on it will either be no-op or return a nullptr.");
-	}
-
-	D3D9GenericBuffer::~D3D9GenericBuffer()
-	{
-		clearBufferViews();
-	}
-
-	void* D3D9GenericBuffer::lock(UINT32 offset, UINT32 length, GpuLockOptions options)
-	{
-		return nullptr;
-	}
-
-	void D3D9GenericBuffer::unlock()
-	{
-	}
-
-	void D3D9GenericBuffer::readData(UINT32 offset, UINT32 length, void* pDest)
-	{
-	}
-
-	void D3D9GenericBuffer::writeData(UINT32 offset, UINT32 length, const void* pSource, bool discardWholeBuffer)
-	{
-	}
-
-	void D3D9GenericBuffer::copyData(GenericBuffer& srcBuffer, UINT32 srcOffset, 
-		UINT32 dstOffset, UINT32 length, bool discardWholeBuffer)
-	{
-	}
-
-	GenericBufferView* D3D9GenericBuffer::createView(UINT32 firstElement, UINT32 elementWidth, UINT32 numElements, bool randomGpuWrite)
-	{
-		return nullptr;
-	}
-
-	void D3D9GenericBuffer::destroyView(GenericBufferView* view)
-	{
-	}
-}

CamelotD3D9Renderer/Source/CmD3D9GpuBuffer.cpp

@@ -0,0 +1,47 @@
+#include "CmD3D9GpuBuffer.h"
+#include "CmDebug.h"
+
+namespace CamelotEngine
+{
+	D3D9GpuBuffer::D3D9GpuBuffer(UINT32 elementCount, UINT32 elementSize, GpuBufferType type, GpuBufferUsage usage, bool randomGpuWrite, bool useCounter) 
+		: GpuBuffer(elementCount, elementSize, type, usage, randomGpuWrite, useCounter)
+	{
+		LOGWRN("Generic buffers are not supported in DirectX 9. Creating a dummy buffer. All operations on it will either be no-op or return a nullptr.");
+	}
+
+	D3D9GpuBuffer::~D3D9GpuBuffer()
+	{
+		clearBufferViews();
+	}
+
+	void* D3D9GpuBuffer::lock(UINT32 offset, UINT32 length, GpuLockOptions options)
+	{
+		return nullptr;
+	}
+
+	void D3D9GpuBuffer::unlock()
+	{
+	}
+
+	void D3D9GpuBuffer::readData(UINT32 offset, UINT32 length, void* pDest)
+	{
+	}
+
+	void D3D9GpuBuffer::writeData(UINT32 offset, UINT32 length, const void* pSource, bool discardWholeBuffer)
+	{
+	}
+
+	void D3D9GpuBuffer::copyData(GpuBuffer& srcBuffer, UINT32 srcOffset, 
+		UINT32 dstOffset, UINT32 length, bool discardWholeBuffer)
+	{
+	}
+
+	GpuBufferView* D3D9GpuBuffer::createView(UINT32 firstElement, UINT32 elementWidth, UINT32 numElements, bool randomGpuWrite)
+	{
+		return nullptr;
+	}
+
+	void D3D9GpuBuffer::destroyView(GpuBufferView* view)
+	{
+	}
+}

CamelotD3D9Renderer/Source/CmD3D9HardwareBufferManager.cpp

@@ -29,7 +29,7 @@ THE SOFTWARE.
 #include "CmD3D9VertexBuffer.h"
 #include "CmD3D9IndexBuffer.h"
 #include "CmD3D9VertexDeclaration.h"
-#include "CmD3D9GenericBuffer.h"
+#include "CmD3D9GpuBuffer.h"
 #include "CmGpuParamBlock.h"
 #include "CmException.h"
 
@@ -73,9 +73,9 @@ namespace CamelotEngine {
 	}
 	//-----------------------------------------------------------------------
 	GenericBufferPtr D3D9HardwareBufferManager::createGenericBuffer(UINT32 elementCount, UINT32 elementSize, 
-		GenericBufferType type, GpuBufferUsage usage, bool randomGpuWrite, bool useCounter)
+		GpuBufferType type, GpuBufferUsage usage, bool randomGpuWrite, bool useCounter)
 	{
-		return GenericBufferPtr(new D3D9GenericBuffer(elementCount, elementSize, type, usage, randomGpuWrite, useCounter));
+		return GenericBufferPtr(new D3D9GpuBuffer(elementCount, elementSize, type, usage, randomGpuWrite, useCounter));
 	}
     //-----------------------------------------------------------------------
     VertexDeclarationPtr D3D9HardwareBufferManager::createVertexDeclarationImpl(void)

CamelotGLRenderer/CamelotGLRenderer.vcxproj

@@ -149,7 +149,7 @@
   <ItemGroup>
     <ClInclude Include="Include\CmGLContext.h" />
     <ClInclude Include="Include\CmGLFrameBufferObject.h" />
-    <ClInclude Include="Include\CmGLGenericBuffer.h" />
+    <ClInclude Include="Include\CmGLGpuBuffer.h" />
     <ClInclude Include="Include\CmGLGpuParamBlock.h" />
     <ClInclude Include="Include\CmGLGpuProgramManager.h" />
     <ClInclude Include="Include\CmGLHardwareBufferManager.h" />
@@ -185,7 +185,7 @@
     <ClCompile Include="CmGLPlugin.cpp" />
     <ClCompile Include="Source\CmGLContext.cpp" />
     <ClCompile Include="Source\CmGLFrameBufferObject.cpp" />
-    <ClCompile Include="Source\CmGLGenericBuffer.cpp" />
+    <ClCompile Include="Source\CmGLGpuBuffer.cpp" />
     <ClCompile Include="Source\CmGLGpuParamBlock.cpp" />
     <ClCompile Include="Source\CmGLGpuProgramManager.cpp" />
     <ClCompile Include="Source\CmGLHardwareBufferManager.cpp" />

CamelotGLRenderer/CamelotGLRenderer.vcxproj.filters

@@ -108,9 +108,6 @@
     <ClInclude Include="Source\GLSL\include\CmGLSLProgramPipelineManager.h">
       <Filter>GLSL</Filter>
     </ClInclude>
-    <ClInclude Include="Include\CmGLGenericBuffer.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
     <ClInclude Include="Include\CmGLOcclusionQuery.h">
       <Filter>Header Files</Filter>
     </ClInclude>
@@ -123,6 +120,9 @@
     <ClInclude Include="Include\CmGLIndexBuffer.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="Include\CmGLGpuBuffer.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Source\GLSL\src\CmGLSLExtSupport.cpp">
@@ -200,9 +200,6 @@
     <ClCompile Include="Source\GLSL\src\CmGLSLProgramPipelineManager.cpp">
       <Filter>GLSL</Filter>
     </ClCompile>
-    <ClCompile Include="Source\CmGLGenericBuffer.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
     <ClCompile Include="Source\CmGLIndexBuffer.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
@@ -215,5 +212,8 @@
     <ClCompile Include="Source\CmGLVertexBuffer.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="Source\CmGLGpuBuffer.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

CamelotGLRenderer/Include/CmGLGenericBuffer.h → CamelotGLRenderer/Include/CmGLGpuBuffer.h

@@ -1,15 +1,15 @@
 #pragma once
 
 #include "CmGLPrerequisites.h"
-#include "CmGenericBuffer.h"
+#include "CmGpuBuffer.h"
 
 namespace CamelotEngine
 {
-	class CM_RSGL_EXPORT GLGenericBuffer : public GenericBuffer
+	class CM_RSGL_EXPORT GLGpuBuffer : public GpuBuffer
 	{
 	public:
-		GLGenericBuffer(UINT32 elementCount, UINT32 elementSize, GenericBufferType type, GpuBufferUsage usage, bool randomGpuWrite = false, bool useCounter = false);
-        ~GLGenericBuffer();
+		GLGpuBuffer(UINT32 elementCount, UINT32 elementSize, GpuBufferType type, GpuBufferUsage usage, bool randomGpuWrite = false, bool useCounter = false);
+        ~GLGpuBuffer();
 
 		/**
 		 * @copydoc GenericBuffer::lockImpl
@@ -35,11 +35,11 @@ namespace CamelotEngine
 		/**
 		* @copydoc GenericBuffer::copyData
 		*/
-		void copyData(GenericBuffer& srcBuffer, UINT32 srcOffset, 
+		void copyData(GpuBuffer& srcBuffer, UINT32 srcOffset, 
 			UINT32 dstOffset, UINT32 length, bool discardWholeBuffer = false);
 
 	protected:
-		virtual GenericBufferView* createView(UINT32 firstElement, UINT32 elementWidth, UINT32 numElements, bool randomGpuWrite);
-		virtual void destroyView(GenericBufferView* view);
+		virtual GpuBufferView* createView(UINT32 firstElement, UINT32 elementWidth, UINT32 numElements, bool randomGpuWrite);
+		virtual void destroyView(GpuBufferView* view);
 	};
 }

CamelotGLRenderer/Include/CmGLHardwareBufferManager.h

@@ -71,7 +71,7 @@ namespace CamelotEngine {
 		 * OpenGL does not support generic buffers so this method will return a dummy instance.
 		 */
 		GenericBufferPtr createGenericBuffer(UINT32 elementCount, UINT32 elementSize, 
-			GenericBufferType type, GpuBufferUsage usage, bool randomGpuWrite = false, bool useCounter = false);
+			GpuBufferType type, GpuBufferUsage usage, bool randomGpuWrite = false, bool useCounter = false);
 
         /// Utility function to get the correct GL usage based on HBU's
         static GLenum getGLUsage(unsigned int usage);

CamelotGLRenderer/Source/CmGLGenericBuffer.cpp

@@ -1,47 +0,0 @@
-#include "CmGLGenericBuffer.h"
-#include "CmDebug.h"
-
-namespace CamelotEngine
-{
-	GLGenericBuffer::GLGenericBuffer(UINT32 elementCount, UINT32 elementSize, GenericBufferType type, GpuBufferUsage usage, bool randomGpuWrite, bool useCounter) 
-		: GenericBuffer(elementCount, elementSize, type, usage, randomGpuWrite, useCounter)
-	{
-		LOGWRN("Generic buffers are not supported in OpenGL. Creating a dummy buffer. All operations on it will either be no-op or return a nullptr.");
-	}
-
-	GLGenericBuffer::~GLGenericBuffer()
-	{
-		clearBufferViews();
-	}
-
-	void* GLGenericBuffer::lock(UINT32 offset, UINT32 length, GpuLockOptions options)
-	{
-		return nullptr;
-	}
-
-	void GLGenericBuffer::unlock()
-	{
-	}
-
-	void GLGenericBuffer::readData(UINT32 offset, UINT32 length, void* pDest)
-	{
-	}
-
-	void GLGenericBuffer::writeData(UINT32 offset, UINT32 length, const void* pSource, bool discardWholeBuffer)
-	{
-	}
-
-	void GLGenericBuffer::copyData(GenericBuffer& srcBuffer, UINT32 srcOffset, 
-		UINT32 dstOffset, UINT32 length, bool discardWholeBuffer)
-	{
-	}
-
-	GenericBufferView* GLGenericBuffer::createView(UINT32 firstElement, UINT32 elementWidth, UINT32 numElements, bool randomGpuWrite)
-	{
-		return nullptr;
-	}
-
-	void GLGenericBuffer::destroyView(GenericBufferView* view)
-	{
-	}
-}

CamelotGLRenderer/Source/CmGLGpuBuffer.cpp

@@ -0,0 +1,47 @@
+#include "CmGLGpuBuffer.h"
+#include "CmDebug.h"
+
+namespace CamelotEngine
+{
+	GLGpuBuffer::GLGpuBuffer(UINT32 elementCount, UINT32 elementSize, GpuBufferType type, GpuBufferUsage usage, bool randomGpuWrite, bool useCounter) 
+		: GpuBuffer(elementCount, elementSize, type, usage, randomGpuWrite, useCounter)
+	{
+		LOGWRN("Generic buffers are not supported in OpenGL. Creating a dummy buffer. All operations on it will either be no-op or return a nullptr.");
+	}
+
+	GLGpuBuffer::~GLGpuBuffer()
+	{
+		clearBufferViews();
+	}
+
+	void* GLGpuBuffer::lock(UINT32 offset, UINT32 length, GpuLockOptions options)
+	{
+		return nullptr;
+	}
+
+	void GLGpuBuffer::unlock()
+	{
+	}
+
+	void GLGpuBuffer::readData(UINT32 offset, UINT32 length, void* pDest)
+	{
+	}
+
+	void GLGpuBuffer::writeData(UINT32 offset, UINT32 length, const void* pSource, bool discardWholeBuffer)
+	{
+	}
+
+	void GLGpuBuffer::copyData(GpuBuffer& srcBuffer, UINT32 srcOffset, 
+		UINT32 dstOffset, UINT32 length, bool discardWholeBuffer)
+	{
+	}
+
+	GpuBufferView* GLGpuBuffer::createView(UINT32 firstElement, UINT32 elementWidth, UINT32 numElements, bool randomGpuWrite)
+	{
+		return nullptr;
+	}
+
+	void GLGpuBuffer::destroyView(GpuBufferView* view)
+	{
+	}
+}

CamelotGLRenderer/Source/CmGLHardwareBufferManager.cpp

@@ -28,7 +28,7 @@ THE SOFTWARE.
 #include "CmGLHardwareBufferManager.h"
 #include "CmGLVertexBuffer.h"
 #include "CmGLIndexBuffer.h"
-#include "CmGLGenericBuffer.h"
+#include "CmGLGpuBuffer.h"
 #include "CmHardwareBuffer.h"
 #include "CmGLGpuParamBlock.h"
 #include "CmRenderSystem.h"
@@ -110,9 +110,9 @@ namespace CamelotEngine {
 	}
 	//---------------------------------------------------------------------
 	GenericBufferPtr GLHardwareBufferManager::createGenericBuffer(UINT32 elementCount, UINT32 elementSize, 
-		GenericBufferType type, GpuBufferUsage usage, bool randomGpuWrite, bool useCounter)
+		GpuBufferType type, GpuBufferUsage usage, bool randomGpuWrite, bool useCounter)
 	{
-		return GenericBufferPtr(new GLGenericBuffer(elementCount, elementSize, type, usage, randomGpuWrite, useCounter));
+		return GenericBufferPtr(new GLGpuBuffer(elementCount, elementSize, type, usage, randomGpuWrite, useCounter));
 	}
     //---------------------------------------------------------------------
     GLenum GLHardwareBufferManager::getGLUsage(unsigned int usage)

CamelotRenderer/CamelotRenderer.vcxproj

@@ -190,8 +190,8 @@
     <ClInclude Include="Include\CmDeferredRenderContext.h" />
     <ClInclude Include="Include\CmDepthStencilStateRTTI.h" />
     <ClInclude Include="Include\CmDepthStencilState.h" />
-    <ClInclude Include="Include\CmGenericBuffer.h" />
-    <ClInclude Include="Include\CmGenericBufferView.h" />
+    <ClInclude Include="Include\CmGpuBuffer.h" />
+    <ClInclude Include="Include\CmGpuBufferView.h" />
     <ClInclude Include="Include\CmGpuParamBlock.h" />
     <ClInclude Include="Include\CmGpuParamDesc.h" />
     <ClInclude Include="Include\CmGpuParams.h" />
@@ -277,8 +277,8 @@
     <ClCompile Include="Source\CmCommandQueue.cpp" />
     <ClCompile Include="Source\CmDeferredRenderContext.cpp" />
     <ClCompile Include="Source\CmDepthStencilState.cpp" />
-    <ClCompile Include="Source\CmGenericBuffer.cpp" />
-    <ClCompile Include="Source\CmGenericBufferView.cpp" />
+    <ClCompile Include="Source\CmGpuBuffer.cpp" />
+    <ClCompile Include="Source\CmGpuBufferView.cpp" />
     <ClCompile Include="Source\CmGpuParamBlock.cpp" />
     <ClCompile Include="Source\CmGpuParams.cpp" />
     <ClCompile Include="Source\CmGpuProgram.cpp" />

CamelotRenderer/CamelotRenderer.vcxproj.filters

@@ -338,15 +338,9 @@
     <ClInclude Include="Include\CmVertexDeclaration.h">
       <Filter>Header Files\RenderSystem</Filter>
     </ClInclude>
-    <ClInclude Include="Include\CmGenericBuffer.h">
-      <Filter>Header Files\RenderSystem</Filter>
-    </ClInclude>
     <ClInclude Include="Include\CmCommonEnums.h">
       <Filter>Header Files\Utility</Filter>
     </ClInclude>
-    <ClInclude Include="Include\CmGenericBufferView.h">
-      <Filter>Header Files\RenderSystem</Filter>
-    </ClInclude>
     <ClInclude Include="Include\CmIndexBuffer.h">
       <Filter>Header Files\RenderSystem</Filter>
     </ClInclude>
@@ -359,6 +353,12 @@
     <ClInclude Include="Include\CmVertexBuffer.h">
       <Filter>Header Files\RenderSystem</Filter>
     </ClInclude>
+    <ClInclude Include="Include\CmGpuBuffer.h">
+      <Filter>Header Files\RenderSystem</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\CmGpuBufferView.h">
+      <Filter>Header Files\RenderSystem</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Source\CamelotRenderer.cpp">
@@ -523,12 +523,6 @@
     <ClCompile Include="Source\CmVertexDeclaration.cpp">
       <Filter>Source Files\RenderSystem</Filter>
     </ClCompile>
-    <ClCompile Include="Source\CmGenericBuffer.cpp">
-      <Filter>Source Files\RenderSystem</Filter>
-    </ClCompile>
-    <ClCompile Include="Source\CmGenericBufferView.cpp">
-      <Filter>Source Files\RenderSystem</Filter>
-    </ClCompile>
     <ClCompile Include="Source\CmIndexBuffer.cpp">
       <Filter>Source Files\RenderSystem</Filter>
     </ClCompile>
@@ -541,5 +535,11 @@
     <ClCompile Include="Source\CmVertexBuffer.cpp">
       <Filter>Source Files\RenderSystem</Filter>
     </ClCompile>
+    <ClCompile Include="Source\CmGpuBufferView.cpp">
+      <Filter>Source Files\RenderSystem</Filter>
+    </ClCompile>
+    <ClCompile Include="Source\CmGpuBuffer.cpp">
+      <Filter>Source Files\RenderSystem</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

CamelotRenderer/Include/CmCommonEnums.h

@@ -239,7 +239,7 @@ namespace CamelotEngine {
 	/**
 	 * @brief	Types of generic GPU buffers that may be attached to GPU programs.
 	 */
-	enum GenericBufferType
+	enum GpuBufferType
 	{
 		GBT_STRUCTURED,
 		GBT_RAW,

CamelotRenderer/Include/CmGenericBuffer.h

@@ -1,51 +0,0 @@
-#pragma once
-
-#include "CmPrerequisites.h"
-#include "CmCommonEnums.h"
-#include "CmGenericBufferView.h"
-
-namespace CamelotEngine 
-{
-	class CM_EXPORT GenericBuffer
-    {
-    public:
-        GenericBuffer(UINT32 elementCount, UINT32 elementSize, GenericBufferType type, GpuBufferUsage usage, bool randomGpuWrite = false, bool useCounter = false);
-        virtual ~GenericBuffer();
-
-		virtual void* lock(UINT32 offset, UINT32 length, GpuLockOptions options) = 0;
-		virtual void unlock() = 0;
-
-        virtual void readData(UINT32 offset, UINT32 length, void* pDest) = 0;
-        virtual void writeData(UINT32 offset, UINT32 length, const void* pSource, bool discardWholeBuffer = false) = 0;
-
-		virtual void copyData(GenericBuffer& srcBuffer, UINT32 srcOffset, 
-			UINT32 dstOffset, UINT32 length, bool discardWholeBuffer = false) = 0;
-
-		GenericBufferView* requestView(UINT32 firstElement, UINT32 elementWidth, UINT32 numElements, bool randomGpuWrite);
-		void releaseView(GenericBufferView* view);
-
-	protected:
-		GenericBufferType mType;
-		GpuBufferUsage mUsage;
-		bool mRandomGpuWrite;
-		bool mUseCounter;
-		UINT32 mElementCount;
-		UINT32 mElementSize;
-
-		virtual GenericBufferView* createView(UINT32 firstElement, UINT32 elementWidth, UINT32 numElements, bool randomGpuWrite) = 0;
-		virtual void destroyView(GenericBufferView* view) = 0;
-		void clearBufferViews();
-
-		struct GenericBufferReference
-		{
-			GenericBufferReference(GenericBufferView* _view)
-				:view(_view), refCount(0)
-			{ }
-
-			GenericBufferView* view;
-			UINT32 refCount;
-		};
-
-		std::unordered_map<GenericBufferView::Key, GenericBufferReference*, GenericBufferView::HashFunction, GenericBufferView::EqualFunction> mBufferViews;
-    };
-}

CamelotRenderer/Include/CmGpuBuffer.h

@@ -0,0 +1,51 @@
+#pragma once
+
+#include "CmPrerequisites.h"
+#include "CmCommonEnums.h"
+#include "CmGpuBufferView.h"
+
+namespace CamelotEngine 
+{
+	class CM_EXPORT GpuBuffer
+    {
+    public:
+        GpuBuffer(UINT32 elementCount, UINT32 elementSize, GpuBufferType type, GpuBufferUsage usage, bool randomGpuWrite = false, bool useCounter = false);
+        virtual ~GpuBuffer();
+
+		virtual void* lock(UINT32 offset, UINT32 length, GpuLockOptions options) = 0;
+		virtual void unlock() = 0;
+
+        virtual void readData(UINT32 offset, UINT32 length, void* pDest) = 0;
+        virtual void writeData(UINT32 offset, UINT32 length, const void* pSource, bool discardWholeBuffer = false) = 0;
+
+		virtual void copyData(GpuBuffer& srcBuffer, UINT32 srcOffset, 
+			UINT32 dstOffset, UINT32 length, bool discardWholeBuffer = false) = 0;
+
+		GpuBufferView* requestView(UINT32 firstElement, UINT32 elementWidth, UINT32 numElements, bool randomGpuWrite);
+		void releaseView(GpuBufferView* view);
+
+	protected:
+		GpuBufferType mType;
+		GpuBufferUsage mUsage;
+		bool mRandomGpuWrite;
+		bool mUseCounter;
+		UINT32 mElementCount;
+		UINT32 mElementSize;
+
+		virtual GpuBufferView* createView(UINT32 firstElement, UINT32 elementWidth, UINT32 numElements, bool randomGpuWrite) = 0;
+		virtual void destroyView(GpuBufferView* view) = 0;
+		void clearBufferViews();
+
+		struct GpuBufferReference
+		{
+			GpuBufferReference(GpuBufferView* _view)
+				:view(_view), refCount(0)
+			{ }
+
+			GpuBufferView* view;
+			UINT32 refCount;
+		};
+
+		std::unordered_map<GpuBufferView::Key, GpuBufferReference*, GpuBufferView::HashFunction, GpuBufferView::EqualFunction> mBufferViews;
+    };
+}

CamelotRenderer/Include/CmGenericBufferView.h → CamelotRenderer/Include/CmGpuBufferView.h

@@ -4,7 +4,7 @@
 
 namespace CamelotEngine
 {
-	class CM_EXPORT GenericBufferView
+	class CM_EXPORT GpuBufferView
 	{
 	public:
 		struct Key
@@ -12,7 +12,7 @@ namespace CamelotEngine
 			Key()
 			{ }
 
-			Key(const GenericBufferView& view)
+			Key(const GpuBufferView& view)
 				: mFirstElement(view.mFirstElement), mElementWidth(view.mElementWidth)
 				, mNumElements(view.mNumElements), mRandomGpuWrite(view.mRandomGpuWrite)
 			{ }
@@ -40,8 +40,8 @@ namespace CamelotEngine
 			bool operator()(const Key &a, const Key &b) const;
 		};
 
-		GenericBufferView(UINT32 firstElement, UINT32 elementWidth, UINT32 numElements, bool randomGpuWrite);
-		virtual ~GenericBufferView();
+		GpuBufferView(UINT32 firstElement, UINT32 elementWidth, UINT32 numElements, bool randomGpuWrite);
+		virtual ~GpuBufferView();
 
 	private:
 		UINT32 mFirstElement;

CamelotRenderer/Include/CmHardwareBufferManager.h

@@ -124,7 +124,7 @@ namespace CamelotEngine {
 		 * Be aware that some of these settings cannot be used together, and you will receive an assert if in debug mode.
 		 */
 		virtual GenericBufferPtr createGenericBuffer(UINT32 elementCount, UINT32 elementSize, 
-			GenericBufferType type, GpuBufferUsage usage, bool randomGpuWrite = false, bool useCounter = false) = 0;
+			GpuBufferType type, GpuBufferUsage usage, bool randomGpuWrite = false, bool useCounter = false) = 0;
 
         /** Creates a new vertex declaration. */
         virtual VertexDeclarationPtr createVertexDeclaration(void);

CamelotRenderer/Include/CmPrerequisites.h

@@ -97,7 +97,7 @@ namespace CamelotEngine {
     class OcclusionQuery;
     class VertexBuffer;
 	class PixelBuffer;
-	class GenericBuffer;
+	class GpuBuffer;
 	class HighLevelGpuProgram;
 	class HighLevelGpuProgramManager;
 	class HighLevelGpuProgramFactory;
@@ -170,7 +170,7 @@ namespace CamelotEngine
 	typedef std::shared_ptr<PixelBuffer> PixelBufferPtr;
 	typedef std::shared_ptr<VertexBuffer> VertexBufferPtr;
 	typedef std::shared_ptr<IndexBuffer> IndexBufferPtr;
-	typedef std::shared_ptr<GenericBuffer> GenericBufferPtr;
+	typedef std::shared_ptr<GpuBuffer> GenericBufferPtr;
 	typedef std::shared_ptr<VertexDeclaration> VertexDeclarationPtr;
 	typedef std::shared_ptr<Mesh> MeshPtr;
 	typedef std::shared_ptr<Texture> TexturePtr;

CamelotRenderer/Source/CmGenericBuffer.cpp → CamelotRenderer/Source/CmGpuBuffer.cpp

@@ -1,20 +1,20 @@
-#include "CmGenericBuffer.h"
+#include "CmGpuBuffer.h"
 #include "CmException.h"
 
 namespace CamelotEngine
 {
-	GenericBuffer::GenericBuffer(UINT32 elementCount, UINT32 elementSize, GenericBufferType type, GpuBufferUsage usage, bool randomGpuWrite, bool useCounter)
+	GpuBuffer::GpuBuffer(UINT32 elementCount, UINT32 elementSize, GpuBufferType type, GpuBufferUsage usage, bool randomGpuWrite, bool useCounter)
 		:mElementCount(elementCount), mElementSize(elementSize), mType(type), mUsage(usage), mRandomGpuWrite(randomGpuWrite), mUseCounter(useCounter)
 	{  
 	}
 
-	GenericBuffer::~GenericBuffer() 
+	GpuBuffer::~GpuBuffer() 
 	{
 		// Make sure that derived classes call clearBufferViews
 		// I can't call it here since it needs a virtual method call
 	}
 
-	void GenericBuffer::clearBufferViews()
+	void GpuBuffer::clearBufferViews()
 	{
 		for(auto iter = mBufferViews.begin(); iter != mBufferViews.end(); ++iter)
 		{
@@ -25,15 +25,15 @@ namespace CamelotEngine
 		mBufferViews.clear();
 	}
 
-	GenericBufferView* GenericBuffer::requestView(UINT32 firstElement, UINT32 elementWidth, UINT32 numElements, bool randomGpuWrite)
+	GpuBufferView* GpuBuffer::requestView(UINT32 firstElement, UINT32 elementWidth, UINT32 numElements, bool randomGpuWrite)
 	{
-		GenericBufferView::Key key(firstElement, elementWidth, numElements, randomGpuWrite);
+		GpuBufferView::Key key(firstElement, elementWidth, numElements, randomGpuWrite);
 
 		auto iterFind = mBufferViews.find(key);
 		if(iterFind == mBufferViews.end())
 		{
-			GenericBufferView* newView = createView(firstElement, elementWidth, numElements, randomGpuWrite);
-			mBufferViews[key] = new GenericBufferReference(newView);
+			GpuBufferView* newView = createView(firstElement, elementWidth, numElements, randomGpuWrite);
+			mBufferViews[key] = new GpuBufferReference(newView);
 
 			iterFind = mBufferViews.find(key);
 		}
@@ -42,9 +42,9 @@ namespace CamelotEngine
 		return iterFind->second->view;
 	}
 
-	void GenericBuffer::releaseView(GenericBufferView* view)
+	void GpuBuffer::releaseView(GpuBufferView* view)
 	{
-		GenericBufferView::Key key(*view);
+		GpuBufferView::Key key(*view);
 
 		auto iterFind = mBufferViews.find(key);
 		if(iterFind == mBufferViews.end())
@@ -56,7 +56,7 @@ namespace CamelotEngine
 
 		if(iterFind->second->refCount == 0)
 		{
-			GenericBufferReference* toRemove = iterFind->second;
+			GpuBufferReference* toRemove = iterFind->second;
 
 			mBufferViews.erase(iterFind);
 

CamelotRenderer/Source/CmGenericBufferView.cpp → CamelotRenderer/Source/CmGpuBufferView.cpp

@@ -1,9 +1,9 @@
-#include "CmGenericBufferView.h"
+#include "CmGpuBufferView.h"
 #include "CmUtil.h"
 
 namespace CamelotEngine
 {
-	size_t GenericBufferView::HashFunction::operator()(const Key &key) const
+	size_t GpuBufferView::HashFunction::operator()(const Key &key) const
 	{
 		size_t seed = 0;
 		hash_combine(seed, key.mElementWidth);
@@ -14,20 +14,20 @@ namespace CamelotEngine
 		return seed;
 	}
 
-	bool GenericBufferView::EqualFunction::operator()
+	bool GpuBufferView::EqualFunction::operator()
 		(const Key &a, const Key &b) const
 	{
 		return a.mElementWidth == b.mElementWidth && a.mFirstElement == b.mFirstElement 
 			&& a.mNumElements == b.mNumElements && a.mRandomGpuWrite == b.mRandomGpuWrite;
 	}
 
-	GenericBufferView::GenericBufferView(UINT32 firstElement, UINT32 elementWidth, UINT32 numElements, bool randomGpuWrite)
+	GpuBufferView::GpuBufferView(UINT32 firstElement, UINT32 elementWidth, UINT32 numElements, bool randomGpuWrite)
 		:mFirstElement(firstElement), mElementWidth(elementWidth), mNumElements(numElements), mRandomGpuWrite(randomGpuWrite)
 	{
 
 	}
 
-	GenericBufferView::~GenericBufferView()
+	GpuBufferView::~GpuBufferView()
 	{
 
 	}