Added dummy generic buffers to D3D9 and GL

CamelotD3D11RenderSystem/Include/CmD3D11HardwareBufferManager.h

@@ -24,6 +24,16 @@ namespace CamelotEngine
 		/** @copydoc HardwareBufferManagerInterface::createGpuParamBlock */
 		GpuParamBlockPtr createGpuParamBlock(const GpuParamBlockDesc& paramDesc);
 
+		/**
+		 * @copydoc HardwareBufferManagerInterface::createGpuParamBlock
+		 *
+		 * Some limitations are imposed on the combinations of parameters:
+		 *  - APPENDCONSUME buffer type can only be used with randomGpuWrite enabled  
+		 *  - 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);
+
 	protected:     
 		/// Internal method for creates a new vertex declaration, may be overridden by certain rendering APIs
 		VertexDeclarationPtr createVertexDeclarationImpl(void);

CamelotD3D11RenderSystem/Source/CmD3D11HardwareBufferManager.cpp

@@ -3,6 +3,7 @@
 #include "CmD3D11HardwareIndexBuffer.h"
 #include "CmD3D11HardwareConstantBuffer.h"
 #include "CmD3D11VertexDeclaration.h"
+#include "CmD3D11GenericBuffer.h"
 #include "CmGpuParamDesc.h"
 
 namespace CamelotEngine
@@ -49,6 +50,12 @@ namespace CamelotEngine
 		return GpuParamBlockPtr(new GpuParamBlock(blockDesc));
 	}
 
+	GenericBufferPtr D3D11HardwareBufferManagerBase::createGenericBuffer(UINT32 elementCount, UINT32 elementSize, 
+		GenericBufferType type, GpuBufferUsage usage, bool randomGpuWrite, bool useCounter)
+	{
+		return GenericBufferPtr(new D3D11GenericBuffer(elementCount, elementSize, type, usage, randomGpuWrite, useCounter));
+	}
+
 	VertexDeclarationPtr D3D11HardwareBufferManagerBase::createVertexDeclarationImpl(void)
 	{
 		return VertexDeclarationPtr(new D3D11VertexDeclaration());

CamelotD3D9Renderer/CamelotD3D9Renderer.vcxproj

@@ -152,6 +152,7 @@
     <ClInclude Include="Include\CmD3D9DeviceManager.h" />
     <ClInclude Include="Include\CmD3D9Driver.h" />
     <ClInclude Include="Include\CmD3D9DriverList.h" />
+    <ClInclude Include="Include\CmD3D9GenericBuffer.h" />
     <ClInclude Include="Include\CmD3D9GpuProgram.h" />
     <ClInclude Include="Include\CmD3D9GpuProgramManager.h" />
     <ClInclude Include="Include\CmD3D9HardwareBufferManager.h" />
@@ -185,6 +186,7 @@
     <ClCompile Include="Source\CmD3D9DeviceManager.cpp" />
     <ClCompile Include="Source\CmD3D9Driver.cpp" />
     <ClCompile Include="Source\CmD3D9DriverList.cpp" />
+    <ClCompile Include="Source\CmD3D9GenericBuffer.cpp" />
     <ClCompile Include="Source\CmD3D9GpuProgram.cpp" />
     <ClCompile Include="Source\CmD3D9GpuProgramManager.cpp" />
     <ClCompile Include="Source\CmD3D9HardwareBufferManager.cpp" />

CamelotD3D9Renderer/CamelotD3D9Renderer.vcxproj.filters

@@ -108,6 +108,9 @@
     <ClInclude Include="Include\CmD3D9MultiRenderTexture.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="Include\CmD3D9GenericBuffer.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Source\CmD3D9Device.cpp">
@@ -197,5 +200,8 @@
     <ClCompile Include="Source\CmD3D9MultiRenderTexture.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="Source\CmD3D9GenericBuffer.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

CamelotD3D9Renderer/Include/CmD3D9GenericBuffer.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#include "CmD3D9Prerequisites.h"
+#include "CmGenericBuffer.h"
+
+namespace CamelotEngine
+{
+	class CM_D3D9_EXPORT D3D9GenericBuffer : public GenericBuffer
+	{
+	public:
+		D3D9GenericBuffer(UINT32 elementCount, UINT32 elementSize, GenericBufferType type, GpuBufferUsage usage, bool randomGpuWrite = false, bool useCounter = false);
+        ~D3D9GenericBuffer();
+
+		/**
+		 * @copydoc GenericBuffer::lockImpl
+		 */
+		virtual void* lock(UINT32 offset, UINT32 length, GpuLockOptions options);
+
+		/**
+		 * @copydoc GenericBuffer::unlockImpl
+		 */
+		virtual void unlock();
+
+		/**
+		* @copydoc GenericBuffer::readData
+		*/
+        virtual void readData(UINT32 offset, UINT32 length, void* pDest);
+
+		/**
+		* @copydoc GenericBuffer::writeData
+		*/
+        virtual void writeData(UINT32 offset, UINT32 length, const void* pSource,
+				bool discardWholeBuffer = false);
+
+		/**
+		* @copydoc GenericBuffer::copyData
+		*/
+		void copyData(GenericBuffer& 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);
+	};
+}

