Added HLSL and RenderSystem factories

CamelotD3D11RenderSystem/CamelotD3D11RenderSystem.vcxproj

@@ -157,10 +157,12 @@
     <ClInclude Include="Include\CmD3D11HardwareBuffer.h" />
     <ClInclude Include="Include\CmD3D11HLSLProgram.h" />
     <ClInclude Include="Include\CmD3D11HardwareIndexBuffer.h" />
+    <ClInclude Include="Include\CmD3D11HLSLProgramFactory.h" />
     <ClInclude Include="Include\CmD3D11Mappings.h" />
     <ClInclude Include="Include\CmD3D11Prerequisites.h" />
     <ClInclude Include="Include\CmD3D11HardwareVertexBuffer.h" />
     <ClInclude Include="Include\CmD3D11RenderSystem.h" />
+    <ClInclude Include="Include\CmD3D11RenderSystemFactory.h" />
     <ClInclude Include="Include\CmD3D11RenderTexture.h" />
     <ClInclude Include="Include\CmD3D11RenderWindow.h" />
     <ClInclude Include="Include\CmD3D11Texture.h" />
@@ -181,9 +183,11 @@
     <ClCompile Include="Source\CmD3D11HardwareConstantBuffer.cpp" />
     <ClCompile Include="Source\CmD3D11HLSLProgram.cpp" />
     <ClCompile Include="Source\CmD3D11HardwareIndexBuffer.cpp" />
+    <ClCompile Include="Source\CmD3D11HLSLProgramFactory.cpp" />
     <ClCompile Include="Source\CmD3D11Mappings.cpp" />
     <ClCompile Include="Source\CmD3D11HardwareVertexBuffer.cpp" />
     <ClCompile Include="Source\CmD3D11RenderSystem.cpp" />
+    <ClCompile Include="Source\CmD3D11RenderSystemFactory.cpp" />
     <ClCompile Include="Source\CmD3D11RenderTexture.cpp" />
     <ClCompile Include="Source\CmD3D11RenderWindow.cpp" />
     <ClCompile Include="Source\CmD3D11Texture.cpp" />

CamelotD3D11RenderSystem/CamelotD3D11RenderSystem.vcxproj.filters

@@ -81,6 +81,12 @@
     <ClInclude Include="Include\CmD3D11DepthStencilBuffer.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="Include\CmD3D11HLSLProgramFactory.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\CmD3D11RenderSystemFactory.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Source\CmD3D11GpuProgram.cpp">
@@ -146,5 +152,11 @@
     <ClCompile Include="Source\CmD3D11DepthStencilBuffer.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="Source\CmD3D11HLSLProgramFactory.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Source\CmD3D11RenderSystemFactory.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

CamelotD3D11RenderSystem/Include/CmD3D11HLSLProgramFactory.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "CmD3D11Prerequisites.h"
+#include "CmHighLevelGpuProgramManager.h"
+
+namespace CamelotEngine
+{
+	class CM_D3D11_EXPORT D3D11HLSLProgramFactory : public HighLevelGpuProgramFactory
+	{
+	protected:
+		static String sLanguageName;
+	public:
+		D3D11HLSLProgramFactory();
+		~D3D11HLSLProgramFactory();
+
+		const String& getLanguage(void) const;
+		HighLevelGpuProgram* create(const String& source, const String& entryPoint, GpuProgramType gptype, GpuProgramProfile profile);
+		HighLevelGpuProgram* create();
+		void destroy_internal(HighLevelGpuProgram* prog);
+	};
+}

CamelotD3D11RenderSystem/Include/CmD3D11RenderSystem.h

