Slight changes in DX11 window creation

CamelotD3D11RenderSystem/CamelotD3D11RenderSystem.vcxproj

@@ -171,6 +171,7 @@
     <ClInclude Include="Include\CmD3D11RenderSystemFactory.h" />
     <ClInclude Include="Include\CmD3D11RenderTexture.h" />
     <ClInclude Include="Include\CmD3D11RenderWindow.h" />
+    <ClInclude Include="Include\CmD3D11RenderWindowManager.h" />
     <ClInclude Include="Include\CmD3D11SamplerState.h" />
     <ClInclude Include="Include\CmD3D11Texture.h" />
     <ClInclude Include="Include\CmD3D11TextureManager.h" />
@@ -202,6 +203,7 @@
     <ClCompile Include="Source\CmD3D11RenderSystemFactory.cpp" />
     <ClCompile Include="Source\CmD3D11RenderTexture.cpp" />
     <ClCompile Include="Source\CmD3D11RenderWindow.cpp" />
+    <ClCompile Include="Source\CmD3D11RenderWindowManager.cpp" />
     <ClCompile Include="Source\CmD3D11SamplerState.cpp" />
     <ClCompile Include="Source\CmD3D11Texture.cpp" />
     <ClCompile Include="Source\CmD3D11TextureManager.cpp" />

CamelotD3D11RenderSystem/CamelotD3D11RenderSystem.vcxproj.filters

@@ -111,6 +111,9 @@
     <ClInclude Include="Include\CmD3D11MultiRenderTexture.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="Include\CmD3D11RenderWindowManager.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Source\CmD3D11GpuProgram.cpp">
@@ -200,5 +203,8 @@
     <ClCompile Include="Source\CmD3D11MultiRenderTexture.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="Source\CmD3D11RenderWindowManager.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

CamelotD3D11RenderSystem/Include/CmD3D11Prerequisites.h

@@ -25,7 +25,7 @@ namespace CamelotEngine
 {
 	// Predefine classes
 	class D3D11RenderSystem;
-	class D3D11RenderWindowBase;
+	class D3D11RenderWindow;
 	class D3D11Texture;
 	class D3D11TextureManager;
 	class D3D11DepthBuffer;
@@ -69,6 +69,7 @@ namespace CamelotEngine
 	typedef std::shared_ptr<D3D11RasterizerState> D3D11RasterizerStatePtr;
 	typedef std::shared_ptr<D3D11SamplerState> D3D11SamplerStatePtr;
 	typedef std::shared_ptr<D3D11DepthStencilState> D3D11DepthStencilStatePtr;
+	typedef std::shared_ptr<D3D11RenderWindow> D3D11RenderWindowPtr;
 
 // Should we ask D3D to manage vertex/index buffers automatically?
 // Doing so avoids lost devices, but also has a performance impact

CamelotD3D11RenderSystem/Include/CmD3D11RenderSystem.h

@@ -30,8 +30,8 @@ namespace CamelotEngine
 		void setViewport(const Viewport& vp);
 		void setScissorRect(UINT32 left = 0, UINT32 top = 0, UINT32 right = 800, UINT32 bottom = 600);
 
-		virtual void setVertexDeclaration(VertexDeclarationPtr decl);
-		virtual void setVertexBufferBinding(VertexBufferBinding* binding);
+		void setVertexDeclaration(VertexDeclarationPtr decl);
+		void setVertexBufferBinding(VertexBufferBinding* binding);
 
 		void bindGpuProgram(GpuProgramHandle prg);
 		void unbindGpuProgram(GpuProgramType gptype);
@@ -58,8 +58,9 @@ namespace CamelotEngine
 		void determineFSAASettings(UINT32 fsaa, const String& fsaaHint, DXGI_FORMAT format, DXGI_SAMPLE_DESC* outFSAASettings);
 		bool checkTextureFilteringSupported(TextureType ttype, PixelFormat format, int usage);
 
-		static D3D11Device& getPrimaryDevice();
-
+		IDXGIFactory* getDXGIFactory() const { return mDXGIFactory; }
+		D3D11Device& getPrimaryDevice() const { return *mDevice; }
+		
 	protected:
 		friend class D3D11RenderSystemFactory;
 		D3D11RenderSystem();
@@ -82,5 +83,7 @@ namespace CamelotEngine
 		D3D11Driver*		mActiveD3DDriver;
 
 		D3D_FEATURE_LEVEL	mFeatureLevel;
+
+		D3D11HLSLProgramFactory* mHLSLFactory;
 	};
 }

