More work on DX11

Some refactoring on the render system to remove unused stuff

CamelotD3D11RenderSystem/CamelotD3D11RenderSystem.vcxproj

@@ -85,7 +85,7 @@
     <ClCompile>
       <WarningLevel>Level3</WarningLevel>
       <Optimization>Disabled</Optimization>
-      <AdditionalIncludeDirectories>C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Include;.\Include;..\CamelotRenderer\Include;..\CamelotUtility\Include;..\Dependencies\Include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>.\Include;..\CamelotRenderer\Include;..\CamelotUtility\Include;..\Dependencies\Include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>CM_RSD3D11_EXPORTS;_WINDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
     <Link>
@@ -99,7 +99,7 @@
     <ClCompile>
       <WarningLevel>Level3</WarningLevel>
       <Optimization>Disabled</Optimization>
-      <AdditionalIncludeDirectories>C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Include;.\Include;..\CamelotRenderer\Include;..\CamelotUtility\Include;..\Dependencies\Include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>.\Include;..\CamelotRenderer\Include;..\CamelotUtility\Include;..\Dependencies\Include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>CM_RSD3D11_EXPORTS;_WINDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
     <Link>
@@ -115,7 +115,7 @@
       <Optimization>MaxSpeed</Optimization>
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
-      <AdditionalIncludeDirectories>C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Include;.\Include;..\CamelotRenderer\Include;..\CamelotUtility\Include;..\Dependencies\Include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>.\Include;..\CamelotRenderer\Include;..\CamelotUtility\Include;..\Dependencies\Include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>CM_RSD3D11_EXPORTS;_WINDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
     <Link>
@@ -133,7 +133,7 @@
       <Optimization>MaxSpeed</Optimization>
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
-      <AdditionalIncludeDirectories>C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Include;.\Include;..\CamelotRenderer\Include;..\CamelotUtility\Include;..\Dependencies\Include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>.\Include;..\CamelotRenderer\Include;..\CamelotUtility\Include;..\Dependencies\Include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>CM_RSD3D11_EXPORTS;_WINDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
     <Link>
@@ -146,8 +146,16 @@
     </Link>
   </ItemDefinitionGroup>
   <ItemGroup>
+    <ClInclude Include="Include\CmD3D11Device.h" />
+    <ClInclude Include="Include\CmD3D11GpuProgram.h" />
+    <ClInclude Include="Include\CmD3D11Mappings.h" />
     <ClInclude Include="Include\CmD3D11Prerequisites.h" />
   </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="Source\CmD3D11Device.cpp" />
+    <ClCompile Include="Source\CmD3D11GpuProgram.cpp" />
+    <ClCompile Include="Source\CmD3D11Mappings.cpp" />
+  </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
   </ImportGroup>

CamelotD3D11RenderSystem/CamelotD3D11RenderSystem.vcxproj.filters

@@ -18,5 +18,25 @@
     <ClInclude Include="Include\CmD3D11Prerequisites.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="Include\CmD3D11GpuProgram.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\CmD3D11Mappings.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\CmD3D11Device.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="Source\CmD3D11GpuProgram.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Source\CmD3D11Mappings.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Source\CmD3D11Device.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

CamelotD3D11RenderSystem/Include/CmD3D11Device.h

@@ -0,0 +1,56 @@
+#pragma once
+
+#include "CmD3D11Prerequisites.h"
+
+namespace CamelotEngine
+{
+	class D3D11Device
+	{
+	public:
+		D3D11Device(ID3D11Device* device);
+		~D3D11Device();
+
+		void shutdown();
+
+		ID3D11DeviceContext* getImmediateContext() const { return mImmediateContext; }
+		ID3D11ClassLinkage* getClassLinkage() const { return mClassLinkage; }
+		ID3D11Device* getD3D11Device() const { return mD3D11Device; }		
+
+		/**
+		 * @brief	Resets error state & error messages.
+		 */
+		void clearError();
+
+		/**
+		 * @brief	Query if error occurred at any point since class "clearError" call.
+		 * 			Use getErrorDescription to get a string describing the error.
+		 */
+		bool hasError() const;
+
+		/**
+		 * @brief	Returns a string describing an error, if one occurred.
+		 */
+		String getErrorDescription(bool clearErrors = true);
+		
+		enum CM_D3D11_ERROR_LEVEL
+		{
+			D3D11ERR_NO_EXCEPTION,
+			D3D11ERR_CORRUPTION,
+			D3D11ERR_ERROR,
+			D3D11ERR_WARNING,
+			D3D11ERR_INFO
+		};
+
+		void setExceptionsErrorLevel(const CM_D3D11_ERROR_LEVEL exceptionsErrorLevel);
+
+	private:
+		ID3D11Device*			mD3D11Device;
+		ID3D11DeviceContext*	mImmediateContext;
+		ID3D11InfoQueue*		mInfoQueue; 
+
+		// Storing class linkage
+		ID3D11ClassLinkage* mClassLinkage;
+
+		D3D11Device();
+	};
+}

CamelotD3D11RenderSystem/Include/CmD3D11GpuProgram.h

@@ -0,0 +1,112 @@
+#pragma once
+
+#include "CmD3D11Prerequisites.h"
+#include "CmGpuProgram.h"
+
+namespace CamelotEngine
+{
+	/** Direct3D implementation of a few things common to low-level vertex & fragment programs. */
+	class D3D11GpuProgram : public GpuProgram
+	{
+	public:
+		D3D11GpuProgram(GpuProgramType type, GpuProgramProfile profile);
+
+	protected:
+		void loadImpl(void);
+
+		/**
+		 * @brief	Loads shader from source. Not used as DX11 doesn't support
+		 * 			assembly shaders.
+		 */
+		void loadFromSource(void);
+
+		/**
+		 * @brief	Loads shader from microcode.
+		 */
+		virtual void loadFromMicrocode(D3D11Device& device, ID3D10Blob* microcode) = 0;
+	};
+
+	/** Direct3D implementation of low-level vertex programs. */
+	class D3D11GpuVertexProgram : public D3D11GpuProgram
+	{
+	protected:
+		ID3D11VertexShader* mVertexShader;
+	public:
+		D3D11GpuVertexProgram(GpuProgramProfile profile);
+		~D3D11GpuVertexProgram();
+
+		/// Gets the vertex shader
+		ID3D11VertexShader* getVertexShader(void) const;
+	protected:
+		void unloadImpl(void);
+		void loadFromMicrocode(D3D11Device& device, ID3D10Blob* microcode);
+	};
+
+	/** Direct3D implementation of low-level fragment programs. */
+	class D3D11GpuFragmentProgram : public D3D11GpuProgram
+	{
+	protected:
+		ID3D11PixelShader* mPixelShader;
+	public:
+		D3D11GpuFragmentProgram(GpuProgramProfile profile);
+		~D3D11GpuFragmentProgram();
+
+		/// Gets the pixel shader
+		ID3D11PixelShader* getPixelShader(void) const;
+	protected:
+		/** @copydoc Resource::unloadImpl */
+		void unloadImpl(void);
+		void loadFromMicrocode(D3D11Device& device, ID3D10Blob* microcode);
+	};
+
+	/** Direct3D implementation of low-level vertex programs. */
+	class D3D11GpuDomainProgram : public D3D11GpuProgram
+	{
+	protected:
+		ID3D11DomainShader* mDomainShader;
+	public:
+		D3D11GpuDomainProgram(GpuProgramProfile profile);
+		~D3D11GpuDomainProgram();
+
+		/// Gets the vertex shader
+		ID3D11DomainShader* getDomainShader(void) const;
+	protected:
+		void unloadImpl(void);
+		void loadFromMicrocode(D3D11Device& device, ID3D10Blob* microcode);
+	};
+
+	/** Direct3D implementation of low-level vertex programs. */
+	class D3D11GpuHullProgram : public D3D11GpuProgram
+	{
+	protected:
+		ID3D11HullShader* mHullShader;
+	public:
+		D3D11GpuHullProgram(GpuProgramProfile profile);
+		~D3D11GpuHullProgram();
+
+		/// Gets the vertex shader
+		ID3D11HullShader* getHullShader() const;
+	protected:
+		void unloadImpl(void);
+		void loadFromMicrocode(D3D11Device& device, ID3D10Blob* microcode);
+	};
+
+	/** 
+		Direct3D implementation of low-level geometry programs. 
+		Added due to need to accept geometry programs came from other profiles (nvgp4, for example)
+	*/
+	class D3D11GpuGeometryProgram : public D3D11GpuProgram
+	{
+	protected:
+		ID3D11GeometryShader* mGeometryShader;
+	public:
+		D3D11GpuGeometryProgram(GpuProgramProfile profile);
+		~D3D11GpuGeometryProgram();
+
+		/// Gets the geometry shader
+		ID3D11GeometryShader* getGeometryShader(void) const;
+	protected:
+		void unloadImpl(void);
+		void loadFromMicrocode(D3D11Device& device, ID3D10Blob* microcode);
+	};
+}

CamelotD3D11RenderSystem/Include/CmD3D11Mappings.h