@@ -8,11 +8,50 @@ namespace CamelotEngine
 	class CM_D3D11_EXPORT D3D11RenderSystem : public RenderSystem
 	{
 	public:
-		
 		static D3D11Device& getPrimaryDevice();
 
 		void determineFSAASettings(UINT32 fsaa, const String& fsaaHint, DXGI_FORMAT format, DXGI_SAMPLE_DESC* outFSAASettings);
 		bool checkTextureFilteringSupported(TextureType ttype, PixelFormat format, int usage);
+
+		virtual const String& getName() const;
+
+		virtual void setSamplerState(UINT16 texUnit, const SamplerState& samplerState);
+		virtual void setBlendState(const BlendState& blendState);
+		virtual void setRasterizerState(const RasterizerState& rasterizerState);
+		virtual void setDepthStencilState(const DepthStencilState& depthStencilState);
+
+		virtual void setTexture(UINT16 unit, bool enabled, const TexturePtr &texPtr );
+
+		virtual void setStencilRefValue(UINT32 refValue);
+
+		virtual void beginFrame();
+		virtual void endFrame();
+		virtual void clearFrameBuffer(unsigned int buffers, const Color& color = Color::Black, float depth = 1.0f, unsigned short stencil = 0);
+
+		virtual void setRenderTarget(RenderTarget* target);
+		virtual void setViewport(const Viewport& vp);
+		virtual void setScissorRect(UINT32 left = 0, UINT32 top = 0, UINT32 right = 800, UINT32 bottom = 600);
+
+		virtual void setVertexDeclaration(VertexDeclarationPtr decl);
+		virtual void setVertexBufferBinding(VertexBufferBinding* binding);
+
+		virtual void bindGpuProgramParameters(GpuProgramType gptype, GpuProgramParametersSharedPtr params, UINT16 variabilityMask);
+
+		
+		virtual void setClipPlanesImpl(const PlaneList& clipPlanes);
+
+		virtual RenderSystemCapabilities* createRenderSystemCapabilities() const;
+		virtual void initialiseFromRenderSystemCapabilities(RenderSystemCapabilities* caps);
+
+		virtual String getErrorDescription(long errorNumber) const;
+
+		virtual void convertProjectionMatrix(const Matrix4& matrix, Matrix4& dest, bool forGpuProgram = false);
+		virtual VertexElementType getColorVertexElementType() const;
+		virtual float getHorizontalTexelOffset();
+		virtual float getVerticalTexelOffset();
+		virtual float getMinimumDepthInputValue();
+		virtual float getMaximumDepthInputValue();
+
 	protected:
 
 	private:

CamelotD3D11RenderSystem/Include/CmD3D11RenderSystemFactory.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <string>
+#include "CmRenderSystemFactory.h"
+#include "CmRenderSystemManager.h"
+#include "CmD3D11RenderSystem.h"
+
+namespace CamelotEngine
+{
+	const std::string SystemName = "D3D11RenderSystem";
+
+	class D3D11RenderSystemFactory : public RenderSystemFactory
+	{
+	public:
+		virtual void create();
+		virtual const std::string& name() const { return SystemName; }
+
+	private:
+		class InitOnStart
+		{
+		public:
+			InitOnStart() 
+			{ 
+				static RenderSystemFactoryPtr newFactory;
+				if(newFactory == nullptr)
+				{
+					newFactory = RenderSystemFactoryPtr(new D3D11RenderSystemFactory());
+					RenderSystemManager::registerRenderSystemFactory(newFactory);
+				}
+			}
+		};
+
+		static InitOnStart initOnStart; // Makes sure factory is registered on program start
+	};
+}

CamelotD3D11RenderSystem/Source/CmD3D11HLSLProgramFactory.cpp

@@ -0,0 +1,39 @@
+#include "CmD3D11HLSLProgramFactory.h"
+#include "CmD3D11HLSLProgram.h"
+
+namespace CamelotEngine
+{
+    String D3D11HLSLProgramFactory::sLanguageName = "hlsl";
+
+    D3D11HLSLProgramFactory::D3D11HLSLProgramFactory()
+    {
+    }
+
+    D3D11HLSLProgramFactory::~D3D11HLSLProgramFactory()
+    {
+    }
+
+    const String& D3D11HLSLProgramFactory::getLanguage(void) const
+    {
+        return sLanguageName;
+    }
+
+	HighLevelGpuProgram* D3D11HLSLProgramFactory::create(const String& source, const String& entryPoint, GpuProgramType gptype, GpuProgramProfile profile)
+    {
+		D3D11HLSLProgram* prog = new D3D11HLSLProgram(source, entryPoint, sLanguageName, gptype, profile);
+
+        return prog;
+    }
+
+	HighLevelGpuProgram* D3D11HLSLProgramFactory::create()
+	{
+		D3D11HLSLProgram* prog = new D3D11HLSLProgram("", "", sLanguageName, GPT_VERTEX_PROGRAM, GPP_NONE);
+
+		return prog;
+	}
+
+	void D3D11HLSLProgramFactory::destroy_internal(HighLevelGpuProgram* prog)
+    {
+        delete prog;
+    }
+}

CamelotD3D11RenderSystem/Source/CmD3D11RenderSystem.cpp

@@ -122,4 +122,134 @@ namespace CamelotEngine
 	{
 		return true;
 	}
+
+	const String& D3D11RenderSystem::getName() const
+	{
+		throw std::exception("The method or operation is not implemented.");
+	}
+
+	void D3D11RenderSystem::setSamplerState(UINT16 texUnit, const SamplerState& samplerState)
+	{
+		throw std::exception("The method or operation is not implemented.");
+	}
+
+	void D3D11RenderSystem::setBlendState(const BlendState& blendState)
+	{
+		throw std::exception("The method or operation is not implemented.");
+	}
+
+	void D3D11RenderSystem::setRasterizerState(const RasterizerState& rasterizerState)
+	{
+		throw std::exception("The method or operation is not implemented.");
+	}
+
+	void D3D11RenderSystem::setDepthStencilState(const DepthStencilState& depthStencilState)
+	{
+		throw std::exception("The method or operation is not implemented.");
+	}
+
+	void D3D11RenderSystem::setStencilRefValue(UINT32 refValue)
+	{
+		throw std::exception("The method or operation is not implemented.");
+	}
+
+	void D3D11RenderSystem::setTexture(UINT16 unit, bool enabled, const TexturePtr &texPtr)
+	{
+		throw std::exception("The method or operation is not implemented.");
+	}
+
+	void D3D11RenderSystem::beginFrame()
+	{
+		throw std::exception("The method or operation is not implemented.");
+	}
+
+	void D3D11RenderSystem::endFrame()
+	{
+		throw std::exception("The method or operation is not implemented.");
+	}
+
+	void D3D11RenderSystem::setViewport(const Viewport& vp)
+	{
+		throw std::exception("The method or operation is not implemented.");
+	}
+
+	void D3D11RenderSystem::setVertexDeclaration(VertexDeclarationPtr decl)
+	{
+		throw std::exception("The method or operation is not implemented.");
+	}
+
+	void D3D11RenderSystem::setVertexBufferBinding(VertexBufferBinding* binding)
+	{
+		throw std::exception("The method or operation is not implemented.");
+	}
+
+	void D3D11RenderSystem::bindGpuProgramParameters(GpuProgramType gptype, GpuProgramParametersSharedPtr params, UINT16 variabilityMask)
+	{
+		throw std::exception("The method or operation is not implemented.");
+	}
+
+	void D3D11RenderSystem::setScissorRect(UINT32 left /*= 0*/, UINT32 top /*= 0*/, UINT32 right /*= 800*/, UINT32 bottom /*= 600 */)
+	{
+		throw std::exception("The method or operation is not implemented.");
+	}
+
+	void D3D11RenderSystem::clearFrameBuffer(unsigned int buffers, const Color& color /*= Color::Black*/, float depth /*= 1.0f*/, unsigned short stencil /*= 0 */)
+	{
+		throw std::exception("The method or operation is not implemented.");
+	}
+
+	void D3D11RenderSystem::setRenderTarget(RenderTarget* target)
+	{
+		throw std::exception("The method or operation is not implemented.");
+	}
+
+	CamelotEngine::VertexElementType D3D11RenderSystem::getColorVertexElementType() const
+	{
+		throw std::exception("The method or operation is not implemented.");
+	}
+
+	void D3D11RenderSystem::convertProjectionMatrix(const Matrix4& matrix, Matrix4& dest, bool forGpuProgram /*= false */)
+	{
+		throw std::exception("The method or operation is not implemented.");
+	}
+
+	float D3D11RenderSystem::getHorizontalTexelOffset()
+	{
+		throw std::exception("The method or operation is not implemented.");
+	}
+
+	float D3D11RenderSystem::getVerticalTexelOffset()
+	{
+		throw std::exception("The method or operation is not implemented.");
+	}
+
+	float D3D11RenderSystem::getMinimumDepthInputValue()
+	{
+		throw std::exception("The method or operation is not implemented.");
+	}
+
+	float D3D11RenderSystem::getMaximumDepthInputValue()
+	{
+		throw std::exception("The method or operation is not implemented.");
+	}
+
+	void D3D11RenderSystem::setClipPlanesImpl(const PlaneList& clipPlanes)
+	{
+		throw std::exception("The method or operation is not implemented.");
+	}
+
+	RenderSystemCapabilities* D3D11RenderSystem::createRenderSystemCapabilities() const
+	{
+		throw std::exception("The method or operation is not implemented.");
+	}
+
+	void D3D11RenderSystem::initialiseFromRenderSystemCapabilities(RenderSystemCapabilities* caps)
+	{
+		throw std::exception("The method or operation is not implemented.");
+	}
+
+	CamelotEngine::String D3D11RenderSystem::getErrorDescription(long errorNumber) const
+	{
+		throw std::exception("The method or operation is not implemented.");
+	}
 }