CamelotD3D11RenderSystem/Include/CmD3D11RenderWindow.h

@@ -8,7 +8,6 @@ namespace CamelotEngine
 	class CM_D3D11_EXPORT D3D11RenderWindow : public RenderWindow
 	{
 	public:
-		D3D11RenderWindow(D3D11Device& device, IDXGIFactory* DXGIFactory);
 		~D3D11RenderWindow();
 
 		void initialize(const RENDER_WINDOW_DESC& desc);
@@ -36,6 +35,9 @@ namespace CamelotEngine
 		bool requiresTextureFlipping() const					{ return false; }
 
 	protected:
+		friend class D3D11RenderWindowManager;
+		D3D11RenderWindow(D3D11Device& device, IDXGIFactory* DXGIFactory);
+
 		void _createSizeDependedD3DResources();
 		void _destroySizeDependedD3DResources();
 

CamelotD3D11RenderSystem/Include/CmD3D11RenderWindowManager.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "CmD3D11Prerequisites.h"
+#include "CmRenderWindowManager.h"
+
+namespace CamelotEngine
+{
+	class CM_D3D11_EXPORT D3D11RenderWindowManager : public RenderWindowManager
+	{
+	public:
+		D3D11RenderWindowManager(D3D11RenderSystem* renderSystem);
+
+	protected:
+		/**
+		 * @copydoc RenderWindowManager::create()
+		 */
+		void createImpl(const RENDER_WINDOW_DESC& desc, AsyncOp& asyncOp);
+
+	private:
+		D3D11RenderSystem* mRenderSystem;
+	};
+}

CamelotD3D11RenderSystem/Source/CmD3D11BlendState.cpp

@@ -34,7 +34,8 @@ namespace CamelotEngine
 			blendStateDesc.RenderTarget[i].SrcBlendAlpha = D3D11Mappings::get(desc.renderTargetDesc[i].srcBlendAlpha);
 		}
 
-		D3D11Device& device = D3D11RenderSystem::getPrimaryDevice();
+		D3D11RenderSystem* rs = static_cast<D3D11RenderSystem*>(RenderSystem::instancePtr());
+		D3D11Device& device = rs->getPrimaryDevice();
 		device.getD3D11Device()->CreateBlendState(&blendStateDesc, &mBlendState);
 	}
 }

CamelotD3D11RenderSystem/Source/CmD3D11DepthStencilBuffer.cpp

@@ -27,7 +27,7 @@ namespace CamelotEngine
 		D3D11RenderSystem* rs = static_cast<D3D11RenderSystem*>(RenderSystem::instancePtr());
 		rs->determineFSAASettings(fsaa, fsaaHint, descDepth.Format, &descDepth.SampleDesc);
 
-		D3D11Device& device = D3D11RenderSystem::getPrimaryDevice();
+		D3D11Device& device = rs->getPrimaryDevice();
 		HRESULT hr = device.getD3D11Device()->CreateTexture2D(&descDepth, NULL, &mDepthStencil);
 		if( FAILED(hr) || device.hasError())
 		{

CamelotD3D11RenderSystem/Source/CmD3D11DepthStencilState.cpp

@@ -34,7 +34,8 @@ namespace CamelotEngine
 		depthStencilState.StencilReadMask = desc.stencilReadMask;
 		depthStencilState.StencilWriteMask = desc.stencilWriteMask;
 
-		D3D11Device& device = D3D11RenderSystem::getPrimaryDevice();
+		D3D11RenderSystem* rs = static_cast<D3D11RenderSystem*>(RenderSystem::instancePtr());
+		D3D11Device& device = rs->getPrimaryDevice();
 		device.getD3D11Device()->CreateDepthStencilState(&depthStencilState, &mDepthStencilState);
 	}
 }