@@ -0,0 +1,82 @@
+#pragma once
+
+#include "CmD3D11Prerequisites.h"
+#include "CmCommon.h"
+#include "CmTexture.h"
+#include "CmPixelData.h"
+#include "CmHardwareIndexBuffer.h"
+#include "CmVertexIndexData.h"
+#include "CmSamplerState.h"
+
+namespace CamelotEngine
+{
+	class D3D11Mappings
+	{
+	public:
+
+		/// enum identifying D3D11 filter usage type
+		enum eD3DFilterUsage
+		{
+			/// min filter
+			D3D_FUSAGE_MIN,
+			/// mag filter
+			D3D_FUSAGE_MAG,
+			/// mip filter
+			D3D_FUSAGE_MIP
+		};
+
+		/// return a D3D11 equivalent for a Ogre TextureAddressingMode value
+		static D3D11_TEXTURE_ADDRESS_MODE get(SamplerState::TextureAddressingMode tam);
+		/// return a D3D11 equivalent for a Ogre SceneBlendFactor value
+		static D3D11_BLEND get(SceneBlendFactor sbf);
+		/// return a D3D11 equivalent for a Ogre SceneBlendOperation value
+		static D3D11_BLEND_OP get(SceneBlendOperation sbo);
+		/// return a D3D11 equivalent for a Ogre CompareFunction value
+		static D3D11_COMPARISON_FUNC get(CompareFunction cf);
+		/// return a D3D11 equivalent for a Ogre CillingMode value
+		static D3D11_CULL_MODE get(CullingMode cm, bool flip = false);
+		/// return a D3D11 equivalent for a Ogre PolygonMode value
+		static D3D11_FILL_MODE get(PolygonMode level);
+		/// return a D3D11 equivalent for a Ogre StencilOperation value
+		static D3D11_STENCIL_OP get(StencilOperation op, bool invert = false);
+		/// return a D3D11 state type for Ogre FilterType value
+		static DWORD get(FilterType ft);
+		static D3D11_FILTER get(const FilterOptions minification, const FilterOptions magnification, const FilterOptions mips, const bool comparison = false);
+		/// return the combination of D3DUSAGE values for Ogre buffer usage
+		static DWORD get(HardwareBuffer::Usage usage);
+		/// Get lock options
+		static D3D11_MAP get(HardwareBuffer::LockOptions options, HardwareBuffer::Usage usage);
+		static UINT getByteWidth(HardwareIndexBuffer::IndexType itype);
+		/// Get vertex data type
+		static DXGI_FORMAT get(VertexElementType vType);
+		/// Get vertex semantic
+		static LPCSTR get(VertexElementSemantic sem);
+		static VertexElementSemantic get(LPCSTR sem);
+		/// Get dx11 color
+		static void get(const Color& inColour, float * outColour );
+
+
+		/// utility method, convert D3D11 pixel format to Ogre pixel format
+		static PixelFormat _getPF(DXGI_FORMAT d3dPF);
+		/// utility method, convert Ogre pixel format to D3D11 pixel format
+		static DXGI_FORMAT _getPF(PixelFormat ogrePF);
+		//
+		static D3D11_USAGE _getUsage(HardwareBuffer::Usage mUsage);
+		static D3D11_USAGE _getUsage(int mUsage);
+		static UINT _getAccessFlags(HardwareBuffer::Usage mUsage);
+		static UINT _getAccessFlags(int mUsage);
+		static bool _isDynamic(HardwareBuffer::Usage mUsage);
+
+		static bool _isDynamic(int mUsage);
+
+		/// utility method, find closest Ogre pixel format that D3D11 can support
+		static PixelFormat _getClosestSupportedPF(PixelFormat ogrePF);
+
+		static TextureType _getTexType(D3D11_SRV_DIMENSION type);
+
+		static size_t _getSizeInBytes(PixelFormat pf, size_t xcount = 1, size_t ycount = 1);
+
+		static UINT _getTextureBindFlags(DXGI_FORMAT format, bool isdynamic);
+		static UINT _getTextureMiscFlags(UINT bindflags, TextureType textype, bool isdynamic);
+	};
+}

CamelotD3D11RenderSystem/Include/CmD3D11Prerequisites.h

@@ -18,30 +18,30 @@
 #endif
 
 #include <d3d11.h>