CamelotD3D9Renderer/Include/CmD3D9HardwareBufferManager.h

@@ -60,6 +60,14 @@ namespace CamelotEngine {
 
 		/** @copydoc HardwareBufferManagerInterface::createGpuParamBlock */
 		GpuParamBlockPtr createGpuParamBlock(const GpuParamBlockDesc& paramDesc);
+
+		/**
+		 * @copydoc HardwareBufferManagerInterface::createGpuParamBlock
+		 *
+		 * DirectX 9 does not support generic buffers so this method will return a dummy instance.
+		 */
+		GenericBufferPtr createGenericBuffer(UINT32 elementCount, UINT32 elementSize, 
+			GenericBufferType type, GpuBufferUsage usage, bool randomGpuWrite = false, bool useCounter = false);
     };
 
 	/// D3D9HardwareBufferManagerBase as a Singleton

CamelotD3D9Renderer/Source/CmD3D9GenericBuffer.cpp

@@ -0,0 +1,47 @@
+#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/CmD3D9HardwareBufferManager.cpp

@@ -29,6 +29,7 @@ THE SOFTWARE.
 #include "CmD3D9HardwareVertexBuffer.h"
 #include "CmD3D9HardwareIndexBuffer.h"
 #include "CmD3D9VertexDeclaration.h"
+#include "CmD3D9GenericBuffer.h"
 #include "CmGpuParamBlock.h"
 #include "CmException.h"
 