CamelotD3D11RenderSystem/Source/CmD3D11HLSLProgram.cpp

@@ -35,37 +35,38 @@ namespace CamelotEngine
 		createConstantBuffers();
 
 		mAssemblerProgram = GpuProgramManager::instance().createProgram("", "", "", mType, GPP_NONE); // We load it from microcode, so none of this matters
+		D3D11RenderSystem* rs = static_cast<D3D11RenderSystem*>(RenderSystem::instancePtr());
 
 		switch(mType)
 		{
 		case GPT_VERTEX_PROGRAM:
 			{
 				D3D11GpuVertexProgramPtr vertProgram = std::static_pointer_cast<D3D11GpuVertexProgram>(mAssemblerProgram);
-				vertProgram->loadFromMicrocode(D3D11RenderSystem::getPrimaryDevice(), microcode);
+				vertProgram->loadFromMicrocode(rs->getPrimaryDevice(), microcode);
 			}
 			break;
 		case GPT_FRAGMENT_PROGRAM:
 			{
 				D3D11GpuFragmentProgramPtr fragProgram = std::static_pointer_cast<D3D11GpuFragmentProgram>(mAssemblerProgram);
-				fragProgram->loadFromMicrocode(D3D11RenderSystem::getPrimaryDevice(), microcode);
+				fragProgram->loadFromMicrocode(rs->getPrimaryDevice(), microcode);
 			}
 			break;
 		case GPT_GEOMETRY_PROGRAM:
 			{
 				D3D11GpuGeometryProgramPtr geomProgram = std::static_pointer_cast<D3D11GpuGeometryProgram>(mAssemblerProgram);
-				geomProgram->loadFromMicrocode(D3D11RenderSystem::getPrimaryDevice(), microcode);
+				geomProgram->loadFromMicrocode(rs->getPrimaryDevice(), microcode);
 			}
 			break;
 		case GPT_HULL_PROGRAM:
 			{
 				D3D11GpuHullProgramPtr hullProgram = std::static_pointer_cast<D3D11GpuHullProgram>(mAssemblerProgram);
-				hullProgram->loadFromMicrocode(D3D11RenderSystem::getPrimaryDevice(), microcode);
+				hullProgram->loadFromMicrocode(rs->getPrimaryDevice(), microcode);
 			}
 			break;
 		case GPT_DOMAIN_PROGRAM:
 			{
 				D3D11GpuDomainProgramPtr domainProgram = std::static_pointer_cast<D3D11GpuDomainProgram>(mAssemblerProgram);
-				domainProgram->loadFromMicrocode(D3D11RenderSystem::getPrimaryDevice(), microcode);
+				domainProgram->loadFromMicrocode(rs->getPrimaryDevice(), microcode);
 			}
 			break;
 		}

CamelotD3D11RenderSystem/Source/CmD3D11RasterizerState.cpp

@@ -29,7 +29,8 @@ namespace CamelotEngine
 		rasterizerStateDesc.ScissorEnable = desc.scissorEnable;
 		rasterizerStateDesc.SlopeScaledDepthBias = desc.slopeScaledDepthBias;
 
-		D3D11Device& device = D3D11RenderSystem::getPrimaryDevice();
+		D3D11RenderSystem* rs = static_cast<D3D11RenderSystem*>(RenderSystem::instancePtr());
+		D3D11Device& device = rs->getPrimaryDevice();
 		device.getD3D11Device()->CreateRasterizerState(&rasterizerStateDesc, &mRasterizerState);
 	}
 }

CamelotD3D11RenderSystem/Source/CmD3D11RenderSystem.cpp