-#include <d3d11shader.h>
+#include <d3d11shader.h>
 #include <D3Dcompiler.h>
 
 namespace CamelotEngine
 {
 	// Predefine classes
-	class D3D11RenderSystem;
-	class D3D11RenderWindowBase;
-	class D3D11Texture;
-	class D3D11TextureManager;
-	class D3D11DepthBuffer;
-	class D3D11Driver;
-	class D3D11DriverList;
-	class D3D11VideoMode;
-	class D3D11VideoModeList;
-	class D3D11GpuProgram;
-	class D3D11GpuProgramManager;
-	class D3D11HardwareBufferManager;
-	class D3D11HardwareIndexBuffer;
-	class D3D11HLSLProgramFactory;
-	class D3D11HLSLProgram;
-	class D3D11VertexDeclaration;
-	class D3D11Device;
-	class D3D11HardwareBuffer;
+	class D3D11RenderSystem;
+	class D3D11RenderWindowBase;
+	class D3D11Texture;
+	class D3D11TextureManager;
+	class D3D11DepthBuffer;
+	class D3D11Driver;
+	class D3D11DriverList;
+	class D3D11VideoMode;
+	class D3D11VideoModeList;
+	class D3D11GpuProgram;
+	class D3D11GpuProgramManager;
+	class D3D11HardwareBufferManager;
+	class D3D11HardwareIndexBuffer;
+	class D3D11HLSLProgramFactory;
+	class D3D11HLSLProgram;
+	class D3D11VertexDeclaration;
+	class D3D11Device;
+	class D3D11HardwareBuffer;
 	class D3D11HardwarePixelBuffer;
 
 	enum TypeID_D3D9

CamelotD3D11RenderSystem/Source/CmD3D11Device.cpp

@@ -0,0 +1,149 @@
+#include "CmD3D11Device.h"
+#include "CmException.h"
+
+namespace CamelotEngine
+{
+	D3D11Device::D3D11Device() 
+		:mD3D11Device(nullptr), mImmediateContext(nullptr), mClassLinkage(nullptr)
+	{
+	}
+
+	D3D11Device::D3D11Device(ID3D11Device* device)
+		: mD3D11Device(device)
+		, mImmediateContext(nullptr)
+		, mInfoQueue(nullptr)
+		, mClassLinkage(nullptr)
+	{
+		assert(device != nullptr);
+
+		if (device)
+		{
+			device->GetImmediateContext(&mImmediateContext);
+
+			HRESULT hr = mD3D11Device->QueryInterface(__uuidof(ID3D11InfoQueue), (LPVOID*)&mInfoQueue);
+
+			if (FAILED(hr))
+				CM_EXCEPT(RenderingAPIException, "Unable to query D3D11InfoQueue");
+
+			// If feature level is 11, create class linkage
+			SAFE_RELEASE(mClassLinkage);
+			if (mD3D11Device->GetFeatureLevel() == D3D_FEATURE_LEVEL_11_0)
+			{
+				HRESULT hr = mD3D11Device->CreateClassLinkage(&mClassLinkage);
+
+				if (FAILED(hr))
+					CM_EXCEPT(RenderingAPIException, "Unable to create class linkage.");
+			}
+		}	
+	}
+
+	D3D11Device::~D3D11Device()
+	{
+	}
+
+	void D3D11Device::shutdown()
+	{
+		// Clear state
+		if (mImmediateContext)
+		{
+			mImmediateContext->Flush();
+			mImmediateContext->ClearState();
+		}
+
+		SAFE_RELEASE(mInfoQueue);
+		SAFE_RELEASE(mD3D11Device);
+		SAFE_RELEASE(mImmediateContext);
+		SAFE_RELEASE(mClassLinkage);
+	}
+
+	String D3D11Device::getErrorDescription(bool doClearErrors)
+	{
+		if (mD3D11Device == nullptr)
+			return "NULL device";
+
+		String res;
+
+		if (mInfoQueue != nullptr)
+		{
+			UINT64 numStoredMessages = mInfoQueue->GetNumStoredMessagesAllowedByRetrievalFilter();
+			for (UINT64 i = 0 ; i < numStoredMessages ; i++ )
+			{
+				// Get the size of the message
+				SIZE_T messageLength = 0;
+				mInfoQueue->GetMessage(i, nullptr, &messageLength);
+				// Allocate space and get the message
+				D3D11_MESSAGE* pMessage = (D3D11_MESSAGE*)malloc(messageLength);
+				mInfoQueue->GetMessage(i, pMessage, &messageLength);
+				res = res + pMessage->pDescription + "\n";
+				free(pMessage);
+			}
+		}
+
+		if(doClearErrors)
+			clearError();
+
+		return res;
+	}
+
+	bool D3D11Device::hasError() const
+	{
+		if (mInfoQueue != nullptr)
+		{
+			UINT64 numStoredMessages = mInfoQueue->GetNumStoredMessagesAllowedByRetrievalFilter();
+
+			if (numStoredMessages > 0)
+				return true;
+
+			return false;
+		}
+		else
+		{
+			return false;
+		}
+	}
+
+	void D3D11Device::clearError()
+	{
+		if (mD3D11Device != nullptr && mInfoQueue != nullptr)
+		{
+			mInfoQueue->ClearStoredMessages();
+		}
+	}
+
+	void D3D11Device::setExceptionsErrorLevel(const CM_D3D11_ERROR_LEVEL exceptionsErrorLevel)
+	{
+		if(mInfoQueue == nullptr)
+			return;
+
+		mInfoQueue->ClearRetrievalFilter();
+		mInfoQueue->ClearStorageFilter();
+
+		D3D11_INFO_QUEUE_FILTER filter;
+		ZeroMemory(&filter, sizeof(D3D11_INFO_QUEUE_FILTER));
+		std::vector<D3D11_MESSAGE_SEVERITY> severityList;
+
+		switch(exceptionsErrorLevel)
+		{
+		case D3D11ERR_NO_EXCEPTION:
+			severityList.push_back(D3D11_MESSAGE_SEVERITY_CORRUPTION);
+		case D3D11ERR_CORRUPTION:
+			severityList.push_back(D3D11_MESSAGE_SEVERITY_ERROR);
+		case D3D11ERR_ERROR:
+			severityList.push_back(D3D11_MESSAGE_SEVERITY_WARNING);
+		case D3D11ERR_WARNING:
+		case D3D11ERR_INFO:
+			severityList.push_back(D3D11_MESSAGE_SEVERITY_INFO);
+		default: 
+			break;
+		}
+
+		if (severityList.size() > 0)
+		{
+			filter.DenyList.NumSeverities = (UINT)severityList.size();
+			filter.DenyList.pSeverityList = &severityList[0];
+		}
+
+		mInfoQueue->AddStorageFilterEntries(&filter);
+		mInfoQueue->AddRetrievalFilterEntries(&filter);
+	}
+}

CamelotD3D11RenderSystem/Source/CmD3D11GpuProgram.cpp

@@ -0,0 +1,247 @@
+#include "CmD3D11GpuProgram.h"
+#include "CmD3D11Device.h"
+#include "CmException.h"
+#include "CmDebug.h"
+
+namespace CamelotEngine
+{
+	D3D11GpuProgram::D3D11GpuProgram(GpuProgramType type, GpuProgramProfile profile) 
+		: GpuProgram("", "", "", type, profile)
+	{
+
+	}
+
+	void D3D11GpuProgram::loadImpl(void)
+	{
+		// Call polymorphic load
+		loadFromSource();
+	}
+
+	void D3D11GpuProgram::loadFromSource(void)
+	{
+		CM_EXCEPT(RenderingAPIException, "DirectX 11 doesn't support assembly shaders.");
+	}
+
+	D3D11GpuVertexProgram::D3D11GpuVertexProgram(GpuProgramProfile profile) 
+		: D3D11GpuProgram(GPT_VERTEX_PROGRAM, profile)
+		, mVertexShader(nullptr)
+	{ }
+
+	D3D11GpuVertexProgram::~D3D11GpuVertexProgram()
+	{
+		// have to call this here reather than in Resource destructor
+		// since calling virtual methods in base destructors causes crash
+		unload(); 
+	}
+
+	void D3D11GpuVertexProgram::loadFromMicrocode(D3D11Device& device, ID3D10Blob *  microcode)
+	{
+		if (isSupported())
+		{
+			// Create the shader
+			HRESULT hr = device.getD3D11Device()->CreateVertexShader( 
+				static_cast<DWORD*>(microcode->GetBufferPointer()), 
+				microcode->GetBufferSize(),
+				NULL,
+				&mVertexShader);
+
+			if (FAILED(hr) || device.hasError())
+			{
+				String errorDescription = device.getErrorDescription();
+				CM_EXCEPT(RenderingAPIException, 
+					"Cannot create D3D11 vertex shader from microcode\nError Description:" + errorDescription);
+
+			}
+		}
+		else
+		{
+			LOGWRN("Unsupported D3D11 vertex shader was not loaded.");
+		}
+	}
+
+	void D3D11GpuVertexProgram::unloadImpl(void)
+	{
+		SAFE_RELEASE(mVertexShader);
+	}
+
+	ID3D11VertexShader * D3D11GpuVertexProgram::getVertexShader( void ) const
+	{
+		return mVertexShader;
+	}
+
+	D3D11GpuFragmentProgram::D3D11GpuFragmentProgram(GpuProgramProfile profile) 
+		: D3D11GpuProgram(GPT_FRAGMENT_PROGRAM, profile)
+		, mPixelShader(nullptr)
+	{ }
+
+	D3D11GpuFragmentProgram::~D3D11GpuFragmentProgram()
+	{
+		unload(); 
+	}
+
+	void D3D11GpuFragmentProgram::loadFromMicrocode(D3D11Device& device, ID3D10Blob* microcode)
+	{
+		if (isSupported())
+		{
+			// Create the shader
+			HRESULT hr = device.getD3D11Device()->CreatePixelShader(
+				static_cast<DWORD*>(microcode->GetBufferPointer()), 
+				microcode->GetBufferSize(),
+				NULL,
+				&mPixelShader);
+
+			if (FAILED(hr) || device.hasError())
+			{
+				String errorDescription = device.getErrorDescription();
+				CM_EXCEPT(RenderingAPIException, 
+					"Cannot create D3D11 pixel shader from microcode.\nError Description:" + errorDescription);
+			}
+		}
+		else
+		{
+			LOGWRN("Unsupported D3D11 pixel shader was not loaded.");
+		}
+	}
+
+	void D3D11GpuFragmentProgram::unloadImpl(void)
+	{
+		SAFE_RELEASE(mPixelShader);
+	}
+
+	ID3D11PixelShader * D3D11GpuFragmentProgram::getPixelShader( void ) const
+	{
+		return mPixelShader;
+	}
+
+	D3D11GpuGeometryProgram::D3D11GpuGeometryProgram(GpuProgramProfile profile) 
+		: D3D11GpuProgram(GPT_GEOMETRY_PROGRAM, profile)
+		, mGeometryShader(nullptr)
+	{ }
+
+	D3D11GpuGeometryProgram::~D3D11GpuGeometryProgram()
+	{
+		unload(); 
+	}
+
+	void D3D11GpuGeometryProgram::loadFromMicrocode(D3D11Device& device, ID3D10Blob* microcode)
+	{
+		if (isSupported())
+		{
+			// Create the shader
+			HRESULT hr = device.getD3D11Device()->CreateGeometryShader(
+				static_cast<DWORD*>(microcode->GetBufferPointer()), 
+				microcode->GetBufferSize(),
+				NULL,
+				&mGeometryShader);
+
+			if (FAILED(hr) || device.hasError())
+			{
+				String errorDescription = device.getErrorDescription();
+				CM_EXCEPT(RenderingAPIException, 
+					"Cannot create D3D11 geometry shader from microcode.\nError Description:" + errorDescription);
+			}
+		}
+		else
+		{
+			LOGWRN("Unsupported D3D11 geometry shader was not loaded.");
+		}
+	}
+
+	void D3D11GpuGeometryProgram::unloadImpl(void)
+	{
+		SAFE_RELEASE(mGeometryShader);
+	}
+
+	ID3D11GeometryShader * D3D11GpuGeometryProgram::getGeometryShader(void) const
+	{
+		return mGeometryShader;
+	}
+
+	D3D11GpuDomainProgram::D3D11GpuDomainProgram(GpuProgramProfile profile) 
+		: D3D11GpuProgram(GPT_DOMAIN_PROGRAM, profile)
+		, mDomainShader(nullptr)
+	{ }
+
+	D3D11GpuDomainProgram::~D3D11GpuDomainProgram()
+	{
+		unload(); 
+	}
+
+	void D3D11GpuDomainProgram::loadFromMicrocode(D3D11Device& device, ID3D10Blob* microcode)
+	{
+		if (isSupported())
+		{
+			// Create the shader
+			HRESULT hr = device.getD3D11Device()->CreateDomainShader(
+				static_cast<DWORD*>(microcode->GetBufferPointer()), 
+				microcode->GetBufferSize(),
+				NULL,
+				&mDomainShader);
+
+			if (FAILED(hr) || device.hasError())
+			{
+				String errorDescription = device.getErrorDescription();
+				CM_EXCEPT(RenderingAPIException, 
+					"Cannot create D3D11 domain shader from microcode.\nError Description:" + errorDescription);
+			}
+		}
+		else
+		{
+			LOGWRN("Unsupported D3D11 domain shader was not loaded.");
+		}
+	}
+
+	void D3D11GpuDomainProgram::unloadImpl(void)
+	{
+		SAFE_RELEASE(mDomainShader);
+	}
+
+	ID3D11DomainShader * D3D11GpuDomainProgram::getDomainShader(void) const
+	{
+		return mDomainShader;
+	}
+
+	D3D11GpuHullProgram::D3D11GpuHullProgram(GpuProgramProfile profile) 
+		: D3D11GpuProgram(GPT_HULL_PROGRAM, profile)
+		, mHullShader(nullptr)
+	{ }
+
+	D3D11GpuHullProgram::~D3D11GpuHullProgram()
+	{
+		unload(); 
+	}
+
+	void D3D11GpuHullProgram::loadFromMicrocode(D3D11Device& device, ID3D10Blob* microcode)
+	{
+		if (isSupported())
+		{
+			// Create the shader
+			HRESULT hr = device.getD3D11Device()->CreateHullShader(
+				static_cast<DWORD*>(microcode->GetBufferPointer()), 
+				microcode->GetBufferSize(),
+				NULL,
+				&mHullShader);
+
+			if (FAILED(hr) || device.hasError())
+			{
+				String errorDescription = device.getErrorDescription();
+				CM_EXCEPT(RenderingAPIException, 
+					"Cannot create D3D11 hull shader from microcode.\nError Description:" + errorDescription);
+			}
+		}
+		else
+		{
+			LOGWRN("Unsupported D3D11 hull shader was not loaded.");
+		}
+	}
+
+	void D3D11GpuHullProgram::unloadImpl(void)
+	{
+		SAFE_RELEASE(mHullShader);
+	}
+
+	ID3D11HullShader* D3D11GpuHullProgram::getHullShader(void) const
+	{
+		return mHullShader;
+	}
+}

CamelotD3D11RenderSystem/Source/CmD3D11Mappings.cpp

@@ -0,0 +1,876 @@
+#include "CmD3D11Mappings.h"
+#include "CmDebug.h"
+#include "CmException.h"
+
+namespace CamelotEngine
+{
+	D3D11_TEXTURE_ADDRESS_MODE D3D11Mappings::get(SamplerState::TextureAddressingMode tam)
+	{
+		switch( tam )
+		{
+		case SamplerState::TAM_WRAP:
+			return D3D11_TEXTURE_ADDRESS_WRAP;
+		case SamplerState::TAM_MIRROR:
+			return D3D11_TEXTURE_ADDRESS_MIRROR;
+		case SamplerState::TAM_CLAMP:
+			return D3D11_TEXTURE_ADDRESS_CLAMP;
+		case SamplerState::TAM_BORDER:
+			return D3D11_TEXTURE_ADDRESS_BORDER;
+		}
+		return D3D11_TEXTURE_ADDRESS_MIRROR_ONCE;
+	}
+
+	D3D11_BLEND D3D11Mappings::get(SceneBlendFactor sbf)
+	{
+		switch( sbf )
+		{
+		case SBF_ONE:
+			return D3D11_BLEND_ONE;
+		case SBF_ZERO:
+			return D3D11_BLEND_ZERO;
+		case SBF_DEST_COLOUR:
+			return D3D11_BLEND_DEST_COLOR;
+		case SBF_SOURCE_COLOUR:
+			return D3D11_BLEND_SRC_COLOR;
+		case SBF_ONE_MINUS_DEST_COLOUR:
+			return D3D11_BLEND_INV_DEST_COLOR;
+		case SBF_ONE_MINUS_SOURCE_COLOUR:
+			return D3D11_BLEND_INV_SRC_COLOR;
+		case SBF_DEST_ALPHA:
+			return D3D11_BLEND_DEST_ALPHA;
+		case SBF_SOURCE_ALPHA:
+			return D3D11_BLEND_SRC_ALPHA;
+		case SBF_ONE_MINUS_DEST_ALPHA:
+			return D3D11_BLEND_INV_DEST_ALPHA;
+		case SBF_ONE_MINUS_SOURCE_ALPHA:
+			return D3D11_BLEND_INV_SRC_ALPHA;
+		}
+		return D3D11_BLEND_ZERO;
+	}
+
+	D3D11_BLEND_OP D3D11Mappings::get(SceneBlendOperation sbo)
+	{
+		switch( sbo )
+		{
+		case SBO_ADD:
+			return D3D11_BLEND_OP_ADD;
+		case SBO_SUBTRACT:
+			return D3D11_BLEND_OP_SUBTRACT;
+		case SBO_REVERSE_SUBTRACT:
+			return D3D11_BLEND_OP_REV_SUBTRACT;
+		case SBO_MIN:
+			return D3D11_BLEND_OP_MIN;
+		case SBO_MAX:
+			return D3D11_BLEND_OP_MAX;
+		}
+		return D3D11_BLEND_OP_ADD;
+	}
+
+	D3D11_COMPARISON_FUNC D3D11Mappings::get(CompareFunction cf)
+	{
+		switch( cf )
+		{
+		case CMPF_ALWAYS_FAIL:
+			return D3D11_COMPARISON_NEVER;
+		case CMPF_ALWAYS_PASS:
+			return D3D11_COMPARISON_ALWAYS;
+		case CMPF_LESS:
+			return D3D11_COMPARISON_LESS;
+		case CMPF_LESS_EQUAL:
+			return D3D11_COMPARISON_LESS_EQUAL;
+		case CMPF_EQUAL:
+			return D3D11_COMPARISON_EQUAL;
+		case CMPF_NOT_EQUAL:
+			return D3D11_COMPARISON_NOT_EQUAL;
+		case CMPF_GREATER_EQUAL:
+			return D3D11_COMPARISON_GREATER_EQUAL;
+		case CMPF_GREATER:
+			return D3D11_COMPARISON_GREATER;
+		};
+		return D3D11_COMPARISON_ALWAYS;
+	}
+
+	D3D11_CULL_MODE D3D11Mappings::get(CullingMode cm, bool flip)
+	{
+		switch( cm )
+		{
+		case CULL_NONE:
+			return D3D11_CULL_NONE;
+		case CULL_CLOCKWISE:
+			if( flip )
+				return D3D11_CULL_FRONT;
+			else
+				return D3D11_CULL_BACK;
+		case CULL_ANTICLOCKWISE:
+			if( flip )
+				return D3D11_CULL_BACK;
+			else
+				return D3D11_CULL_FRONT;
+		}
+		return D3D11_CULL_NONE;
+	}
+
+	D3D11_FILL_MODE D3D11Mappings::get(PolygonMode level)
+	{
+		switch(level)
+		{
+		case PM_POINTS:
+			LOGWRN("Point rendering not supported in DX11. You must utilize custom geometry shader for that feature");
+			return D3D11_FILL_SOLID; 
+		case PM_WIREFRAME:
+			return D3D11_FILL_WIREFRAME;
+		case PM_SOLID:
+			return D3D11_FILL_SOLID;
+		}
+		return D3D11_FILL_SOLID;
+	}
+
+	D3D11_STENCIL_OP D3D11Mappings::get(StencilOperation op, bool invert)
+	{
+		switch(op)
+		{
+		case SOP_KEEP:
+			return D3D11_STENCIL_OP_KEEP;
+		case SOP_ZERO:
+			return D3D11_STENCIL_OP_ZERO;
+		case SOP_REPLACE:
+			return D3D11_STENCIL_OP_REPLACE;
+		case SOP_INCREMENT:
+			return invert? D3D11_STENCIL_OP_DECR_SAT : D3D11_STENCIL_OP_INCR_SAT;
+		case SOP_DECREMENT:
+			return invert? D3D11_STENCIL_OP_INCR_SAT : D3D11_STENCIL_OP_DECR_SAT;
+		case SOP_INCREMENT_WRAP:
+			return invert? D3D11_STENCIL_OP_DECR : D3D11_STENCIL_OP_INCR;
+		case SOP_DECREMENT_WRAP:
+			return invert? D3D11_STENCIL_OP_INCR : D3D11_STENCIL_OP_DECR;
+		case SOP_INVERT:
+			return D3D11_STENCIL_OP_INVERT;
+		}
+		return D3D11_STENCIL_OP_KEEP;
+	}
+
+	DWORD D3D11Mappings::get(FilterType ft)
+	{
+		switch (ft)
+		{
+		case FT_MIN:
+			return D3D11_MIN_FILTER_SHIFT;
+			break;
+		case FT_MAG:
+			return D3D11_MAG_FILTER_SHIFT;
+			break;
+		case FT_MIP:
+			return D3D11_MIP_FILTER_SHIFT;
+			break;
+		}
+
+		// to keep compiler happy
+		return D3D11_MIP_FILTER_SHIFT;
+	}
+	//---------------------------------------------------------------------
+	D3D11_FILTER D3D11Mappings::get(const FilterOptions min, const FilterOptions mag, const FilterOptions mip, const bool comparison)
+	{
+
+		D3D11_FILTER res;
+#define MERGE_FOR_SWITCH(_comparison_, _min_ , _mag_, _mip_ ) ((_comparison_ << 16) | (_min_ << 8) | (_mag_ << 4) | (_mip_))
+
+		switch((MERGE_FOR_SWITCH(comparison, min, mag, mip)))
+		{
+		case MERGE_FOR_SWITCH(true, FO_POINT, FO_POINT, FO_POINT):
+			res = D3D11_FILTER_COMPARISON_MIN_MAG_MIP_POINT;
+			break;
+		case MERGE_FOR_SWITCH(true, FO_POINT, FO_POINT, FO_LINEAR):
+			res = D3D11_FILTER_COMPARISON_MIN_MAG_POINT_MIP_LINEAR;
+			break;
+		case MERGE_FOR_SWITCH(true, FO_POINT, FO_LINEAR, FO_POINT):
+			res = D3D11_FILTER_COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT;
+			break;
+		case MERGE_FOR_SWITCH(true, FO_POINT, FO_LINEAR, FO_LINEAR):
+			res = D3D11_FILTER_COMPARISON_MIN_POINT_MAG_MIP_LINEAR;
+			break;
+		case MERGE_FOR_SWITCH(true, FO_LINEAR, FO_POINT, FO_POINT):
+			res = D3D11_FILTER_COMPARISON_MIN_LINEAR_MAG_MIP_POINT;
+			break;
+		case MERGE_FOR_SWITCH(true, FO_LINEAR, FO_POINT, FO_LINEAR):
+			res = D3D11_FILTER_COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR;
+			break;		
+		case MERGE_FOR_SWITCH(true, FO_LINEAR, FO_LINEAR, FO_POINT):
+			res = D3D11_FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT;
+			break;
+		case MERGE_FOR_SWITCH(true, FO_LINEAR, FO_LINEAR, FO_LINEAR):
+			res = D3D11_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR;
+			break;
+		case MERGE_FOR_SWITCH(true, FO_ANISOTROPIC, FO_ANISOTROPIC, FO_ANISOTROPIC):
+			res = D3D11_FILTER_COMPARISON_ANISOTROPIC;
+			break;
+
+		case MERGE_FOR_SWITCH(false, FO_POINT, FO_POINT, FO_POINT):
+			res = D3D11_FILTER_MIN_MAG_MIP_POINT;
+			break;
+		case MERGE_FOR_SWITCH(false, FO_POINT, FO_POINT, FO_LINEAR):
+			res = D3D11_FILTER_MIN_MAG_POINT_MIP_LINEAR;
+			break;
+		case MERGE_FOR_SWITCH(false, FO_POINT, FO_LINEAR, FO_POINT):
+			res = D3D11_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT;
+			break;
+		case MERGE_FOR_SWITCH(false, FO_POINT, FO_LINEAR, FO_LINEAR):
+			res = D3D11_FILTER_MIN_POINT_MAG_MIP_LINEAR;
+			break;
+		case MERGE_FOR_SWITCH(false, FO_LINEAR, FO_POINT, FO_POINT):
+			res = D3D11_FILTER_MIN_LINEAR_MAG_MIP_POINT;
+			break;
+		case MERGE_FOR_SWITCH(false, FO_LINEAR, FO_POINT, FO_LINEAR):
+			res = D3D11_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR;
+			break;		
+		case MERGE_FOR_SWITCH(false, FO_LINEAR, FO_LINEAR, FO_POINT):
+			res = D3D11_FILTER_MIN_MAG_LINEAR_MIP_POINT;
+			break;
+		case MERGE_FOR_SWITCH(false, FO_LINEAR, FO_LINEAR, FO_LINEAR):
+			res = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
+			break;
+		case MERGE_FOR_SWITCH(false, FO_ANISOTROPIC, FO_ANISOTROPIC, FO_ANISOTROPIC):
+			res = D3D11_FILTER_ANISOTROPIC;
+			break;
+		default:
+			res = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
+		}	
+
+#undef MERGE_FOR_SWITCH
+		
+		return res;
+	}
+
+	DWORD D3D11Mappings::get(HardwareBuffer::Usage usage)
+	{
+		DWORD ret = 0;
+		if (usage & HardwareBuffer::HBU_DYNAMIC)
+		{
+#if CM_D3D_MANAGE_BUFFERS
+			// Only add the dynamic flag for default pool, and
+			// we use default pool when buffer is discardable
+			if (usage & HardwareBuffer::HBU_DISCARDABLE)
+				ret |= D3D11_USAGE_DYNAMIC;
+#else
+			ret |= D3D11_USAGE_DYNAMIC;
+#endif
+		}
+		if (usage & HardwareBuffer::HBU_WRITE_ONLY)
+		{
+			ret |= D3D11_USAGE_DYNAMIC;
+		}
+		return ret;
+	}
+
+	D3D11_MAP D3D11Mappings::get(HardwareBuffer::LockOptions options, HardwareBuffer::Usage usage)
+	{
+		D3D11_MAP ret = D3D11_MAP_READ_WRITE;
+		if (options == HardwareBuffer::HBL_DISCARD)
+		{
+#if CM_D3D_MANAGE_BUFFERS
+			// Only add the discard flag for dynamic usgae and default pool
+			if ((usage & HardwareBuffer::HBU_DYNAMIC) &&
+				(usage & HardwareBuffer::HBU_DISCARDABLE))
+				ret = D3D11_MAP_WRITE_DISCARD;
+#else
+			// D3D doesn't like discard or no_overwrite on non-dynamic buffers
+			if (usage & HardwareBuffer::HBU_DYNAMIC)
+				ret = D3D11_MAP_WRITE_DISCARD;
+#endif
+		}
+		if (options == HardwareBuffer::HBL_READ_ONLY)
+		{
+			// D3D debug runtime doesn't like you locking managed buffers readonly
+			// when they were created with write-only (even though you CAN read
+			// from the software backed version)
+			if (!(usage & HardwareBuffer::HBU_WRITE_ONLY))
+				ret = D3D11_MAP_READ;
+
+		}
+		if (options == HardwareBuffer::HBL_NO_OVERWRITE)
+		{
+#if CM_D3D_MANAGE_BUFFERS
+			// Only add the nooverwrite flag for dynamic usgae and default pool
+			if ((usage & HardwareBuffer::HBU_DYNAMIC) &&
+				(usage & HardwareBuffer::HBU_DISCARDABLE))
+				ret = D3D11_MAP_WRITE_NO_OVERWRITE;
+#else
+			// D3D doesn't like discard or no_overwrite on non-dynamic buffers
+			if (usage & HardwareBuffer::HBU_DYNAMIC)
+				ret = D3D11_MAP_WRITE_NO_OVERWRITE;
+#endif 
+		}
+
+		return ret;
+	}
+
+	UINT D3D11Mappings::getByteWidth(HardwareIndexBuffer::IndexType itype)
+	{
+		if (itype == HardwareIndexBuffer::IT_32BIT)
+		{
+			return sizeof(UINT32);
+		}
+		else
+		{
+			return sizeof(UINT16);
+		}
+	}
+
+	DXGI_FORMAT D3D11Mappings::get(VertexElementType vType)
+	{
+		switch (vType)
+		{
+		case VET_COLOUR:
+		case VET_COLOUR_ABGR:
+		case VET_COLOUR_ARGB:
+			return DXGI_FORMAT_R8G8B8A8_UNORM;
+			break;
+		case VET_FLOAT1:
+			return DXGI_FORMAT_R32_FLOAT;
+			break;
+		case VET_FLOAT2:
+			return DXGI_FORMAT_R32G32_FLOAT;
+			break;
+		case VET_FLOAT3:
+			return DXGI_FORMAT_R32G32B32_FLOAT;
+			break;
+		case VET_FLOAT4:
+			return DXGI_FORMAT_R32G32B32A32_FLOAT;
+			break;
+		case VET_SHORT2:
+			return DXGI_FORMAT_R16G16_SINT;
+			break;
+		case VET_SHORT4:
+			return DXGI_FORMAT_R16G16B16A16_SINT;
+			break;
+		case VET_UBYTE4:
+			return DXGI_FORMAT_R8G8B8A8_UINT;
+			break;
+		}
+		// to keep compiler happy
+		return DXGI_FORMAT_R32G32B32_FLOAT;
+	}
+
+	VertexElementSemantic D3D11Mappings::get(LPCSTR sem)
+	{
+		// todo - add to ogre - POSITIONT and PSIZE ("Transformed vertex position" and "Point size")
+
+		if( strcmp(sem, "BLENDINDICES") == 0 )
+			return VES_BLEND_INDICES;
+		if( strcmp(sem, "BLENDWEIGHT") == 0 )
+			return VES_BLEND_WEIGHTS;
+		if( strcmp(sem, "COLOR") == 0 )
+			return VES_DIFFUSE;
+		if( strcmp(sem, "NORMAL") == 0 )
+			return VES_NORMAL;
+		if( strcmp(sem, "POSITION") == 0 )
+			return VES_POSITION;
+		if( strcmp(sem, "TEXCOORD") == 0 )
+			return VES_TEXTURE_COORDINATES;
+		if( strcmp(sem, "BINORMAL") == 0 )
+			return VES_BITANGENT;
+		if( strcmp(sem, "TANGENT") == 0 )
+			return VES_TANGENT;
+		if( strcmp(sem, "POSITIONT") == 0 )
+			return VES_POSITIONT;
+		if( strcmp(sem, "PSIZE") == 0 ) 
+			return VES_PSIZE;
+
+		CM_EXCEPT(RenderingAPIException, "Invalid shader semantic: " + String(sem));
+
+		// to keep compiler happy
+		return VES_POSITION;
+	}
+
+	LPCSTR D3D11Mappings::get(VertexElementSemantic sem)
+	{
+		switch (sem)	
+		{
+		case VES_BLEND_INDICES:
+			return "BLENDINDICES";
+			break;
+		case VES_BLEND_WEIGHTS:
+			return "BLENDWEIGHT";
+			break;
+		case VES_DIFFUSE:
+			return "COLOR"; // NB index will differentiate
+			break;
+		case VES_SPECULAR:
+			return "COLOR"; // NB index will differentiate
+			break;
+		case VES_NORMAL:
+			return "NORMAL";
+			break;
+		case VES_POSITION:
+			return "POSITION";
+			break;
+		case VES_TEXTURE_COORDINATES:
+			return "TEXCOORD";
+			break;
+		case VES_BITANGENT:
+			return "BINORMAL";
+			break;
+		case VES_TANGENT:
+			return "TANGENT";
+			break;
+		case VES_POSITIONT:
+			return "POSITIONT";
+			break;
+		case VES_PSIZE:
+			return "PSIZE";
+			break;
+		}
+		// to keep compiler happy
+		return "";
+	}
+
+	void D3D11Mappings::get(const Color& inColour, float * outColour )
+	{
+		outColour[0] = inColour.r;
+		outColour[1] = inColour.g;
+		outColour[2] = inColour.b;
+		outColour[3] = inColour.a;	
+	}
+
+	PixelFormat D3D11Mappings::_getPF(DXGI_FORMAT d3dPF)
+	{
+		switch(d3dPF)
+		{
+
+		case DXGI_FORMAT_UNKNOWN	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R32G32B32A32_TYPELESS	:
+			return PF_FLOAT32_RGBA;
+		case DXGI_FORMAT_R32G32B32A32_FLOAT	:
+			return PF_FLOAT32_RGBA;
+		case DXGI_FORMAT_R32G32B32A32_UINT	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R32G32B32A32_SINT	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R32G32B32_TYPELESS	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R32G32B32_FLOAT	:
+			return PF_FLOAT32_RGB;
+		case DXGI_FORMAT_R32G32B32_UINT	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R32G32B32_SINT	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R16G16B16A16_TYPELESS	:
+			return PF_FLOAT16_RGBA;
+		case DXGI_FORMAT_R16G16B16A16_FLOAT	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R16G16B16A16_UNORM	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R16G16B16A16_UINT	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R16G16B16A16_SNORM	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R16G16B16A16_SINT	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R32G32_TYPELESS	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R32G32_FLOAT	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R32G32_UINT	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R32G32_SINT	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R32G8X24_TYPELESS	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_D32_FLOAT_S8X24_UINT	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_X32_TYPELESS_G8X24_UINT	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R10G10B10A2_TYPELESS	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R10G10B10A2_UNORM	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R10G10B10A2_UINT	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R11G11B10_FLOAT	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R8G8B8A8_TYPELESS	:
+			return PF_R8G8B8A8;
+		case DXGI_FORMAT_R8G8B8A8_UNORM	:
+			return PF_R8G8B8A8;
+		case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R8G8B8A8_UINT	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R8G8B8A8_SNORM	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R8G8B8A8_SINT	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R16G16_TYPELESS	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R16G16_FLOAT	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R16G16_UNORM	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R16G16_UINT	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R16G16_SNORM	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R16G16_SINT	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R32_TYPELESS	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_D32_FLOAT	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R32_FLOAT	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R32_UINT	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R32_SINT	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R24G8_TYPELESS	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_D24_UNORM_S8_UINT	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R24_UNORM_X8_TYPELESS	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_X24_TYPELESS_G8_UINT	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R8G8_TYPELESS	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R8G8_UNORM	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R8G8_UINT	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R8G8_SNORM	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R8G8_SINT	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R16_TYPELESS	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R16_FLOAT	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_D16_UNORM	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R16_UNORM	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R16_UINT	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R16_SNORM	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R16_SINT	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R8_TYPELESS	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R8_UNORM	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R8_UINT	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R8_SNORM	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R8_SINT	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_A8_UNORM	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R1_UNORM	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R9G9B9E5_SHAREDEXP	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_R8G8_B8G8_UNORM	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_G8R8_G8B8_UNORM	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_BC1_TYPELESS	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_BC1_UNORM	:
+			return PF_DXT1;
+		case DXGI_FORMAT_BC1_UNORM_SRGB	:
+			return PF_DXT1;
+		case DXGI_FORMAT_BC2_TYPELESS	:
+			return PF_DXT2;
+		case DXGI_FORMAT_BC2_UNORM	:
+			return PF_DXT2;
+		case DXGI_FORMAT_BC2_UNORM_SRGB	:
+			return PF_DXT2;
+		case DXGI_FORMAT_BC3_TYPELESS	:
+			return PF_DXT3;
+		case DXGI_FORMAT_BC3_UNORM	:
+			return PF_DXT3;
+		case DXGI_FORMAT_BC3_UNORM_SRGB	:
+			return PF_DXT3;
+		case DXGI_FORMAT_BC4_TYPELESS	:
+			return PF_DXT4;
+		case DXGI_FORMAT_BC4_UNORM	:
+			return PF_DXT4;
+		case DXGI_FORMAT_BC4_SNORM	:
+			return PF_DXT4;
+		case DXGI_FORMAT_BC5_TYPELESS	:
+			return PF_DXT5;
+		case DXGI_FORMAT_BC5_UNORM	:
+			return PF_DXT5;
+		case DXGI_FORMAT_BC5_SNORM	:
+			return PF_DXT5;
+		case DXGI_FORMAT_B5G6R5_UNORM	:
+			return PF_DXT5;
+		case DXGI_FORMAT_B5G5R5A1_UNORM	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_B8G8R8A8_UNORM	:
+			return PF_UNKNOWN;
+		case DXGI_FORMAT_B8G8R8X8_UNORM	:
+			return PF_UNKNOWN;
+		default:
+			return PF_UNKNOWN;
+		}
+	}
+
+	DXGI_FORMAT D3D11Mappings::_getPF(PixelFormat ogrePF)
+	{
+		switch(ogrePF)
+		{
+		case PF_L8:
+			return DXGI_FORMAT_R8_UNORM;
+		case PF_L16:
+			return DXGI_FORMAT_R16_UNORM;
+		case PF_A8:
+			return DXGI_FORMAT_UNKNOWN;
+		case PF_A4L4:
+			return DXGI_FORMAT_UNKNOWN;
+		case PF_BYTE_LA:
+			return DXGI_FORMAT_UNKNOWN; 
+		case PF_R3G3B2:
+			return DXGI_FORMAT_UNKNOWN;
+		case PF_A1R5G5B5:
+			return DXGI_FORMAT_UNKNOWN;
+		case PF_R5G6B5:
+			return DXGI_FORMAT_UNKNOWN;
+		case PF_A4R4G4B4:
+			return DXGI_FORMAT_UNKNOWN;
+		case PF_R8G8B8:
+			return DXGI_FORMAT_UNKNOWN;
+		case PF_A8R8G8B8:
+			return DXGI_FORMAT_UNKNOWN;
+		case PF_A8B8G8R8:
+			return DXGI_FORMAT_R8G8B8A8_UNORM;
+		case PF_X8R8G8B8:
+			return DXGI_FORMAT_UNKNOWN;
+		case PF_X8B8G8R8:
+			return DXGI_FORMAT_UNKNOWN;
+		case PF_A2B10G10R10:
+			return DXGI_FORMAT_R10G10B10A2_TYPELESS;
+		case PF_A2R10G10B10:
+			return DXGI_FORMAT_UNKNOWN;
+		case PF_FLOAT16_R:
+			return DXGI_FORMAT_R16_FLOAT;
+		case PF_FLOAT16_RGBA:
+			return DXGI_FORMAT_R16G16B16A16_FLOAT;
+		case PF_FLOAT32_R:
+			return DXGI_FORMAT_R32_FLOAT;
+		case PF_FLOAT32_RGBA:
+			return DXGI_FORMAT_R32G32B32A32_FLOAT;
+		case PF_SHORT_RGBA:
+			return DXGI_FORMAT_R16G16B16A16_UNORM;
+		case PF_DXT1:
+			return DXGI_FORMAT_BC1_UNORM;
+		case PF_DXT2:
+			return DXGI_FORMAT_BC2_UNORM;
+		case PF_DXT3:
+			return DXGI_FORMAT_BC3_UNORM;
+		case PF_DXT4:
+			return DXGI_FORMAT_BC4_UNORM;
+		case PF_DXT5:
+			return DXGI_FORMAT_BC5_UNORM;
+		case PF_UNKNOWN:
+		default:
+			return DXGI_FORMAT_UNKNOWN;
+		}
+	}
+
+	PixelFormat D3D11Mappings::_getClosestSupportedPF(PixelFormat ogrePF)
+	{
+		if (_getPF(ogrePF) != DXGI_FORMAT_UNKNOWN)
+		{
+			return ogrePF;
+		}
+		switch(ogrePF)
+		{
+		case PF_FLOAT16_RGB:
+			return PF_FLOAT16_RGBA;
+		case PF_FLOAT32_RGB:
+			return PF_FLOAT32_RGBA;
+		case PF_UNKNOWN:
+		default:
+			return PF_A8B8G8R8;
+		}
+	}
+
+	D3D11_USAGE D3D11Mappings::_getUsage(HardwareBuffer::Usage mUsage)
+	{
+		if (_isDynamic(mUsage))
+		{
+			return D3D11_USAGE_DYNAMIC;
+		}
+		else
+		{
+			return D3D11_USAGE_DEFAULT;
+		}
+	}
+
+	bool D3D11Mappings::_isDynamic(HardwareBuffer::Usage mUsage)
+	{
+		switch ( mUsage)
+		{
+		case HardwareBuffer::HBU_DYNAMIC:
+		case HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY:
+		case HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY_DISCARDABLE:
+			return true;
+		}
+
+		return false;
+	}
+
+	bool D3D11Mappings::_isDynamic(int mUsage)
+	{
+		return _isDynamic(static_cast<HardwareBuffer::Usage>(mUsage));
+	}
+
+	D3D11_USAGE D3D11Mappings::_getUsage(int mUsage)
+	{
+		return _getUsage(static_cast<HardwareBuffer::Usage>(mUsage));
+	}
+
+	UINT D3D11Mappings::_getAccessFlags(int mUsage)
+	{
+		return _getAccessFlags(static_cast<HardwareBuffer::Usage>(mUsage));
+	}
+
+	UINT D3D11Mappings::_getAccessFlags(HardwareBuffer::Usage mUsage)
+	{
+		if(_isDynamic(mUsage))
+			return D3D11_CPU_ACCESS_WRITE;
+		else
+			return 0;
+	}
+
+	TextureType D3D11Mappings::_getTexType(D3D11_SRV_DIMENSION type)
+	{
+		switch(type)
+		{
+		case D3D_SRV_DIMENSION_TEXTURE1D:
+			return TEX_TYPE_1D;
+		case D3D_SRV_DIMENSION_TEXTURE2D:
+		case D3D_SRV_DIMENSION_TEXTURE2DMS:
+			return TEX_TYPE_2D;
+		case D3D_SRV_DIMENSION_TEXTURE2DARRAY:
+		case D3D_SRV_DIMENSION_TEXTURE2DMSARRAY:
+			return TEX_TYPE_2D_ARRAY;
+		case D3D_SRV_DIMENSION_TEXTURE3D:
+			return TEX_TYPE_3D;
+		case D3D_SRV_DIMENSION_TEXTURECUBE:
+			return TEX_TYPE_CUBE_MAP;
+		default:
+			// unknown
+			return static_cast<TextureType>(0);
+		}
+	}
+	//---------------------------------------------------------------------
+	size_t D3D11Mappings::_getSizeInBytes(PixelFormat pf, size_t xcount, size_t ycount)
+	{
+		if(xcount == 0 || ycount == 0)
+			return 0;
+
+		if(PixelUtil::isCompressed(pf))
+		{
+			// D3D wants the width of one row of cells in bytes
+			if (pf == PF_DXT1)
+			{
+				// 64 bits (8 bytes) per 4x4 block
+				return std::max<size_t>(1, xcount / 4) * std::max<size_t>(1, ycount / 4) * 8;
+			}
+			else
+			{
+				// 128 bits (16 bytes) per 4x4 block
+				return std::max<size_t>(1, xcount / 4) * std::max<size_t>(1, ycount / 4) * 16;
+			}
+		}
+		else
+		{
+			return xcount * ycount * PixelUtil::getNumElemBytes(pf);
+		}
+	}
+
+	UINT D3D11Mappings::_getTextureBindFlags(DXGI_FORMAT format, bool isdynamic)
+	{
+		if(isdynamic)
+			return D3D11_BIND_SHADER_RESOURCE; 
+
+		switch(format)
+		{
+		case DXGI_FORMAT_R32G32B32A32_TYPELESS:
+		case DXGI_FORMAT_R32G32B32_TYPELESS:
+		case DXGI_FORMAT_R32G32B32_FLOAT:
+		case DXGI_FORMAT_R32G32B32_UINT:
+		case DXGI_FORMAT_R32G32B32_SINT:
+		case DXGI_FORMAT_R16G16B16A16_TYPELESS:
+		case DXGI_FORMAT_R32G32_TYPELESS:
+		case DXGI_FORMAT_R32G8X24_TYPELESS:
+		case DXGI_FORMAT_D32_FLOAT_S8X24_UINT:
+		case DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS:
+		case DXGI_FORMAT_X32_TYPELESS_G8X24_UINT:
+		case DXGI_FORMAT_R10G10B10A2_TYPELESS:
+		case DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM:
+		case DXGI_FORMAT_R8G8B8A8_TYPELESS:
+		case DXGI_FORMAT_R16G16_TYPELESS:
+		case DXGI_FORMAT_R32_TYPELESS:
+		case DXGI_FORMAT_D32_FLOAT:
+		case DXGI_FORMAT_R24G8_TYPELESS:
+		case DXGI_FORMAT_D24_UNORM_S8_UINT:
+		case DXGI_FORMAT_R24_UNORM_X8_TYPELESS:
+		case DXGI_FORMAT_X24_TYPELESS_G8_UINT:
+		case DXGI_FORMAT_R8G8_TYPELESS:
+		case DXGI_FORMAT_R16_TYPELESS:
+		case DXGI_FORMAT_D16_UNORM:
+		case DXGI_FORMAT_R8_TYPELESS:
+		case DXGI_FORMAT_R9G9B9E5_SHAREDEXP:
+		case DXGI_FORMAT_R8G8_B8G8_UNORM:
+		case DXGI_FORMAT_G8R8_G8B8_UNORM:
+		case DXGI_FORMAT_BC1_TYPELESS:
+		case DXGI_FORMAT_BC1_UNORM:
+		case DXGI_FORMAT_BC1_UNORM_SRGB:
+		case DXGI_FORMAT_BC2_TYPELESS:
+		case DXGI_FORMAT_BC2_UNORM:
+		case DXGI_FORMAT_BC2_UNORM_SRGB:
+		case DXGI_FORMAT_BC3_TYPELESS:
+		case DXGI_FORMAT_BC3_UNORM:
+		case DXGI_FORMAT_BC3_UNORM_SRGB:
+		case DXGI_FORMAT_BC4_TYPELESS:
+		case DXGI_FORMAT_BC4_UNORM:
+		case DXGI_FORMAT_BC4_SNORM:
+		case DXGI_FORMAT_BC5_TYPELESS:
+		case DXGI_FORMAT_BC5_UNORM:
+		case DXGI_FORMAT_BC5_SNORM:
+		case DXGI_FORMAT_B8G8R8A8_TYPELESS:
+		case DXGI_FORMAT_B8G8R8X8_TYPELESS:
+		case DXGI_FORMAT_BC6H_TYPELESS:
+		case DXGI_FORMAT_BC6H_UF16:
+		case DXGI_FORMAT_BC6H_SF16:
+		case DXGI_FORMAT_BC7_TYPELESS:
+		case DXGI_FORMAT_BC7_UNORM:
+		case DXGI_FORMAT_BC7_UNORM_SRGB:
+			return D3D11_BIND_SHADER_RESOURCE;
+		default:
+			return D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET;
+		}
+	}
+
+	UINT D3D11Mappings::_getTextureMiscFlags(UINT bindflags, TextureType textype, bool isdynamic)
+	{
+		if(isdynamic)
+			return 0;
+
+		UINT flags = 0;
+
+		if(bindflags & D3D11_BIND_RENDER_TARGET)
+			flags |= D3D11_RESOURCE_MISC_GENERATE_MIPS;
+
+		if(textype == TEX_TYPE_CUBE_MAP)
+			flags |= D3D11_RESOURCE_MISC_TEXTURECUBE;
+
+		return flags;
+	}
+}

CamelotD3D9Renderer/Include/CmD3D9Mappings.h

@@ -63,10 +63,6 @@ namespace CamelotEngine
 			D3D_FUSAGE_MIP
 		};
 
