Renamed GpuParamBlock to GpuParamBlockBuffer

CamelotD3D11RenderSystem/Include/CmD3D11GpuParamBlock.h

@@ -5,7 +5,7 @@
 
 namespace CamelotEngine
 {
-	class CM_D3D11_EXPORT D3D11GpuParamBlock : public GpuParamBlock
+	class CM_D3D11_EXPORT D3D11GpuParamBlock : public GpuParamBlockBuffer
 	{
 	private:
 		struct D3D11GpuParamBlockSharedData
@@ -18,7 +18,7 @@ namespace CamelotEngine
 		~D3D11GpuParamBlock();
 
 		virtual void updateIfDirty();
-		virtual GpuParamBlockPtr clone() const;
+		virtual GpuParamBlockBufferPtr clone() const;
 
 		ID3D11Buffer* getD3D11Buffer() const;
 

CamelotD3D11RenderSystem/Include/CmD3D11HardwareBufferManager.h

@@ -21,11 +21,11 @@ namespace CamelotEngine
 		 */
 		IndexBufferPtr createIndexBuffer(IndexBuffer::IndexType itype, UINT32 numIndexes, GpuBufferUsage usage);
 
-		/** @copydoc HardwareBufferManagerInterface::createGpuParamBlock */
-		GpuParamBlockPtr createGpuParamBlock(const GpuParamBlockDesc& paramDesc);
+		/** @copydoc HardwareBufferManagerInterface::createGpuParamBlockBuffer */
+		GpuParamBlockBufferPtr createGpuParamBlockBuffer(const GpuParamBlockDesc& paramDesc);
 
 		/**
-		 * @copydoc HardwareBufferManagerInterface::createGpuParamBlock
+		 * @copydoc HardwareBufferManagerInterface::createGpuBuffer
 		 *
 		 * Some limitations are imposed on the combinations of parameters:
 		 *  - APPENDCONSUME buffer type can only be used with randomGpuWrite enabled  

CamelotD3D11RenderSystem/Source/CmD3D11GpuParamBlock.cpp

@@ -6,7 +6,7 @@
 namespace CamelotEngine
 {
 	D3D11GpuParamBlock::D3D11GpuParamBlock(const GpuParamBlockDesc& desc)
-		:GpuParamBlock(desc), mD3D11SharedData(nullptr)
+		:GpuParamBlockBuffer(desc), mD3D11SharedData(nullptr)
 	{
 		mD3D11SharedData = new D3D11GpuParamBlockSharedData();
 	}
@@ -37,10 +37,10 @@ namespace CamelotEngine
 			mD3D11SharedData->mBuffer->writeData(0, mSize, mData, true);
 		}
 
-		GpuParamBlock::updateIfDirty();
+		GpuParamBlockBuffer::updateIfDirty();
 	}
 
-	GpuParamBlockPtr D3D11GpuParamBlock::clone() const
+	GpuParamBlockBufferPtr D3D11GpuParamBlock::clone() const
 	{
 		std::shared_ptr<D3D11GpuParamBlock> clonedParamBlock(new D3D11GpuParamBlock(*this));
 		clonedParamBlock->mData = new UINT8[mSize];

CamelotD3D11RenderSystem/Source/CmD3D11HardwareBufferManager.cpp

@@ -44,9 +44,9 @@ namespace CamelotEngine
 		return IndexBufferPtr(idx);
 	}
 
-	GpuParamBlockPtr D3D11HardwareBufferManager::createGpuParamBlock(const GpuParamBlockDesc& blockDesc)
+	GpuParamBlockBufferPtr D3D11HardwareBufferManager::createGpuParamBlockBuffer(const GpuParamBlockDesc& blockDesc)
 	{
-		return GpuParamBlockPtr(new D3D11GpuParamBlock(blockDesc));
+		return GpuParamBlockBufferPtr(new D3D11GpuParamBlock(blockDesc));
 	}
 
 	GpuBufferPtr D3D11HardwareBufferManager::createGpuBuffer(UINT32 elementCount, UINT32 elementSize, 

CamelotD3D11RenderSystem/Source/CmD3D11RenderSystem.cpp

@@ -464,7 +464,7 @@ namespace CamelotEngine
 
 		for(auto iter = paramDesc.paramBlocks.begin(); iter != paramDesc.paramBlocks.end(); ++iter)
 		{
-			GpuParamBlockPtr currentBlock = params->getParamBlock(iter->second.slot);
+			GpuParamBlockBufferPtr currentBlock = params->getParamBlock(iter->second.slot);
 
 			if(currentBlock != nullptr)
 			{

CamelotD3D9Renderer/Include/CmD3D9HardwareBufferManager.h

@@ -56,8 +56,8 @@ namespace CamelotEngine {
 		 */
 		IndexBufferPtr createIndexBuffer(IndexBuffer::IndexType itype, UINT32 numIndexes, GpuBufferUsage usage);
 
-		/** @copydoc HardwareBufferManager::createGpuParamBlock */
-		GpuParamBlockPtr createGpuParamBlock(const GpuParamBlockDesc& paramDesc);
+		/** @copydoc HardwareBufferManager::createGpuParamBlockBuffer */
+		GpuParamBlockBufferPtr createGpuParamBlockBuffer(const GpuParamBlockDesc& paramDesc);
 
 		/**
 		 * @copydoc HardwareBufferManager::createGenericBuffer

CamelotD3D9Renderer/Source/CmD3D9HardwareBufferManager.cpp

@@ -67,9 +67,9 @@ namespace CamelotEngine {
             
     }
 	//-----------------------------------------------------------------------
-	GpuParamBlockPtr D3D9HardwareBufferManager::createGpuParamBlock(const GpuParamBlockDesc& paramDesc)
+	GpuParamBlockBufferPtr D3D9HardwareBufferManager::createGpuParamBlockBuffer(const GpuParamBlockDesc& paramDesc)
 	{
-		return GpuParamBlockPtr(new GpuParamBlock(paramDesc));
+		return GpuParamBlockBufferPtr(new GpuParamBlockBuffer(paramDesc));
 	}
 	//-----------------------------------------------------------------------
 	GpuBufferPtr D3D9HardwareBufferManager::createGpuBuffer(UINT32 elementCount, UINT32 elementSize, 

CamelotD3D9Renderer/Source/CmD3D9RenderSystem.cpp

@@ -361,7 +361,7 @@ namespace CamelotEngine
 				{
 					const GpuParamMemberDesc& paramDesc = iter->second;
 
-					GpuParamBlockPtr paramBlock = params->getParamBlock(paramDesc.paramBlockSlot);
+					GpuParamBlockBufferPtr paramBlock = params->getParamBlock(paramDesc.paramBlockSlot);
 					const UINT8* ptrData = paramBlock->getDataPtr(paramDesc.cpuMemOffset * sizeof(UINT32));
 
 					switch(paramDesc.type)
@@ -413,7 +413,7 @@ namespace CamelotEngine
 				{
 					const GpuParamMemberDesc& paramDesc = iter->second;
 
-					GpuParamBlockPtr paramBlock = params->getParamBlock(paramDesc.paramBlockSlot);
+					GpuParamBlockBufferPtr paramBlock = params->getParamBlock(paramDesc.paramBlockSlot);
 					const UINT8* ptrData = paramBlock->getDataPtr(paramDesc.cpuMemOffset * sizeof(UINT32));
 
 					switch(paramDesc.type)

CamelotGLRenderer/Include/CmGLGpuParamBlock.h

@@ -5,7 +5,7 @@
 
 namespace CamelotEngine
 {
-	class CM_RSGL_EXPORT GLGpuParamBlock : public GpuParamBlock
+	class CM_RSGL_EXPORT GLGpuParamBlock : public GpuParamBlockBuffer
 	{
 	private:
 		struct GLGpuParamBlockSharedData
@@ -18,7 +18,7 @@ namespace CamelotEngine
 		~GLGpuParamBlock();
 
 		virtual void updateIfDirty();
-		virtual GpuParamBlockPtr clone() const;
+		virtual GpuParamBlockBufferPtr clone() const;
 
 		GLuint getGLHandle() const { return mGLSharedData->mGLHandle; }
 

CamelotGLRenderer/Include/CmGLHardwareBufferManager.h

@@ -62,8 +62,8 @@ namespace CamelotEngine {
             IndexBuffer::IndexType itype, UINT32 numIndexes, 
             GpuBufferUsage usage);
 
-		/** @copydoc HardwareBufferManager::createGpuParamBlock */
-		GpuParamBlockPtr createGpuParamBlock(const GpuParamBlockDesc& paramDesc);
+		/** @copydoc HardwareBufferManager::createGpuParamBlockBuffer */
+		GpuParamBlockBufferPtr createGpuParamBlockBuffer(const GpuParamBlockDesc& paramDesc);
 
 		/**
 		 * @copydoc HardwareBufferManager::createGenericBuffer

CamelotGLRenderer/Source/CmGLGpuParamBlock.cpp

@@ -3,7 +3,7 @@
 namespace CamelotEngine
 {
 	GLGpuParamBlock::GLGpuParamBlock(const GpuParamBlockDesc& desc)
-		:GpuParamBlock(desc), mGLSharedData(nullptr)
+		:GpuParamBlockBuffer(desc), mGLSharedData(nullptr)
 	{
 		mGLSharedData = new GLGpuParamBlockSharedData();
 	}
@@ -36,10 +36,10 @@ namespace CamelotEngine
 			glBindBuffer(GL_UNIFORM_BUFFER, 0);
 		}
 
-		GpuParamBlock::updateIfDirty();
+		GpuParamBlockBuffer::updateIfDirty();
 	}
 
-	GpuParamBlockPtr GLGpuParamBlock::clone() const
+	GpuParamBlockBufferPtr GLGpuParamBlock::clone() const
 	{
 		std::shared_ptr<GLGpuParamBlock> clonedParamBlock(new GLGpuParamBlock(*this));
 		clonedParamBlock->mData = new UINT8[mSize];

CamelotGLRenderer/Source/CmGLHardwareBufferManager.cpp

@@ -104,9 +104,9 @@ namespace CamelotEngine {
 		return IndexBufferPtr(buf);
     }
 	//---------------------------------------------------------------------
-	GpuParamBlockPtr GLHardwareBufferManager::createGpuParamBlock(const GpuParamBlockDesc& paramDesc)
+	GpuParamBlockBufferPtr GLHardwareBufferManager::createGpuParamBlockBuffer(const GpuParamBlockDesc& paramDesc)
 	{
-		return GpuParamBlockPtr(new GLGpuParamBlock(paramDesc));
+		return GpuParamBlockBufferPtr(new GLGpuParamBlock(paramDesc));
 	}
 	//---------------------------------------------------------------------
 	GpuBufferPtr GLHardwareBufferManager::createGpuBuffer(UINT32 elementCount, UINT32 elementSize, 

CamelotGLRenderer/Source/CmGLRenderSystem.cpp

@@ -341,7 +341,7 @@ namespace CamelotEngine
 			if(iter->second.slot == 0)
 				continue;
 
-			GpuParamBlockPtr paramBlock = params->getParamBlock(iter->second.slot);
+			GpuParamBlockBufferPtr paramBlock = params->getParamBlock(iter->second.slot);
 			if(paramBlock == nullptr)
 				continue;
 
@@ -358,7 +358,7 @@ namespace CamelotEngine
 		{
 			const GpuParamMemberDesc& paramDesc = iter->second;
 
-			GpuParamBlockPtr paramBlock = params->getParamBlock(paramDesc.paramBlockSlot);
+			GpuParamBlockBufferPtr paramBlock = params->getParamBlock(paramDesc.paramBlockSlot);
 			
 			if(paramDesc.paramBlockSlot != 0) // 0 means uniforms are not in a block
 				continue;

CamelotRenderer/Include/CmGpuParamBlock.h

@@ -4,7 +4,7 @@
 
 namespace CamelotEngine
 {
-	class CM_EXPORT GpuParamBlock
+	class CM_EXPORT GpuParamBlockBuffer
 	{
 	private:
 		struct GpuParamBlockSharedData
@@ -14,8 +14,8 @@ namespace CamelotEngine
 		};
 
 	public:
-		GpuParamBlock(const GpuParamBlockDesc& desc);
-		virtual ~GpuParamBlock();
+		GpuParamBlockBuffer(const GpuParamBlockDesc& desc);
+		virtual ~GpuParamBlockBuffer();
 
 		void write(UINT32 offset, const void* data, UINT32 size);
 		void zeroOut(UINT32 offset, UINT32 size);
@@ -25,9 +25,9 @@ namespace CamelotEngine
 
 		virtual void updateIfDirty();
 
-		virtual GpuParamBlockPtr clone() const;
+		virtual GpuParamBlockBufferPtr clone() const;
 		
-		static GpuParamBlockPtr create(const GpuParamBlockDesc& desc);
+		static GpuParamBlockBufferPtr create(const GpuParamBlockDesc& desc);
 	protected:
 		GpuParamBlockSharedData* sharedData;
 		bool mOwnsSharedData;

CamelotRenderer/Include/CmGpuParams.h

@@ -9,11 +9,11 @@ namespace CamelotEngine
 	public:
 		GpuParams(GpuParamDesc& paramDesc);
 
-		GpuParamBlockPtr getParamBlock(UINT32 slot) const;
-		GpuParamBlockPtr getParamBlock(const String& name) const;
+		GpuParamBlockBufferPtr getParamBlock(UINT32 slot) const;
+		GpuParamBlockBufferPtr getParamBlock(const String& name) const;
 
-		void setParamBlock(UINT32 slot, GpuParamBlockPtr paramBlock);
-		void setParamBlock(const String& name, GpuParamBlockPtr paramBlock);
+		void setParamBlock(UINT32 slot, GpuParamBlockBufferPtr paramBlock);
+		void setParamBlock(const String& name, GpuParamBlockBufferPtr paramBlock);
 
 		const GpuParamDesc& getParamDesc() const { return mParamDesc; }
 
@@ -59,7 +59,7 @@ namespace CamelotEngine
 
 		GpuParamMemberDesc* getParamDesc(const String& name) const;
 
-		vector<GpuParamBlockPtr>::type mParamBlocks;
+		vector<GpuParamBlockBufferPtr>::type mParamBlocks;
 		vector<TextureHandle>::type mTextures;
 		vector<SamplerStatePtr>::type mSamplerStates;
 	};

CamelotRenderer/Include/CmHardwareBufferManager.h

@@ -109,7 +109,7 @@ namespace CamelotEngine {
 		 *
 		 * @return	The new GPU parameter block.
 		 */
-		virtual GpuParamBlockPtr createGpuParamBlock(const GpuParamBlockDesc& paramDesc) = 0;
+		virtual GpuParamBlockBufferPtr createGpuParamBlockBuffer(const GpuParamBlockDesc& paramDesc) = 0;
 
 		/**
 		 * @brief	Creates a generic buffer that can be passed as a parameter to a shader.

CamelotRenderer/Include/CmPrerequisites.h

@@ -135,7 +135,7 @@ namespace CamelotEngine {
 	class RenderStateManager;
 	class RasterizerState;
 	class BlendState;
-	class GpuParamBlock;
+	class GpuParamBlockBuffer;
 	class GpuParams;
 	struct GpuParamDesc;
 	struct GpuParamMemberDesc;
@@ -197,7 +197,7 @@ namespace CamelotEngine
 	typedef std::shared_ptr<RenderTarget> RenderTargetPtr;
 	typedef std::shared_ptr<RenderTexture> RenderTexturePtr;
 	typedef std::shared_ptr<MultiRenderTexture> MultiRenderTexturePtr;
-	typedef std::shared_ptr<GpuParamBlock> GpuParamBlockPtr;
+	typedef std::shared_ptr<GpuParamBlockBuffer> GpuParamBlockBufferPtr;
 	typedef std::shared_ptr<GpuParams> GpuParamsPtr;
 	typedef std::shared_ptr<TextureView> TextureViewPtr;
 }

CamelotRenderer/Source/CmGpuParamBlock.cpp

@@ -5,7 +5,7 @@
 
 namespace CamelotEngine
 {
-	GpuParamBlock::GpuParamBlock(const GpuParamBlockDesc& desc)
+	GpuParamBlockBuffer::GpuParamBlockBuffer(const GpuParamBlockDesc& desc)
 		:mSize(desc.blockSize * sizeof(UINT32)), mOwnsSharedData(true)
 	{
 		mData = new UINT8[mSize];
@@ -16,7 +16,7 @@ namespace CamelotEngine
 		sharedData->mInitialized = false;
 	}
 
-	GpuParamBlock::~GpuParamBlock()
+	GpuParamBlockBuffer::~GpuParamBlockBuffer()
 	{
 		delete [] mData;
 
@@ -24,7 +24,7 @@ namespace CamelotEngine
 			delete sharedData;
 	}
 
-	void GpuParamBlock::write(UINT32 offset, const void* data, UINT32 size)
+	void GpuParamBlockBuffer::write(UINT32 offset, const void* data, UINT32 size)
 	{
 #if CM_DEBUG_MODE
 		if(offset < 0 || (offset + size) > mSize)
@@ -40,7 +40,7 @@ namespace CamelotEngine
 		sharedData->mDirty = true;
 	}
 
-	void GpuParamBlock::zeroOut(UINT32 offset, UINT32 size)
+	void GpuParamBlockBuffer::zeroOut(UINT32 offset, UINT32 size)
 	{
 #if CM_DEBUG_MODE
 		if(offset < 0 || (offset + size) > mSize)
@@ -56,7 +56,7 @@ namespace CamelotEngine
 		sharedData->mDirty = true;
 	}
 
-	const UINT8* GpuParamBlock::getDataPtr(UINT32 offset) const
+	const UINT8* GpuParamBlockBuffer::getDataPtr(UINT32 offset) const
 	{
 #if CM_DEBUG_MODE
 		if(offset < 0 || offset >= mSize)
@@ -70,16 +70,16 @@ namespace CamelotEngine
 		return &mData[offset];
 	}
 
-	void GpuParamBlock::updateIfDirty()
+	void GpuParamBlockBuffer::updateIfDirty()
 	{
 		sharedData->mDirty = false;
 
 		// Do nothing
 	}
 
-	GpuParamBlockPtr GpuParamBlock::clone() const
+	GpuParamBlockBufferPtr GpuParamBlockBuffer::clone() const
 	{
-		GpuParamBlockPtr clonedParamBlock(new GpuParamBlock(*this));
+		GpuParamBlockBufferPtr clonedParamBlock(new GpuParamBlockBuffer(*this));
 		clonedParamBlock->mData = new UINT8[mSize];
 		clonedParamBlock->mSize = mSize;
 		clonedParamBlock->mOwnsSharedData = false;
@@ -88,8 +88,8 @@ namespace CamelotEngine
 		return clonedParamBlock;
 	}
 
-	GpuParamBlockPtr GpuParamBlock::create(const GpuParamBlockDesc& desc)
+	GpuParamBlockBufferPtr GpuParamBlockBuffer::create(const GpuParamBlockDesc& desc)
 	{
-		return HardwareBufferManager::instance().createGpuParamBlock(desc);
+		return HardwareBufferManager::instance().createGpuParamBlockBuffer(desc);
 	}
 }

CamelotRenderer/Source/CmGpuParams.cpp

@@ -21,7 +21,7 @@ namespace CamelotEngine
 
 		for(auto iter = mParamDesc.paramBlocks.begin(); iter != mParamDesc.paramBlocks.end(); ++iter)
 		{
-			mParamBlocks[iter->second.slot] = GpuParamBlock::create(iter->second);
+			mParamBlocks[iter->second.slot] = GpuParamBlockBuffer::create(iter->second);
 		}
 
 		UINT32 numTextureSlots = 0;
@@ -43,7 +43,7 @@ namespace CamelotEngine
 		mSamplerStates.resize(numSamplerSlots);
 	}
 
-	GpuParamBlockPtr GpuParams::getParamBlock(UINT32 slot) const
+	GpuParamBlockBufferPtr GpuParams::getParamBlock(UINT32 slot) const
 	{
 		if(slot < 0 || slot >= (UINT32)mParamBlocks.size())
 		{
@@ -54,7 +54,7 @@ namespace CamelotEngine
 		return mParamBlocks[slot];
 	}
 
-	GpuParamBlockPtr GpuParams::getParamBlock(const String& name) const
+	GpuParamBlockBufferPtr GpuParams::getParamBlock(const String& name) const
 	{
 		auto iterFind = mParamDesc.paramBlocks.find(name);
 
@@ -67,7 +67,7 @@ namespace CamelotEngine
 		return mParamBlocks[iterFind->second.slot];
 	}
 
-	void GpuParams::setParamBlock(UINT32 slot, GpuParamBlockPtr paramBlock)
+	void GpuParams::setParamBlock(UINT32 slot, GpuParamBlockBufferPtr paramBlock)
 	{
 		if(slot < 0 || slot >= (UINT32)mParamBlocks.size())
 		{
@@ -78,7 +78,7 @@ namespace CamelotEngine
 		mParamBlocks[slot] = paramBlock;
 	}
 
-	void GpuParams::setParamBlock(const String& name, GpuParamBlockPtr paramBlock)
+	void GpuParams::setParamBlock(const String& name, GpuParamBlockBufferPtr paramBlock)
 	{
 		auto iterFind = mParamDesc.paramBlocks.find(name);
 
@@ -198,7 +198,7 @@ namespace CamelotEngine
 				toString(elementSizeBytes) + ". Supplied size: " + toString(sizeBytes));
 		}
 
-		GpuParamBlockPtr paramBlock = mParamBlocks[desc->paramBlockSlot];
+		GpuParamBlockBufferPtr paramBlock = mParamBlocks[desc->paramBlockSlot];
 
 		if(paramBlock == nullptr)
 		{