@@ -2,6 +2,11 @@
 #include "CmD3D11DriverList.h"
 #include "CmD3D11Driver.h"
 #include "CmD3D11Device.h"
+#include "CmD3D11TextureManager.h"
+#include "CmD3D11HardwareBufferManager.h"
+#include "CmD3D11GpuProgramManager.h"
+#include "CmD3D11RenderWindowManager.h"
+#include "CmD3D11HLSLProgramFactory.h"
 #include "CmRenderSystem.h"
 #include "CmDebug.h"
 #include "CmException.h"
@@ -11,6 +16,7 @@ namespace CamelotEngine
 	D3D11RenderSystem::D3D11RenderSystem()
 		: mDXGIFactory(nullptr), mDevice(nullptr), mDriverList(nullptr)
 		, mActiveD3DDriver(nullptr), mFeatureLevel(D3D_FEATURE_LEVEL_9_1)
+		, mHLSLFactory(nullptr)
 	{
 
 	}
@@ -66,11 +72,33 @@ namespace CamelotEngine
 			mDriverVersion.build = LOWORD(driverVersion.LowPart);
 		}
 
+		// Create the texture manager for use by others		
+		TextureManager::startUp(new D3D11TextureManager());
+
+		// Also create hardware buffer manager		
+		HardwareBufferManager::startUp(new D3D11HardwareBufferManager(*mDevice));
+
+		// Create the GPU program manager		
+		GpuProgramManager::startUp(new D3D11GpuProgramManager(*mDevice));
+
+		// Create render window manager
+		RenderWindowManager::startUp(new D3D11RenderWindowManager(this));
+
+		// Create & register HLSL factory		
+		mHLSLFactory = new D3D11HLSLProgramFactory();
+
 		RenderSystem::initialize_internal();
 	}
 
     void D3D11RenderSystem::destroy_internal()
 	{
+		SAFE_DELETE(mHLSLFactory);
+
+		RenderWindowManager::shutDown();
+		GpuProgramManager::shutDown();
+		HardwareBufferManager::shutDown();
+		TextureManager::shutDown();
+
 		SAFE_RELEASE(mDXGIFactory);
 		SAFE_DELETE(mDevice);
 		SAFE_DELETE(mDriverList);
@@ -116,12 +144,12 @@ namespace CamelotEngine
 
 	void D3D11RenderSystem::beginFrame()
 	{
-		throw std::exception("The method or operation is not implemented.");
+		// Not used
 	}
 
 	void D3D11RenderSystem::endFrame()
 	{
-		throw std::exception("The method or operation is not implemented.");
+		// Not used
 	}
 
 	void D3D11RenderSystem::setViewport(const Viewport& vp)
@@ -161,11 +189,22 @@ namespace CamelotEngine
 
 	void D3D11RenderSystem::clearFrameBuffer(unsigned int buffers, const Color& color /*= Color::Black*/, float depth /*= 1.0f*/, unsigned short stencil /*= 0 */)
 	{
+		//mDevice->getImmediateContext()->c
+
 		throw std::exception("The method or operation is not implemented.");
 	}
 
 	void D3D11RenderSystem::setRenderTarget(RenderTarget* target)
 	{
+		//if(target != nullptr)
+		//{
+		//	mRenderViews
+		//}
+		//else
+		//{
+
+		//}
+
 		throw std::exception("The method or operation is not implemented.");
 	}
 
@@ -184,21 +223,13 @@ namespace CamelotEngine
 		throw std::exception("The method or operation is not implemented.");
 	}
 
-	D3D11Device& D3D11RenderSystem::getPrimaryDevice() 
-	{ 
-		CM_EXCEPT(NotImplementedException, "Not implemented"); 
-	}
-
-	CamelotEngine::String D3D11RenderSystem::getErrorDescription(long errorNumber) const
+	String D3D11RenderSystem::getErrorDescription(long errorNumber) const
 	{
-		throw std::exception("The method or operation is not implemented.");
+		return mDevice->getErrorDescription();
 	}
 