-		/// return a D3D9 equivalent for a Ogre ShadeOptions value
-		static DWORD get(ShadeOptions so);
-		/// return a D3D9 equivalent for a Ogre TexCoordCalsMethod value
-		static DWORD get(TexCoordCalcMethod m, const D3DCAPS9& caps);
 		/// return a D3D9 equivalent for a Ogre TextureAddressingMode value
 		static D3DTEXTUREADDRESS get(SamplerState::TextureAddressingMode tam, const D3DCAPS9& devCaps);
 		/// return a D3D9 equivalent for a Ogre SceneBlendFactor value
@@ -77,8 +73,6 @@ namespace CamelotEngine
 		static DWORD get(CompareFunction cf);
 		/// return a D3D9 equivalent for a Ogre CillingMode value
 		static DWORD get(CullingMode cm, bool flip);
-		/// return a D3D9 equivalent for a Ogre FogMode value
-		static D3DFOGMODE get(FogMode fm);
 		/// return a D3D9 equivalent for a Ogre PolygonMode value
 		static D3DFILLMODE get(PolygonMode level);
 		/// return a D3D9 equivalent for a Ogre StencilOperation value

CamelotD3D9Renderer/Include/CmD3D9RenderSystem.h

@@ -78,8 +78,6 @@ namespace CamelotEngine
 			D3D9Mappings::eD3DTexType texType;
 			/// which texCoordIndex to use
 			size_t coordIndex;