CamelotD3D11RenderSystem/Source/CmD3D11RenderSystemFactory.cpp

@@ -0,0 +1,12 @@
+#include "CmD3D11RenderSystemFactory.h"
+#include "CmRenderSystem.h"
+
+namespace CamelotEngine
+{
+	void D3D11RenderSystemFactory::create()
+	{
+		RenderSystem::startUp(new D3D11RenderSystem());
+	}
+
+	D3D11RenderSystemFactory::InitOnStart D3D11RenderSystemFactory::initOnStart;
+}

CamelotD3D9Renderer/Include/CmD3D9RenderSystem.h

@@ -189,7 +189,6 @@ namespace CamelotEngine
 		/** See RenderSystem definition */
 		virtual void initialiseFromRenderSystemCapabilities(RenderSystemCapabilities* caps);
 
-
         void convertVertexShaderCaps(RenderSystemCapabilities* rsc) const;
         void convertPixelShaderCaps(RenderSystemCapabilities* rsc) const;
 		bool checkVertexTextureFormats(D3D9RenderWindow* renderWindow) const;
@@ -249,9 +248,6 @@ namespace CamelotEngine
 
 		void setClipPlanesImpl(const PlaneList& clipPlanes);	
 
-		/// @copydoc RenderSystem::createMultiRenderTarget
-		virtual MultiRenderTarget * createMultiRenderTarget(const String & name);
-
 		String getErrorDescription( long errorNumber ) const;
 
 		void initConfigOptions();