-		void D3D11RenderSystem::determineFSAASettings(UINT32 fsaa, const String& fsaaHint, DXGI_FORMAT format, DXGI_SAMPLE_DESC* outFSAASettings)
+	void D3D11RenderSystem::determineFSAASettings(UINT32 fsaa, const String& fsaaHint, DXGI_FORMAT format, DXGI_SAMPLE_DESC* outFSAASettings)
 	{
-		CM_EXCEPT(NotImplementedException, "Not implemented");
-
-		/*
 		bool ok = false;
 		bool qualityHint = fsaaHint.find("Quality") != String::npos;
 		size_t origFSAA = fsaa;
@@ -256,10 +287,7 @@ namespace CamelotEngine
 
 			HRESULT hr;
 			UINT outQuality;
-			hr = mDevice->CheckMultisampleQualityLevels( 
-				format, 
-				outFSAASettings->Count, 
-				&outQuality);
+			hr = mDevice->getD3D11Device()->CheckMultisampleQualityLevels(format, outFSAASettings->Count, &outQuality);
 
 			if (SUCCEEDED(hr) && (!tryCSAA || outQuality > outFSAASettings->Quality))
 			{
@@ -300,7 +328,6 @@ namespace CamelotEngine
 			}
 
 		} // while !ok
-		*/
 	}
 
 	bool D3D11RenderSystem::checkTextureFilteringSupported(TextureType ttype, PixelFormat format, int usage)
@@ -308,7 +335,7 @@ namespace CamelotEngine
 		return true;
 	}
 
-	CamelotEngine::VertexElementType D3D11RenderSystem::getColorVertexElementType() const
+	VertexElementType D3D11RenderSystem::getColorVertexElementType() const
 	{
 		return VET_COLOR_ABGR;
 	}

CamelotD3D11RenderSystem/Source/CmD3D11RenderTexture.cpp

@@ -80,7 +80,8 @@ namespace CamelotEngine
 		}
 
 		ID3D11RenderTargetView* rtv;
-		D3D11Device& device = D3D11RenderSystem::getPrimaryDevice();
+		D3D11RenderSystem* rs = static_cast<D3D11RenderSystem*>(RenderSystem::instancePtr());
+		D3D11Device& device = rs->getPrimaryDevice();
 		HRESULT hr = device.getD3D11Device()->CreateRenderTargetView(d3d11Texture->getDX11Resource(), &RTVDesc, &rtv);
 
 		if (FAILED(hr) || device.hasError())

CamelotD3D11RenderSystem/Source/CmD3D11RenderWindowManager.cpp

@@ -0,0 +1,26 @@
+#include "CmD3D11RenderWindowManager.h"
+#include "CmD3D11RenderSystem.h"
+#include "CmD3D11RenderWindow.h"
+#include "CmAsyncOp.h"
+
+namespace CamelotEngine
+{
+	D3D11RenderWindowManager::D3D11RenderWindowManager(D3D11RenderSystem* renderSystem)
+		:mRenderSystem(renderSystem)
+	{
+		assert(mRenderSystem != nullptr);
+	}
+
+	void D3D11RenderWindowManager::createImpl(const RENDER_WINDOW_DESC& desc, AsyncOp& asyncOp)
+	{
+		RenderSystem* rs = RenderSystem::instancePtr();
+		D3D11RenderSystem* d3d11rs = static_cast<D3D11RenderSystem*>(rs);
+
+		// Create the window
+		D3D11RenderWindow* renderWindow = new D3D11RenderWindow(d3d11rs->getPrimaryDevice(), d3d11rs->getDXGIFactory());
+		renderWindow->initialize(desc);
+
+		D3D11RenderWindowPtr winPtr(renderWindow);
+		asyncOp.completeOperation(std::static_pointer_cast<RenderWindow>(winPtr));
+	}
+}