-			/// type of auto tex. calc. used
-			TexCoordCalcMethod autoTexCoordType;
 			/// texture 
 			IDirect3DBaseTexture9 *pTex;
 			/// vertex texture 

CamelotD3D9Renderer/Source/CmD3D9Device.cpp

@@ -605,7 +605,6 @@ namespace CamelotEngine
 		
 			// set stage desc. to defaults
 			renderSystem->mTexStageDesc[stage].pTex = 0;
-			renderSystem->mTexStageDesc[stage].autoTexCoordType = TEXCALC_NONE;
 			renderSystem->mTexStageDesc[stage].coordIndex = 0;
 			renderSystem->mTexStageDesc[stage].texType = D3D9Mappings::D3D_TEX_TYPE_NORMAL;
 		}

CamelotD3D9Renderer/Source/CmD3D9Mappings.cpp

@@ -28,61 +28,10 @@ THE SOFTWARE.
 #include "CmD3D9Mappings.h"
 #include "CmString.h"
 #include "CmException.h"
+#include "CmDebug.h"
 
 namespace CamelotEngine 
 {
-	//---------------------------------------------------------------------
-	DWORD D3D9Mappings::get(ShadeOptions so)
-	{
-		switch( so )
-		{
-		case SO_FLAT:
-			return D3DSHADE_FLAT;
-		case SO_GOURAUD:
-			return D3DSHADE_GOURAUD;
-		case SO_PHONG:
-			return D3DSHADE_PHONG;
-		}
-		return 0;
-	}
-	//---------------------------------------------------------------------
-	DWORD D3D9Mappings::get(TexCoordCalcMethod m, const D3DCAPS9& caps)
-	{
-		switch( m )
-		{
-		case TEXCALC_NONE:
-			return D3DTSS_TCI_PASSTHRU;
-		case TEXCALC_ENVIRONMENT_MAP_REFLECTION:
-			return D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR;
-		case TEXCALC_ENVIRONMENT_MAP_PLANAR:
-			if (caps.VertexProcessingCaps & D3DVTXPCAPS_TEXGEN_SPHEREMAP)
-			{
-				// Use sphere map if available
-				return D3DTSS_TCI_SPHEREMAP;
-			}
-			else
-			{
-				// If not, fall back on camera space reflection vector which isn't as good
-                return D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR;
-			}
-		case TEXCALC_ENVIRONMENT_MAP_NORMAL:
-			return D3DTSS_TCI_CAMERASPACENORMAL;
-		case TEXCALC_ENVIRONMENT_MAP:
-			if (caps.VertexProcessingCaps & D3DVTXPCAPS_TEXGEN_SPHEREMAP)
-			{
-				// Use sphere map if available
-				return D3DTSS_TCI_SPHEREMAP;
-			}
-			else
-			{
-				// If not, fall back on camera space normal which isn't as good
-				return D3DTSS_TCI_CAMERASPACENORMAL;
-			}
-        case TEXCALC_PROJECTIVE_TEXTURE:
-            return D3DTSS_TCI_CAMERASPACEPOSITION;
-		}
-		return 0;
-	}
 	//---------------------------------------------------------------------
 	D3DTEXTUREADDRESS D3D9Mappings::get(SamplerState::TextureAddressingMode tam, const D3DCAPS9& devCaps)
 	{
@@ -194,20 +143,6 @@ namespace CamelotEngine
 		return 0;
 	}
 	//---------------------------------------------------------------------
-	D3DFOGMODE D3D9Mappings::get(FogMode fm)
-	{
-		switch( fm )
-		{
-		case FOG_EXP:
-			return D3DFOG_EXP;
-		case FOG_EXP2:
-			return D3DFOG_EXP2;
-		case FOG_LINEAR:
-			return D3DFOG_LINEAR;
-		}
-		return D3DFOG_FORCE_DWORD;
-	}
-	//---------------------------------------------------------------------
 	D3DFILLMODE D3D9Mappings::get(PolygonMode level)
 	{
 		switch(level)
@@ -514,6 +449,8 @@ namespace CamelotEngine
 		case VES_TANGENT:
 			return D3DDECLUSAGE_TANGENT;
 			break;
+		default:
+			CM_EXCEPT(RenderingAPIException, "Invalid semantic for D3D9 render system: " + toString(sem));
 		}
 		// to keep compiler happy
 		return D3DDECLUSAGE_POSITION;

CamelotD3D9Renderer/Source/CmD3D9RenderSystem.cpp

@@ -151,7 +151,6 @@ namespace CamelotEngine
 		// set stages desc. to defaults
 		for (size_t n = 0; n < CM_MAX_TEXTURE_LAYERS; n++)
 		{
-			mTexStageDesc[n].autoTexCoordType = TEXCALC_NONE;
 			mTexStageDesc[n].coordIndex = 0;
 			mTexStageDesc[n].texType = D3D9Mappings::D3D_TEX_TYPE_NORMAL;
 			mTexStageDesc[n].pTex = 0;
@@ -573,7 +572,6 @@ namespace CamelotEngine
 
 			// set stage desc. to defaults
 			mTexStageDesc[stage].pTex = 0;
-			mTexStageDesc[stage].autoTexCoordType = TEXCALC_NONE;
 			mTexStageDesc[stage].coordIndex = 0;
 			mTexStageDesc[stage].texType = D3D9Mappings::D3D_TEX_TYPE_NORMAL;
 		}

CamelotRenderer/Include/CmCommon.h

@@ -132,27 +132,6 @@ namespace CamelotEngine {
         FO_ANISOTROPIC
     };
 
-    /** Light shading modes. */
-    enum ShadeOptions
-    {
-        SO_FLAT,
-        SO_GOURAUD,
-        SO_PHONG
-    };
-
-    /** Fog modes. */
-    enum FogMode
-    {
-        /// No fog. Duh.
-        FOG_NONE,
-        /// Fog density increases  exponentially from the camera (fog = 1/e^(distance * density))
-        FOG_EXP,
-        /// Fog density increases at the square of FOG_EXP, i.e. even quicker (fog = 1/e^(distance * density)^2)
-        FOG_EXP2,
-        /// Fog density increases linearly between the start and end distances
-        FOG_LINEAR
-    };
-
     /** Hardware culling modes based on vertex winding.
         This setting applies to how the hardware API culls triangles it is sent. */
     enum CullingMode
@@ -176,43 +155,37 @@ namespace CamelotEngine {
         PM_SOLID = 3
     };
 
-    /** An enumeration describing which material properties should track the vertex colours */
-    typedef int TrackVertexColourType;
-    enum TrackVertexColourEnum {
-        TVC_NONE        = 0x0,
-        TVC_AMBIENT     = 0x1,        
-        TVC_DIFFUSE     = 0x2,
-        TVC_SPECULAR    = 0x4,
-        TVC_EMISSIVE    = 0x8
-    };
-
     /** Defines the frame buffer types. */
     enum FrameBufferType {
         FBT_COLOUR  = 0x1,
         FBT_DEPTH   = 0x2,
         FBT_STENCIL = 0x4
     };
-    
-	/// Name / value parameter pair (first = name, second = value)
-	typedef map<String, String>::type NameValuePairList;
 
-	/// Render window creation parameters.
-	struct RenderWindowDescription
+	/// Enum describing the various actions which can be taken onthe stencil buffer
+	enum StencilOperation
 	{
-		String				name;
-		unsigned int		width;
-		unsigned int		height;
-		bool				useFullScreen;
-		NameValuePairList	miscParams;
+		/// Leave the stencil buffer unchanged
+		SOP_KEEP,
+		/// Set the stencil value to zero
+		SOP_ZERO,
+		/// Set the stencil value to the reference value
+		SOP_REPLACE,
+		/// Increase the stencil value by 1, clamping at the maximum value
+		SOP_INCREMENT,
+		/// Decrease the stencil value by 1, clamping at 0
+		SOP_DECREMENT,
+		/// Increase the stencil value by 1, wrapping back to 0 when incrementing the maximum value
+		SOP_INCREMENT_WRAP,
+		/// Decrease the stencil value by 1, wrapping when decrementing 0
+		SOP_DECREMENT_WRAP,
+		/// Invert the bits of the stencil buffer
+		SOP_INVERT
 	};
+    
+	/// Name / value parameter pair (first = name, second = value)
+	typedef map<String, String>::type NameValuePairList;
 
-	/// Render window creation parameters container.
-	typedef vector<RenderWindowDescription>::type RenderWindowDescriptionList;
-
-	/// Render window container.
-	typedef vector<RenderWindow*>::type RenderWindowList;
-
-	
 	/** @} */
 }
 