@@ -75,6 +76,12 @@ namespace CamelotEngine {
 	{
 		return GpuParamBlockPtr(new GpuParamBlock(paramDesc));
 	}
+	//-----------------------------------------------------------------------
+	GenericBufferPtr D3D9HardwareBufferManagerBase::createGenericBuffer(UINT32 elementCount, UINT32 elementSize, 
+		GenericBufferType type, GpuBufferUsage usage, bool randomGpuWrite, bool useCounter)
+	{
+		return GenericBufferPtr(new D3D9GenericBuffer(elementCount, elementSize, type, usage, randomGpuWrite, useCounter));
+	}
     //-----------------------------------------------------------------------
     VertexDeclarationPtr D3D9HardwareBufferManagerBase::createVertexDeclarationImpl(void)
     {

CamelotGLRenderer/CamelotGLRenderer.vcxproj

@@ -150,6 +150,7 @@
     <ClInclude Include="Include\CmGLContext.h" />
     <ClInclude Include="Include\CmGLDepthStencilBuffer.h" />
     <ClInclude Include="Include\CmGLFrameBufferObject.h" />
+    <ClInclude Include="Include\CmGLGenericBuffer.h" />
     <ClInclude Include="Include\CmGLGpuParamBlock.h" />
     <ClInclude Include="Include\CmGLGpuProgramManager.h" />
     <ClInclude Include="Include\CmGLHardwareBufferManager.h" />
@@ -186,6 +187,7 @@
     <ClCompile Include="Source\CmGLContext.cpp" />
     <ClCompile Include="Source\CmGLDepthStencilBuffer.cpp" />
     <ClCompile Include="Source\CmGLFrameBufferObject.cpp" />
+    <ClCompile Include="Source\CmGLGenericBuffer.cpp" />
     <ClCompile Include="Source\CmGLGpuParamBlock.cpp" />
     <ClCompile Include="Source\CmGLGpuProgramManager.cpp" />
     <ClCompile Include="Source\CmGLHardwareBufferManager.cpp" />

CamelotGLRenderer/CamelotGLRenderer.vcxproj.filters

@@ -123,6 +123,9 @@
     <ClInclude Include="Source\GLSL\include\CmGLSLProgramPipelineManager.h">
       <Filter>GLSL</Filter>
     </ClInclude>
+    <ClInclude Include="Include\CmGLGenericBuffer.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Source\GLSL\src\CmGLSLExtSupport.cpp">
@@ -215,5 +218,8 @@
     <ClCompile Include="Source\GLSL\src\CmGLSLProgramPipelineManager.cpp">
       <Filter>GLSL</Filter>
     </ClCompile>
+    <ClCompile Include="Source\CmGLGenericBuffer.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

CamelotGLRenderer/Include/CmGLGenericBuffer.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#include "CmGLPrerequisites.h"
+#include "CmGenericBuffer.h"
+
+namespace CamelotEngine
+{
+	class CM_RSGL_EXPORT GLGenericBuffer : public GenericBuffer
+	{
+	public:
+		GLGenericBuffer(UINT32 elementCount, UINT32 elementSize, GenericBufferType type, GpuBufferUsage usage, bool randomGpuWrite = false, bool useCounter = false);
+        ~GLGenericBuffer();
+
+		/**
+		 * @copydoc GenericBuffer::lockImpl
+		 */
+		virtual void* lock(UINT32 offset, UINT32 length, GpuLockOptions options);
+
+		/**
+		 * @copydoc GenericBuffer::unlockImpl
+		 */
+		virtual void unlock();
+
+		/**
+		* @copydoc GenericBuffer::readData
+		*/
+        virtual void readData(UINT32 offset, UINT32 length, void* pDest);
+
+		/**
+		* @copydoc GenericBuffer::writeData
+		*/
+        virtual void writeData(UINT32 offset, UINT32 length, const void* pSource,
+				bool discardWholeBuffer = false);
+
+		/**
+		* @copydoc GenericBuffer::copyData
+		*/
+		void copyData(GenericBuffer& 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);
+	};
+}

CamelotGLRenderer/Include/CmGLHardwareBufferManager.h

@@ -65,6 +65,14 @@ namespace CamelotEngine {
 		/** @copydoc HardwareBufferManagerInterface::createGpuParamBlock */
 		GpuParamBlockPtr createGpuParamBlock(const GpuParamBlockDesc& paramDesc);
 
+		/**
+		 * @copydoc HardwareBufferManagerInterface::createGpuParamBlock
+		 *
+		 * 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);
+
         /// Utility function to get the correct GL usage based on HBU's
         static GLenum getGLUsage(unsigned int usage);
 

CamelotGLRenderer/Source/CmGLGenericBuffer.cpp

@@ -0,0 +1,47 @@
+#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/CmGLHardwareBufferManager.cpp

@@ -28,6 +28,7 @@ THE SOFTWARE.
 #include "CmGLHardwareBufferManager.h"
 #include "CmGLHardwareVertexBuffer.h"
 #include "CmGLHardwareIndexBuffer.h"
+#include "CmGLGenericBuffer.h"
 #include "CmHardwareBuffer.h"
 #include "CmGLGpuParamBlock.h"
 #include "CmRenderSystem.h"
@@ -109,6 +110,12 @@ namespace CamelotEngine {
 	{
 		return GpuParamBlockPtr(new GLGpuParamBlock(paramDesc));
 	}
+	//---------------------------------------------------------------------
+	GenericBufferPtr GLHardwareBufferManagerBase::createGenericBuffer(UINT32 elementCount, UINT32 elementSize, 
+		GenericBufferType type, GpuBufferUsage usage, bool randomGpuWrite, bool useCounter)
+	{
+		return GenericBufferPtr(new GLGenericBuffer(elementCount, elementSize, type, usage, randomGpuWrite, useCounter));
+	}
     //---------------------------------------------------------------------
     GLenum GLHardwareBufferManagerBase::getGLUsage(unsigned int usage)
     {

CamelotRenderer/Include/CmCommonEnums.h

@@ -236,6 +236,17 @@ namespace CamelotEngine {
 		GBU_DYNAMIC = 2,
 	};
 
+	/**
+	 * @brief	Types of generic GPU buffers that may be attached to GPU programs.
+	 */
+	enum GenericBufferType
+	{
+		GBT_STRUCTURED,
+		GBT_RAW,
+		GBT_INDIRECTARGUMENT,
+		GBT_APPENDCONSUME
+	};
+
 	/** Texture addressing mode for each texture coordinate. */
 	struct UVWAddressingMode
 	{

CamelotRenderer/Include/CmGenericBuffer.h

@@ -6,14 +6,6 @@
 
 namespace CamelotEngine 
 {
-	enum GenericBufferType
-	{
-		GBT_STRUCTURED,
-		GBT_RAW,
-		GBT_INDIRECTARGUMENT,
-		GBT_APPENDCONSUME
-	};
-
 	class CM_EXPORT GenericBuffer
     {
     public:

CamelotRenderer/Include/CmHardwareBufferManager.h

@@ -132,6 +132,21 @@ namespace CamelotEngine {
 		 */
 		virtual GpuParamBlockPtr createGpuParamBlock(const GpuParamBlockDesc& paramDesc) = 0;
 
+		/**
+		 * @brief	Creates a generic buffer that can be passed as a parameter to a shader.
+		 *
+		 * @param	elementCount  	Number of elements in the buffer. 
+		 * @param	elementSize   	Size of each individual element in the buffer, in bytes.
+		 * @param	type		  	Type of the buffer.
+		 * @param	usage		  	Determines how will the buffer be used.
+		 * @param	randomGpuWrite	(optional) Allows the GPU to write to the resource.
+		 * @param	useCounter	  	(optional) Binds a counter that can be used from a shader to the buffer.
+		 *
+		 * 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;
+
         /** Creates a new vertex declaration. */
         virtual VertexDeclarationPtr createVertexDeclaration(void);
 
@@ -172,6 +187,13 @@ namespace CamelotEngine {
 			return mImpl->createGpuParamBlock(paramDesc);
 		}
 
+		/** @copydoc HardwareBufferManagerInterface::createGenericBuffer */
+		GenericBufferPtr createGenericBuffer(UINT32 elementCount, UINT32 elementSize, 
+			GenericBufferType type, GpuBufferUsage usage, bool randomGpuWrite = false, bool useCounter = false)
+		{
+			return mImpl->createGenericBuffer(elementCount, elementSize, type, usage, randomGpuWrite, useCounter);
+		}
+
 		/** @copydoc HardwareBufferManagerInterface::createVertexDeclaration */
 		virtual VertexDeclarationPtr createVertexDeclaration(void)
 		{

CamelotRenderer/Include/CmPrerequisites.h

@@ -73,6 +73,7 @@ namespace CamelotEngine {
     class HardwareOcclusionQuery;
     class HardwareVertexBuffer;
 	class HardwarePixelBuffer;
+	class GenericBuffer;
 	class HighLevelGpuProgram;
 	class HighLevelGpuProgramManager;
 	class HighLevelGpuProgramFactory;
@@ -146,6 +147,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<GenericBuffer> GenericBufferPtr;
 	typedef std::shared_ptr<VertexDeclaration> VertexDeclarationPtr;
 	typedef std::shared_ptr<Mesh> MeshPtr;
 	typedef std::shared_ptr<Texture> TexturePtr;