CamelotD3D11RenderSystem/Source/CmD3D11SamplerState.cpp

@@ -87,7 +87,8 @@ namespace CamelotEngine
 			samplerState.Filter = (D3D11_FILTER)(0x80 | samplerState.Filter);
 		}
 
-		D3D11Device& device = D3D11RenderSystem::getPrimaryDevice();
+		D3D11RenderSystem* rs = static_cast<D3D11RenderSystem*>(RenderSystem::instancePtr());
+		D3D11Device& device = rs->getPrimaryDevice();
 		device.getD3D11Device()->CreateSamplerState(&samplerState, &mSamplerState);
 	}
 }

CamelotD3D11RenderSystem/Source/CmD3D11Texture.cpp

@@ -38,7 +38,8 @@ namespace CamelotEngine
 	{
 		D3D11Texture* other = static_cast<D3D11Texture*>(target.get());
 
-		D3D11Device& device = D3D11RenderSystem::getPrimaryDevice();
+		D3D11RenderSystem* rs = static_cast<D3D11RenderSystem*>(RenderSystem::instancePtr());
+		D3D11Device& device = rs->getPrimaryDevice();
 		device.getImmediateContext()->CopyResource(other->getDX11Resource(), mTex);
 
 		if (device.hasError())
@@ -183,7 +184,8 @@ namespace CamelotEngine
 		}
 
 		// Create the texture
-		D3D11Device& device = D3D11RenderSystem::getPrimaryDevice();
+		D3D11RenderSystem* rs = static_cast<D3D11RenderSystem*>(RenderSystem::instancePtr());
+		D3D11Device& device = rs->getPrimaryDevice();
 		hr = device.getD3D11Device()->CreateTexture1D(&desc, nullptr, &m1DTex);
 
 		// Check result and except if failed
@@ -276,7 +278,8 @@ namespace CamelotEngine
         }
 
 		// Create the texture
-		D3D11Device& device = D3D11RenderSystem::getPrimaryDevice();
+		D3D11RenderSystem* rs = static_cast<D3D11RenderSystem*>(RenderSystem::instancePtr());
+		D3D11Device& device = rs->getPrimaryDevice();
 		hr = device.getD3D11Device()->CreateTexture2D(&desc, nullptr, &m2DTex);
 
 		// Check result and except if failed
@@ -380,7 +383,8 @@ namespace CamelotEngine
 		}
 
 		// Create the texture
-		D3D11Device& device = D3D11RenderSystem::getPrimaryDevice();
+		D3D11RenderSystem* rs = static_cast<D3D11RenderSystem*>(RenderSystem::instancePtr());
+		D3D11Device& device = rs->getPrimaryDevice();
 		hr = device.getD3D11Device()->CreateTexture3D(&desc, nullptr, &m3DTex);
 
 		// Check result and except if failed
@@ -430,7 +434,8 @@ namespace CamelotEngine
 		if(getTextureType() == TEX_TYPE_3D)
 			face = 0;
 
-		D3D11Device& device = D3D11RenderSystem::getPrimaryDevice();
+		D3D11RenderSystem* rs = static_cast<D3D11RenderSystem*>(RenderSystem::instancePtr());
+		D3D11Device& device = rs->getPrimaryDevice();
 
 		mLockedSubresourceIdx = D3D11CalcSubresource(mipLevel, face, getNumMipmaps()+1);
 		device.getImmediateContext()->Map(res, mLockedSubresourceIdx, flags, 0, &pMappedResource);