CamelotRenderer/Include/CmGpuProgram.h

@@ -48,7 +48,10 @@ namespace CamelotEngine {
 	{
 		GPT_VERTEX_PROGRAM,
 		GPT_FRAGMENT_PROGRAM,
-		GPT_GEOMETRY_PROGRAM
+		GPT_GEOMETRY_PROGRAM,
+		GPT_DOMAIN_PROGRAM,
+		GPT_HULL_PROGRAM,
+		GPT_COMPUTE_PROGRAM
 	};
 
 	/** Defines a program which runs on the GPU such as a vertex or fragment program. 

CamelotRenderer/Include/CmHardwareVertexBuffer.h

@@ -91,8 +91,11 @@ namespace CamelotEngine {
         /// Binormal (Y axis if normal is Z)
         VES_BITANGENT = 8,
         /// Tangent (X axis if normal is Z)
-        VES_TANGENT = 9
-
+        VES_TANGENT = 9,
+		/// Transformed vertex position
+		VES_POSITIONT = 10,
+		/// Point size
+		VES_PSIZE = 11
 	};
 
     /// Vertex element type, used to identify the base types of the vertex contents

CamelotRenderer/Include/CmRenderSystem.h

@@ -60,41 +60,6 @@ namespace CamelotEngine
 	typedef multimap<UINT8, RenderTarget * >::type RenderTargetPriorityMap;
 
 	class TextureManager;
-	/// Enum describing the ways to generate texture coordinates
-	enum TexCoordCalcMethod
-	{
-		/// No calculated texture coordinates
-		TEXCALC_NONE,
-		/// Environment map based on vertex normals
-		TEXCALC_ENVIRONMENT_MAP,
-		/// Environment map based on vertex positions
-		TEXCALC_ENVIRONMENT_MAP_PLANAR,
-		TEXCALC_ENVIRONMENT_MAP_REFLECTION,
-		TEXCALC_ENVIRONMENT_MAP_NORMAL,
-		/// Projective texture
-		TEXCALC_PROJECTIVE_TEXTURE
-	};
-	/// Enum describing the various actions which can be taken onthe stencil buffer
-	enum StencilOperation
-	{
-		/// Leave the stencil buffer unchanged
-		SOP_KEEP,
-		/// Set the stencil value to zero
-		SOP_ZERO,
-		/// Set the stencil value to the reference value
-		SOP_REPLACE,
-		/// Increase the stencil value by 1, clamping at the maximum value
-		SOP_INCREMENT,
-		/// Decrease the stencil value by 1, clamping at 0
-		SOP_DECREMENT,
-		/// Increase the stencil value by 1, wrapping back to 0 when incrementing the maximum value
-		SOP_INCREMENT_WRAP,
-		/// Decrease the stencil value by 1, wrapping when decrementing 0
-		SOP_DECREMENT_WRAP,
-		/// Invert the bits of the stencil buffer
-		SOP_INVERT
-	};
-
 
 	/** Defines the functionality of a 3D API
 	@remarks

CamelotRenderer/Include/CmTexture.h

@@ -71,7 +71,9 @@ namespace CamelotEngine {
         /// 3D volume texture, used in combination with 3D texture coordinates
         TEX_TYPE_3D = 3,
         /// 3D cube map, used in combination with 3D texture coordinates
-        TEX_TYPE_CUBE_MAP = 4
+        TEX_TYPE_CUBE_MAP = 4,
+		// Array of 2D textures,
+		TEX_TYPE_2D_ARRAY = 5
     };
 
 	/** Enum identifying special mipmap numbers

CamelotRenderer/TODO.txt

@@ -14,6 +14,18 @@ High-level TODO:
    - Render queue and sorting
  - DX11 render system
 
+ DX11 specific features:
+  - Deferred render contexts and multithreaded rendering
+  - Tesselation (hull/domain) shader
+  - Compute pipeline
+  - Stream out (write vertex buffers)
+  - Instancing
+  - Dynamic shader linkage
+  - Append/Consume buffer
+  - What's missing:
+    - No proper support for texture arrays, or multisampled texture resources
+	- Staging and immutable buffers. See D3D11Mapping, DWORD D3D11Mappings::get(HardwareBuffer::Usage usage)
+
 
 Command buffer TODO:
  - Redo OpenGL shaders as they seem to be using pretty old methods (glCreateShaderObjectARB seems to be deprectated for example)
@@ -22,6 +34,8 @@ Command buffer TODO:
    - Instead of requiring the user to constantly call setActiveContext, make the call peristent per thread. 
    - Store sequential thread idx in local thread storage, and then we can easily look up a context for a thread and
      automatically use it, if it's set. (Use boost::thread_specific_ptr for local thread storage)
+ - Make sure to allow the user to submit the context manually to the gpu. (Right now all contexts are submitted at once, and when I'll have compute
+ shaders running I'm sure I'll want other threads to do different things on the gpu)
  - Doing setPixels_async in the texture doesn't make sure that the user doesn't actually modify the provided PixelData after
     that call.
 
@@ -68,12 +82,14 @@ Mid priority TODO:
   - Imported FBX meshes are too big
   - Search for all remaining "TODO PORT" comments and fix them
   - Ogre performed special DDS loading. I removed that. I'm not sure if I'll need to re-add it?
+  - My log is not thread safe yet it is being called from multiple threads.
  - RTTI:
      When defining RTTIType like so: 
       RTTIType<D3D9HLSLProgram, HighLevelGpuProgram, D3D9HLSLProgramRTTI>
      I need to make sure that HighLevelGpuProgram class has valid RTTI type as well. Otherwise the inheritance hierarchy will not be correct. Right now this isn't checked anywhere.
 
 Low priority TODO:
+ - Drop support for assembly shaders?
  - Move all x86 libs to x86 folders. Move all binaries to x86 folders as well
  - Mesh loading:
   - Sub-meshes aren't being transformed by world matrices of their nodes
@@ -101,8 +117,9 @@ Optional TODO:
  -----------------------------------------------------------------------------------------------
 
 After everything is polished
- - Get 64bit version working
  - DX11 render system
+   - Make sure to add OpenGL equivalents of DX11 features (tesselation, stream out, compute, etc.)
+ - SLI / multiple device support
  - How do I handle multiple mesh formats? Some files need animation, other don't. Some would mabye like to use QTangent, others the proper tangent frame.
  - Load texture mips separately so we can unload HQ textures from far away objects (like UE3)
  - Add Unified shader so I can easily switch between HLSL and GLSL shaders (they need same parameters usually, just different code)