CamelotD3D9Renderer/Include/CmD3D9TextureManager.h

@@ -54,7 +54,7 @@ namespace CamelotEngine
 			UINT32 height, UINT32 fsaa, const String& fsaaHint);
 
 	protected:		
-		D3D9Texture* createImpl();
+		Texture* createImpl();
 	};
 }
 #endif

CamelotD3D9Renderer/Source/CmD3D9HLSLProgramFactory.cpp

@@ -66,5 +66,4 @@ namespace CamelotEngine {
         delete prog;
     }
     //-----------------------------------------------------------------------
-
 }

CamelotD3D9Renderer/Source/CmD3D9RenderSystem.cpp

@@ -2559,23 +2559,11 @@ namespace CamelotEngine
 		__SetRenderState(D3DRS_CLIPPLANEENABLE, enable?
 			(prev | (1 << index)) : (prev & ~(1 << index)));
 	}
-	//-----------------------------------------------------------------------
-	MultiRenderTarget * D3D9RenderSystem::createMultiRenderTarget(const String & name)
-	{
-		THROW_IF_NOT_RENDER_THREAD;
-
-		MultiRenderTarget *retval;
-		retval = new D3D9MultiRenderTarget(name);
-		attachRenderTarget(*retval);
-
-		return retval;
-	}
 	//---------------------------------------------------------------------
 	void D3D9RenderSystem::notifyOnDeviceLost(D3D9Device* device)
 	{	
 
 	}
-
 	//---------------------------------------------------------------------
 	void D3D9RenderSystem::notifyOnDeviceReset(D3D9Device* device)
 	{		

CamelotD3D9Renderer/Source/CmD3D9TextureManager.cpp

@@ -44,7 +44,7 @@ namespace CamelotEngine
 
 	}
 