@@ -446,7 +451,8 @@ namespace CamelotEngine
 
 	void D3D11Texture::_unmap(ID3D11Resource* res)
 	{
-		D3D11Device& device = D3D11RenderSystem::getPrimaryDevice();
+		D3D11RenderSystem* rs = static_cast<D3D11RenderSystem*>(RenderSystem::instancePtr());
+		D3D11Device& device = rs->getPrimaryDevice();
 		device.getImmediateContext()->Unmap(res, mLockedSubresourceIdx);
 
 		if (device.hasError())
@@ -461,7 +467,8 @@ namespace CamelotEngine
 		if(!mStagingBuffer)
 			_createStagingBuffer();
 
-		D3D11Device& device = D3D11RenderSystem::getPrimaryDevice();
+		D3D11RenderSystem* rs = static_cast<D3D11RenderSystem*>(RenderSystem::instancePtr());
+		D3D11Device& device = rs->getPrimaryDevice();
 		device.getImmediateContext()->CopyResource(mStagingBuffer, mTex);
 
 		return _map(mStagingBuffer, flags, face, mipLevel);
@@ -488,7 +495,8 @@ namespace CamelotEngine
 		UINT32 rowWidth = D3D11Mappings::_getSizeInBytes(mStaticBuffer->getFormat(), mStaticBuffer->getWidth());
 		UINT32 sliceWidth = D3D11Mappings::_getSizeInBytes(mStaticBuffer->getFormat(), mStaticBuffer->getWidth(), mStaticBuffer->getHeight());
 
-		D3D11Device& device = D3D11RenderSystem::getPrimaryDevice();
+		D3D11RenderSystem* rs = static_cast<D3D11RenderSystem*>(RenderSystem::instancePtr());
+		D3D11Device& device = rs->getPrimaryDevice();
 		device.getImmediateContext()->UpdateSubresource(mTex, mLockedSubresourceIdx, nullptr, mStaticBuffer->data, rowWidth, sliceWidth);
 
 		if (device.hasError())
@@ -502,7 +510,8 @@ namespace CamelotEngine
 
 	void D3D11Texture::_createStagingBuffer()
 	{
-		D3D11Device& device = D3D11RenderSystem::getPrimaryDevice();
+		D3D11RenderSystem* rs = static_cast<D3D11RenderSystem*>(RenderSystem::instancePtr());
+		D3D11Device& device = rs->getPrimaryDevice();
 		switch (getTextureType())
 		{
 		case TEX_TYPE_1D:

CamelotD3D9Renderer/Include/CmD3D9RenderSystem.h

@@ -137,8 +137,6 @@ namespace CamelotEngine
 		D3D9Driver* mActiveD3DDriver;
 		/// NVPerfHUD allowed?
 		bool mUseNVPerfHUD;
-		/// Per-stage constant support? (not in main caps since D3D specific & minor)
-		bool mPerStageConstantSupport;
 		/// Fast singleton access.
 		static D3D9RenderSystem* msD3D9RenderSystem;
 

CamelotRenderer/Include/CmRenderWindow.h

@@ -100,6 +100,7 @@ namespace CamelotEngine
         /** Default constructor.
         */
         RenderWindow();
+		virtual ~RenderWindow() {}
 
         /** Creates & displays a new window.
         */

CamelotRenderer/TODO.txt

@@ -17,11 +17,22 @@
 
 
 /////
-Write a shader preprocessor?
- - Handles #include files, exposing parameters, and defining HLSL/GLSL blocks
- - Either that or provide UI support for those things?
- - I think UI actually sounds better...
- - Just writing out some thoughts, delete this in a few days
+RenderSystem::setTexture(STAGE, UINT32 slot, Texture)
+RenderSystem::setBuffer(STAGE, UINT32 slot, Buffer)
+RenderSystem::setSampler(STAGE, UINT32 slot, Sampler)
+
+RenderSystem::clearFrameBuffer
+ - Change so it accepts a RenderTarget as a parameter
+
+RenderSystem::setScissorRect(RECT[] array)
+ - Change it so it accepts an array
+
+RenderSystem::setViewport(RECT[] array)
+ - Change it so it accepts an array
+
+Modify how are Material/Pass parameters & GpuProgramParameters handled
+
+monitorIndex is ignored in DX11
 
 Creating a primary window and initializing the render system should probably be one step
  - OpenGL requires it anyway in order to get context (Make sure to update GLRenderWindowManager if I change how this works)