-    D3D9Texture* D3D9TextureManager::createImpl()
+    Texture* D3D9TextureManager::createImpl()
     {
 		return new D3D9Texture();
     }

CamelotGLRenderer/Include/CmGLRenderSystem.h

@@ -281,9 +281,6 @@ namespace CamelotEngine {
 		void setClipPlanesImpl(const PlaneList& clipPlanes);
 		bool activateGLTextureUnit(UINT16 unit);
 
-		/// @copydoc RenderSystem::createMultiRenderTarget
-		virtual MultiRenderTarget * createMultiRenderTarget(const String & name); 
-		
         /** See
           RenderSystem
          */

CamelotGLRenderer/Source/CmGLRenderSystem.cpp

@@ -1777,13 +1777,6 @@ namespace CamelotEngine {
 		}
 	}
 	//-----------------------------------------------------------------------
-	MultiRenderTarget * GLRenderSystem::createMultiRenderTarget(const String & name)
-	{
-		MultiRenderTarget *retval = GLRTTManager::instancePtr()->createMultiRenderTarget(name);
-		attachRenderTarget( *retval );
-		return retval;
-	}
-	//-----------------------------------------------------------------------
 	void GLRenderSystem::initialiseContext(GLContext* primary)
 	{
 		// Set main and current context

CamelotRenderer/Include/CmDepthStencilBuffer.h

@@ -31,8 +31,6 @@ namespace CamelotEngine
 		UINT32						mWidth;
 		UINT32						mHeight;
 		UINT32						mFsaa;
-		String						mFsaaHint;
-
-		void detachFromAllRenderTargets();
+		String						mFsaaHint;
 	};
 }

CamelotRenderer/Include/CmRenderSystem.h

@@ -418,12 +418,6 @@ namespace CamelotEngine
 		/** Initialize the render system from the capabilities*/
 		virtual void initialiseFromRenderSystemCapabilities(RenderSystemCapabilities* caps) = 0;
 
-		/**	Create a MultiRenderTarget, which is a render target that renders to multiple RenderTextures
-		at once. Surfaces can be bound and unbound at will.
-		This fails if mCapabilities->getNumMultiRenderTargets() is smaller than 2.
-		*/
-		virtual MultiRenderTarget * createMultiRenderTarget(const String & name) = 0; 
-
 		/** Returns a description of an error code.
 		*/
 		virtual String getErrorDescription(long errorNumber) const = 0;

CamelotRenderer/TODO.txt

@@ -17,7 +17,7 @@
 
 
 /////
-HardwarePixelBuffer should hold a pointer to DX11Texture, and CmDX11Texture should hold a pointer to HardwarePixelBuffer
+DX11 Render Textures are not implemented. I need to rethink render textures (and multi render textures) completely (Get rid of TU_RENDERTARGET enum)
 
 waitForVsync can probably be moved somewhere other than being directly in RenderSystem? (where is it in DX11?)
 
@@ -38,6 +38,7 @@ Add D3D11DepthStencilBuffer
 
 Make CommandQueue not use mutexes and use atomics instead??
 Make sure that the simulation can't run faster then the render thread! (Block the main thread until previous render finishes)
+Figure out how to handle accessing texture from a non-render thread?
 /////
 
 
@@ -174,6 +175,7 @@ Optional TODO:
  - Shared shader parameters (Since there will be values that are constant between all Draw call it doesn't make sense to set them every call?)
  - Serializable callbacks can't be null otherwise compiler complains
  - FBX importer can be greatly sped up by implementing a better allocator
+ - Extend texture copy so it accepts different subregions & subresources (currently only entire resource can be copied)
 
  -----------------------------------------------------------------------------------------------
 
@@ -186,6 +188,7 @@ After everything is polished
     - Maybe just add support for Cg and force everyone to use that? - I'd like to be able to just switch out renderer in a single location and that everything keeps on working without 
 	  further modifications.
  - Port boost threads to std threads (CmThreadDefines.h)
+ - Remove HardwarePixelBuffer (DX11 doesn't use it, and DX9 and OpenGL textures can be rewritten so they have its methods internally)
  
  - Go to Game Engine Architecture book and make a list of Utility systems we will need (Config files, Parsers, File I/O etc)
  - Go to GEA book and read about resource managers before implementing them