Removed remainining referenced to RenderSystemManager

CamelotClient/CamelotClient.cpp

@@ -9,7 +9,6 @@
 #include "CmGameObject.h"
 #include "CmCamera.h"
 #include "CmHighLevelGpuProgramManager.h"
-#include "CmRenderSystemManager.h"
 #include "CmRenderSystem.h"
 #include "CmRenderWindow.h"
 #include "CmResources.h"
@@ -30,7 +29,7 @@ int _tmain(int argc, _TCHAR* argv[])
 	gApplication().startUp("CamelotGLRenderSystem", "CamelotForwardRenderer");
 	//gApplication().startUp("CamelotD3D9RenderSystem", "CamelotForwardRenderer");
 
-	RenderSystem* renderSystem = RenderSystemManager::getActive();
+	RenderSystem* renderSystem = RenderSystem::instancePtr();
 	RenderWindowPtr renderWindow = gApplication().getPrimaryRenderWindow();
 
 	GameObjectPtr cameraGO = GameObject::create("MainCamera");

CamelotD3D11RenderSystem/Source/CmD3D11HLSLProgram.cpp

@@ -1,5 +1,4 @@
 #include "CmD3D11HLSLProgram.h"
-#include "CmRenderSystemManager.h"
 #include "CmRenderSystem.h"
 #include "CmGpuProgramManager.h"
 #include "CmD3D11GpuProgram.h"
@@ -92,7 +91,7 @@ namespace CamelotEngine
 
 	bool D3D11HLSLProgram::isSupported() const
 	{
-		RenderSystem* rs = RenderSystemManager::getActive();
+		RenderSystem* rs = RenderSystem::instancePtr();
 
 		return rs->getCapabilities()->isShaderProfileSupported(getSyntaxCode()) && HighLevelGpuProgram::isSupported();
 	}

CamelotD3D9Renderer/Source/CmD3D9Device.cpp

@@ -33,7 +33,6 @@ THE SOFTWARE.
 #include "CmD3D9RenderWindow.h"
 #include "CmHardwareBufferManager.h"
 #include "CmException.h"
-#include "CmRenderSystemManager.h"
 
 namespace CamelotEngine
 {
@@ -202,7 +201,7 @@ namespace CamelotEngine
 	{
 		if (mpDevice != NULL)
 		{
-			D3D9RenderSystem* renderSystem = static_cast<D3D9RenderSystem*>(CamelotEngine::RenderSystemManager::getActive());
+			D3D9RenderSystem* renderSystem = static_cast<D3D9RenderSystem*>(CamelotEngine::RenderSystem::instancePtr());
 
 			//// Clean up depth stencil surfaces
 			//renderSystem->_cleanupDepthStencils(mpDevice);	
@@ -241,7 +240,7 @@ namespace CamelotEngine
 		// Case we just moved from valid state to lost state.
 		mDeviceLost = true;	
 
-		D3D9RenderSystem* renderSystem = static_cast<D3D9RenderSystem*>(CamelotEngine::RenderSystemManager::getActive());
+		D3D9RenderSystem* renderSystem = static_cast<D3D9RenderSystem*>(CamelotEngine::RenderSystem::instancePtr());
 
 		renderSystem->notifyOnDeviceLost(this);
 	}	
@@ -366,7 +365,7 @@ namespace CamelotEngine
 		// Lock access to rendering device.
 		D3D9RenderSystem::getResourceManager()->lockDeviceAccess();
 					
-		D3D9RenderSystem* renderSystem = static_cast<D3D9RenderSystem*>(CamelotEngine::RenderSystemManager::getActive());
+		D3D9RenderSystem* renderSystem = static_cast<D3D9RenderSystem*>(CamelotEngine::RenderSystem::instancePtr());
 
 		// Inform all resources that device lost.
 		D3D9RenderSystem::getResourceManager()->notifyOnDeviceLost(mpDevice);
@@ -576,7 +575,7 @@ namespace CamelotEngine
 	//---------------------------------------------------------------------
 	void D3D9Device::clearDeviceStreams()
 	{
-		D3D9RenderSystem* renderSystem = static_cast<D3D9RenderSystem*>(CamelotEngine::RenderSystemManager::getActive());
+		D3D9RenderSystem* renderSystem = static_cast<D3D9RenderSystem*>(CamelotEngine::RenderSystem::instancePtr());
 
 		// Set all texture units to nothing to release texture surfaces
 		for (DWORD stage = 0; stage < mD3D9DeviceCaps.MaxSimultaneousTextures; ++stage)

CamelotD3D9Renderer/Source/CmD3D9DeviceManager.cpp

@@ -32,7 +32,6 @@ THE SOFTWARE.
 #include "CmD3D9Driver.h"
 #include "CmD3D9DriverList.h"
 #include "CmException.h"
-#include "CmRenderSystemManager.h"
 
 namespace CamelotEngine
 {
@@ -63,7 +62,7 @@ namespace CamelotEngine
 		{
 			mActiveDevice = device;
 
-			D3D9RenderSystem* renderSystem = static_cast<D3D9RenderSystem*>(CamelotEngine::RenderSystemManager::getActive());
+			D3D9RenderSystem* renderSystem = static_cast<D3D9RenderSystem*>(CamelotEngine::RenderSystem::instancePtr());
 			D3D9DriverList*		driverList	 = renderSystem->getDirect3DDrivers();
 
 			// Update the active driver member.
@@ -152,7 +151,7 @@ namespace CamelotEngine
 	//---------------------------------------------------------------------
 	D3D9Device* D3D9DeviceManager::selectDevice(D3D9RenderWindow* renderWindow, D3D9RenderWindowList& renderWindowsGroup)
 	{
-		D3D9RenderSystem*		renderSystem	 = static_cast<D3D9RenderSystem*>(CamelotEngine::RenderSystemManager::getActive());
+		D3D9RenderSystem*		renderSystem	 = static_cast<D3D9RenderSystem*>(CamelotEngine::RenderSystem::instancePtr());
 		D3D9Device*				renderDevice	 = NULL;	
 		IDirect3D9*				direct3D9	     = D3D9RenderSystem::getDirect3D9();
 		UINT					nAdapterOrdinal  = D3DADAPTER_DEFAULT;
@@ -403,7 +402,7 @@ namespace CamelotEngine
 	//-----------------------------------------------------------------------
 	D3D9Driver* D3D9DeviceManager::findDriver(D3D9RenderWindow* renderWindow)
 	{
-		D3D9RenderSystem*		renderSystem	 = static_cast<D3D9RenderSystem*>(CamelotEngine::RenderSystemManager::getActive());		
+		D3D9RenderSystem*		renderSystem	 = static_cast<D3D9RenderSystem*>(CamelotEngine::RenderSystem::instancePtr());		
 		IDirect3D9*				direct3D9	     = D3D9RenderSystem::getDirect3D9();
 		UINT					nAdapterOrdinal  = D3DADAPTER_DEFAULT;						
 		HMONITOR				hRenderWindowMonitor = NULL;			

CamelotD3D9Renderer/Source/CmD3D9HLSLProgram.cpp

@@ -30,7 +30,6 @@ THE SOFTWARE.
 #include "CmD3D9GpuProgram.h"
 #include "CmException.h"
 #include "CmRenderSystem.h"
-#include "CmRenderSystemManager.h"
 #include "CmAsyncOp.h"
 #include "CmD3D9HLSLProgramRTTI.h"
 
@@ -537,7 +536,7 @@ namespace CamelotEngine {
 
 		String hlslProfile = GpuProgramManager::instance().gpuProgProfileToRSSpecificProfile(mProfile);
 
-		RenderSystem* rs = CamelotEngine::RenderSystemManager::getActive();
+		RenderSystem* rs = CamelotEngine::RenderSystem::instancePtr();
 		return rs->getCapabilities()->isShaderProfileSupported(hlslProfile);
     }
     //-----------------------------------------------------------------------

CamelotD3D9Renderer/Source/CmD3D9HardwarePixelBuffer.cpp

@@ -31,7 +31,6 @@ THE SOFTWARE.
 #include "CmException.h"
 #include "CmBitwise.h"
 #include "CmRenderSystem.h"
-#include "CmRenderSystemManager.h"
 
 namespace CamelotEngine {
 
@@ -942,7 +941,7 @@ void D3D9HardwarePixelBuffer::updateRenderTexture(bool writeGamma, UINT32 fsaa,
 
 		mRenderTexture = new D3D9RenderTexture(name, this, writeGamma, fsaa);		
 
-		CamelotEngine::RenderSystemManager::getActive()->attachRenderTarget(*mRenderTexture);
+		CamelotEngine::RenderSystem::instancePtr()->attachRenderTarget(*mRenderTexture);
 	}
 }
 //-----------------------------------------------------------------------------    
@@ -950,7 +949,7 @@ void D3D9HardwarePixelBuffer::destroyRenderTexture()
 {
 	if (mRenderTexture != NULL)
 	{
-		CamelotEngine::RenderSystemManager::getActive()->destroyRenderTarget(mRenderTexture);
+		CamelotEngine::RenderSystem::instancePtr()->destroyRenderTarget(mRenderTexture);
 		mRenderTexture = NULL;
 	}
 }

CamelotD3D9Renderer/Source/CmD3D9MultiRenderTarget.cpp

@@ -32,7 +32,6 @@ THE SOFTWARE.
 #include "CmD3D9RenderSystem.h"
 #include "CmD3D9Device.h"
 #include "CmD3D9DeviceManager.h"
-#include "CmRenderSystemManager.h"
 
 namespace CamelotEngine 
 {
@@ -70,7 +69,7 @@ namespace CamelotEngine
 				CM_EXCEPT(InvalidParametersException, "MultiRenderTarget surfaces are not of same size");
 			}
 
-			if (!CamelotEngine::RenderSystemManager::getActive()->getCapabilities()->hasCapability(RSC_MRT_DIFFERENT_BIT_DEPTHS)
+			if (!CamelotEngine::RenderSystem::instancePtr()->getCapabilities()->hasCapability(RSC_MRT_DIFFERENT_BIT_DEPTHS)
 				&& (PixelUtil::getNumElemBits(mRenderTargets[y]->getFormat()) != 
 				PixelUtil::getNumElemBits(buffer->getFormat())))
 			{

CamelotD3D9Renderer/Source/CmD3D9RenderWindow.cpp

@@ -33,7 +33,6 @@ THE SOFTWARE.
 #include "CmBitwise.h"
 #include "CmWindowEventUtilities.h"
 #include "CmD3D9DeviceManager.h"
-#include "CmRenderSystemManager.h"
 
 namespace CamelotEngine
 {
@@ -598,7 +597,7 @@ namespace CamelotEngine
 			// 16-bit depth, software stencil
 			presentParams->AutoDepthStencilFormat	= D3DFMT_D16;
 
-		D3D9RenderSystem* rsys = static_cast<D3D9RenderSystem*>(CamelotEngine::RenderSystemManager::getActive());
+		D3D9RenderSystem* rsys = static_cast<D3D9RenderSystem*>(CamelotEngine::RenderSystem::instancePtr());
 
 		rsys->determineFSAASettings(mDevice->getD3D9Device(),
 			mFSAA, mFSAAHint, presentParams->BackBufferFormat, mIsFullScreen, 

CamelotD3D9Renderer/Source/CmD3D9Texture.cpp

@@ -35,7 +35,6 @@ THE SOFTWARE.
 #include "CmD3D9Device.h"
 #include "CmD3D9DeviceManager.h"
 #include "CmD3D9ResourceManager.h"
-#include "CmRenderSystemManager.h"
 
 #if CM_DEBUG_MODE
 #define THROW_IF_NOT_RENDER_THREAD throwIfNotRenderThread();
@@ -390,7 +389,7 @@ namespace CamelotEngine
 		// Check FSAA level
 		if (mUsage & TU_RENDERTARGET)
 		{
-			D3D9RenderSystem* rsys = static_cast<D3D9RenderSystem*>(CamelotEngine::RenderSystemManager::getActive());
+			D3D9RenderSystem* rsys = static_cast<D3D9RenderSystem*>(CamelotEngine::RenderSystem::instancePtr());
 			rsys->determineFSAASettings(d3d9Device, mFSAA, mFSAAHint, d3dPF, false, 
 				&mFSAAType, &mFSAAQuality);
 		}
@@ -518,7 +517,7 @@ namespace CamelotEngine
 		// Check FSAA level
 		if (mUsage & TU_RENDERTARGET)
 		{
-			D3D9RenderSystem* rsys = static_cast<D3D9RenderSystem*>(CamelotEngine::RenderSystemManager::getActive());
+			D3D9RenderSystem* rsys = static_cast<D3D9RenderSystem*>(CamelotEngine::RenderSystem::instancePtr());
 			rsys->determineFSAASettings(d3d9Device, mFSAA, mFSAAHint, d3dPF, false, 
 				&mFSAAType, &mFSAAQuality);
 		}

CamelotD3D9Renderer/Source/CmD3D9TextureManager.cpp

@@ -30,7 +30,6 @@ THE SOFTWARE.
 #include "CmException.h"
 #include "CmD3D9Mappings.h"
 #include "CmD3D9RenderSystem.h"
-#include "CmRenderSystemManager.h"
 
 namespace CamelotEngine 
 {
@@ -95,7 +94,7 @@ namespace CamelotEngine
             format = getNativeFormat(ttype, format, usage);
 
         D3D9RenderSystem* rs = static_cast<D3D9RenderSystem*>(
-            CamelotEngine::RenderSystemManager::getActive());
+            CamelotEngine::RenderSystem::instancePtr());
 
         return rs->checkTextureFilteringSupported(ttype, format, usage);
     }

CamelotGLRenderer/Source/CmGLFrameBufferObject.cpp

@@ -29,7 +29,6 @@ THE SOFTWARE.
 #include "CmGLFrameBufferObject.h"
 #include "CmGLPixelFormat.h"
 #include "CmGLHardwarePixelBuffer.h"
-#include "CmRenderSystemManager.h"
 #include "CmGLRenderTexture.h"
 
 namespace CamelotEngine {
@@ -123,7 +122,7 @@ namespace CamelotEngine {
         UINT32 height = mColour[0].buffer->getHeight();
         GLuint glformat = mColour[0].buffer->getGLFormat();
         PixelFormat format = mColour[0].buffer->getFormat();
-        UINT16 maxSupportedMRTs = CamelotEngine::RenderSystemManager::getActive()->getCapabilities()->getNumMultiRenderTargets();
+        UINT16 maxSupportedMRTs = CamelotEngine::RenderSystem::instancePtr()->getCapabilities()->getNumMultiRenderTargets();
 
 		// Bind simple buffer to add colour attachments
 		glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, mFB);

CamelotGLRenderer/Source/CmGLHardwareBufferManager.cpp

@@ -31,7 +31,6 @@ THE SOFTWARE.
 #include "CmHardwareBuffer.h"
 #include "CmRenderSystem.h"
 #include "CmRenderSystemCapabilities.h"
-#include "CmRenderSystemManager.h"
 
 namespace CamelotEngine {
     //-----------------------------------------------------------------------
@@ -66,7 +65,7 @@ namespace CamelotEngine {
 		// Win32 machines with ATI GPU are having issues glMapBuffer, looks like buffer corruption
 		// disable for now until we figure out where the problem lies			
 #	if CM_PLATFORM == CM_PLATFORM_WIN32
-		if (CamelotEngine::RenderSystemManager::getActive()->getCapabilities()->getVendor() == GPU_ATI) 
+		if (CamelotEngine::RenderSystem::instancePtr()->getCapabilities()->getVendor() == GPU_ATI) 
 		{
 			mMapBufferThreshold = 0xffffffffUL  /* maximum unsigned long value */;
 		}

CamelotGLRenderer/Source/CmGLHardwarePixelBuffer.cpp

@@ -32,7 +32,6 @@ THE SOFTWARE.
 #include "CmException.h"
 #include "CmBitwise.h"
 #include "CmGLRenderTexture.h"
-#include "CmRenderSystemManager.h"
 
 namespace CamelotEngine {
 //----------------------------------------------------------------------------- 
@@ -255,7 +254,7 @@ GLTextureBuffer::GLTextureBuffer(const String &baseName, GLenum target, GLuint i
             surface.zoffset = zoffset;
             RenderTexture *trt = GLRTTManager::instance().createRenderTexture(name, surface, writeGamma, fsaa);
             mSliceTRT.push_back(trt);
-            CamelotEngine::RenderSystemManager::getActive()->attachRenderTarget(*mSliceTRT[zoffset]);
+            CamelotEngine::RenderSystem::instancePtr()->attachRenderTarget(*mSliceTRT[zoffset]);
         }
 	}
 }
@@ -267,7 +266,7 @@ GLTextureBuffer::~GLTextureBuffer()
         // was deleted by the user.
         for (SliceTRT::const_iterator it = mSliceTRT.begin(); it != mSliceTRT.end(); ++it)
         {
-			CamelotEngine::RenderSystemManager::getActive()->destroyRenderTarget(*it);
+			CamelotEngine::RenderSystem::instancePtr()->destroyRenderTarget(*it);
         }
 	}
 }
@@ -565,7 +564,7 @@ void GLTextureBuffer::blitFromTexture(GLTextureBuffer *src, const Box &srcBox, c
         GL_TEXTURE_BIT | GL_VIEWPORT_BIT);
 
 	// Important to disable all other texture units
-	RenderSystem* rsys = CamelotEngine::RenderSystemManager::getActive();
+	RenderSystem* rsys = CamelotEngine::RenderSystem::instancePtr();
 	rsys->disableTextureUnitsFrom(0);
 	if (GLEW_VERSION_1_2)
 	{

CamelotGLRenderer/Source/CmGLPixelFormat.cpp

@@ -29,7 +29,6 @@ THE SOFTWARE.
 #include "CmGLPixelFormat.h"
 #include "CmRenderSystem.h"
 #include "CmBitwise.h"
-#include "CmRenderSystemManager.h"
 
 namespace CamelotEngine  {
 	//-----------------------------------------------------------------------------
@@ -373,7 +372,7 @@ namespace CamelotEngine  {
     //-----------------------------------------------------------------------------    
     UINT32 GLPixelUtil::optionalPO2(UINT32 value)
     {
-        const RenderSystemCapabilities *caps = CamelotEngine::RenderSystemManager::getActive()->getCapabilities();
+        const RenderSystemCapabilities *caps = CamelotEngine::RenderSystem::instancePtr()->getCapabilities();
         if(caps->hasCapability(RSC_NON_POWER_OF_2_TEXTURES))
             return value;
         else

CamelotGLRenderer/Source/CmGLTexture.cpp

@@ -36,7 +36,6 @@ THE SOFTWARE.
 #include "CmException.h"
 #include "CmBitwise.h"
 #include "CmTextureManager.h"
-#include "CmRenderSystemManager.h"
 
 #include "CmGLRenderTexture.h"
 

CamelotGLRenderer/Source/CmGLTextureManager.cpp

@@ -29,7 +29,6 @@ THE SOFTWARE.
 #include "CmGLTextureManager.h"
 #include "CmRenderSystem.h"
 #include "CmGLRenderTexture.h"
-#include "CmRenderSystemManager.h"
 
 namespace CamelotEngine {
     //-----------------------------------------------------------------------------
@@ -84,7 +83,7 @@ namespace CamelotEngine {
 	PixelFormat GLTextureManager::getNativeFormat(TextureType ttype, PixelFormat format, int usage)
 	{
 		// Adjust requested parameters to capabilities
-        const RenderSystemCapabilities *caps = CamelotEngine::RenderSystemManager::getActive()->getCapabilities();
+        const RenderSystemCapabilities *caps = CamelotEngine::RenderSystem::instancePtr()->getCapabilities();
 
 		// Check compressed texture support
 		// if a compressed format not supported, revert to PF_A8R8G8B8

CamelotGLRenderer/Source/CmWin32Window.cpp

@@ -36,7 +36,6 @@ THE SOFTWARE.
 #include "CmWin32Context.h"
 #include "CmWindowEventUtilities.h"
 #include "CmGLPixelFormat.h"
-#include "CmRenderSystemManager.h"
 
 namespace CamelotEngine {
 

CamelotGLRenderer/Source/win32/CmWin32Context.cpp

@@ -32,7 +32,6 @@ THE SOFTWARE.
 #include "CmWin32Context.h"
 #include "CmException.h"
 #include "CmGLRenderSystem.h"
-#include "CmRenderSystemManager.h"
 
 namespace CamelotEngine {
 
@@ -47,7 +46,7 @@ namespace CamelotEngine {
     {
 		// NB have to do this is subclass to ensure any methods called back
 		// are on this subclass and not half-destructed superclass
-		GLRenderSystem *rs = static_cast<GLRenderSystem*>(CamelotEngine::RenderSystemManager::getActive());
+		GLRenderSystem *rs = static_cast<GLRenderSystem*>(CamelotEngine::RenderSystem::instancePtr());
 		rs->unregisterContext(this);
     }
         

CamelotRenderer/Include/CmRenderSystemManager.h

@@ -11,7 +11,6 @@ namespace CamelotEngine
 	{
 	public:
 		static void startUp(const String& name);
-		static RenderSystem* getActive();
 
 		static void registerRenderSystemFactory(RenderSystemFactoryPtr factory);
 	private:

CamelotRenderer/Source/CmApplication.cpp

@@ -49,7 +49,7 @@ namespace CamelotEngine
 		loadPlugin(rendererName);
 		RendererManager::setActive("ForwardRenderer");
 
-		RenderSystem* renderSystem = RenderSystemManager::getActive();
+		RenderSystem* renderSystem = RenderSystem::instancePtr();
 
 		mPrimaryRenderWindow = RenderWindow::create("Camelot Renderer", 1280, 720, false);
 		mPrimaryRenderContext = renderSystem->createDeferredContext();
@@ -70,7 +70,7 @@ namespace CamelotEngine
 		{
 			gSceneManager().update();
 
-			RenderSystem* renderSystem = RenderSystemManager::getActive();
+			RenderSystem* renderSystem = RenderSystem::instancePtr();
 			renderSystem->queueCommand(boost::bind(&Application::updateMessagePump, this));
 			renderSystem->queueCommand(boost::bind(&Application::updateResourcesCallback, this));
 

CamelotRenderer/Source/CmCamera.cpp

@@ -36,7 +36,6 @@ THE SOFTWARE.
 #include "CmHardwareBufferManager.h"
 #include "CmHardwareVertexBuffer.h"
 #include "CmHardwareIndexBuffer.h"
-#include "CmRenderSystemManager.h"
 #include "CmException.h"
 #include "CmRenderSystem.h"
 #include "CmGameObject.h"
@@ -495,7 +494,7 @@ namespace CamelotEngine {
 			} // ortho            
 		} // !mCustomProjMatrix
 
-		RenderSystem* renderSystem = CamelotEngine::RenderSystemManager::getActive();
+		RenderSystem* renderSystem = CamelotEngine::RenderSystem::instancePtr();
 		// API specific
 		renderSystem->convertProjectionMatrix(mProjMatrix, mProjMatrixRS);
 		// API specific for Gpu Programs

CamelotRenderer/Source/CmCommandQueue.cpp

@@ -1,6 +1,5 @@
 #include "CmCommandQueue.h"
 #include "CmException.h"
-#include "CmRenderSystemManager.h"
 #include "CmRenderSystem.h"
 #include "CmDebug.h"
 
@@ -75,7 +74,7 @@ namespace CamelotEngine
 	void CommandQueue::playback(vector<CommandQueue::Command>::type* commands, boost::function<void(UINT32)> notifyCallback)
 	{
 #if CM_DEBUG_MODE
-		RenderSystem* rs = RenderSystemManager::getActive();
+		RenderSystem* rs = RenderSystem::instancePtr();
 
 		if(rs->getRenderThreadId() != CM_THREAD_CURRENT_ID)
 			CM_EXCEPT(InternalErrorException, "This method should only be called from the render thread.");

CamelotRenderer/Source/CmDeferredRenderContext.cpp

@@ -1,6 +1,5 @@
 #include "CmDeferredRenderContext.h"
 #include "CmCommandQueue.h"
-#include "CmRenderSystemManager.h"
 #include "CmRenderSystem.h"
 #include "CmBlendState.h"
 #include "CmRasterizerState.h"
@@ -153,7 +152,7 @@ namespace CamelotEngine
 	{
 		vector<CommandQueue::Command>::type* commands = mCommandQueue->flush();
 
-		RenderSystem* rs = RenderSystemManager::getActive();
+		RenderSystem* rs = RenderSystem::instancePtr();
 		rs->queueCommand(boost::bind(&CommandQueue::playback, mCommandQueue, commands));
 	}
 }

CamelotRenderer/Source/CmGpuProgram.cpp

@@ -32,7 +32,6 @@ THE SOFTWARE.
 #include "CmRenderSystemCapabilities.h"
 #include "CmException.h"
 #include "CmRenderSystem.h"
-#include "CmRenderSystemManager.h"
 #include "CmAsyncOp.h"
 #include "CmGpuProgramRTTI.h"
 
@@ -60,7 +59,7 @@ namespace CamelotEngine
 	//-----------------------------------------------------------------------------
 	void GpuProgram::initialize()
 	{
-		RenderSystemManager::getActive()->queueCommand(boost::bind(&GpuProgram::initialize_internal, this));
+		RenderSystem::instancePtr()->queueCommand(boost::bind(&GpuProgram::initialize_internal, this));
 	}
     //-----------------------------------------------------------------------------
     void GpuProgram::initialize_internal(void)
@@ -93,7 +92,7 @@ namespace CamelotEngine
         if (mCompileError || !isRequiredCapabilitiesSupported())
             return false;
 
-		RenderSystem* rs = CamelotEngine::RenderSystemManager::getActive();
+		RenderSystem* rs = CamelotEngine::RenderSystem::instancePtr();
 		return rs->getCapabilities()->isShaderProfileSupported(mSyntaxCode);
     }
 	//-----------------------------------------------------------------------------
@@ -128,7 +127,7 @@ namespace CamelotEngine
 	//---------------------------------------------------------------------
 	GpuProgramParametersSharedPtr GpuProgram::createParameters(void)
 	{
-		AsyncOp op = RenderSystemManager::getActive()->queueReturnCommand(boost::bind(&GpuProgram::createParameters_internal, this, _1), true);
+		AsyncOp op = RenderSystem::instancePtr()->queueReturnCommand(boost::bind(&GpuProgram::createParameters_internal, this, _1), true);
 
 		return op.getReturnValue<GpuProgramParametersSharedPtr>();
 	}
@@ -166,7 +165,7 @@ namespace CamelotEngine
 	//----------------------------------------------------------------------------- 
 	void GpuProgram::throwIfNotRenderThread() const
 	{
-		if(CM_THREAD_CURRENT_ID != RenderSystemManager::getActive()->getRenderThreadId())
+		if(CM_THREAD_CURRENT_ID != RenderSystem::instancePtr()->getRenderThreadId())
 			CM_EXCEPT(InternalErrorException, "Calling an internal texture method from a non-render thread!");
 	}
 

CamelotRenderer/Source/CmGpuProgramManager.cpp

@@ -28,7 +28,6 @@ THE SOFTWARE.
 #include "CmGpuProgramManager.h"
 //#include "CmHighLevelGpuProgramManager.h"
 #include "CmRenderSystem.h"
-#include "CmRenderSystemManager.h"
 
 
 namespace CamelotEngine {
@@ -45,7 +44,7 @@ namespace CamelotEngine {
 	//-------------------------------------------------------------------------
 	void GpuProgramManager::destroy(GpuProgram* program)
 	{
-		RenderSystemManager::getActive()->queueCommand(boost::bind(&GpuProgramManager::destroy_internal, this, program));
+		RenderSystem::instancePtr()->queueCommand(boost::bind(&GpuProgramManager::destroy_internal, this, program));
 	}
 	//-------------------------------------------------------------------------
 	void GpuProgramManager::destroy_internal(GpuProgram* program)
@@ -64,7 +63,7 @@ namespace CamelotEngine {
 		const GpuProgramManager::SyntaxCodes& GpuProgramManager::getSupportedSyntax(void) const
         {
 			// Use the current render system
-			RenderSystem* rs = CamelotEngine::RenderSystemManager::getActive();
+			RenderSystem* rs = CamelotEngine::RenderSystem::instancePtr();
 
 			// Get the supported syntaxed from RenderSystemCapabilities 
 			return rs->getCapabilities()->getSupportedShaderProfiles();
@@ -74,7 +73,7 @@ namespace CamelotEngine {
     bool GpuProgramManager::isSyntaxSupported(const String& syntaxCode) const
         {
 			// Use the current render system
-			RenderSystem* rs = CamelotEngine::RenderSystemManager::getActive();
+			RenderSystem* rs = CamelotEngine::RenderSystem::instancePtr();
 
 			// Get the supported syntaxed from RenderSystemCapabilities 
 			return rs->getCapabilities()->isShaderProfileSupported(syntaxCode);
@@ -84,7 +83,7 @@ namespace CamelotEngine {
 	String GpuProgramManager::gpuProgProfileToRSSpecificProfile(GpuProgramProfile gpuProgProfile) const
 	{
 		// Use the current render system
-		RenderSystem* rs = CamelotEngine::RenderSystemManager::getActive();
+		RenderSystem* rs = CamelotEngine::RenderSystem::instancePtr();
 
 		return  rs->getCapabilities()->gpuProgProfileToRSSpecificProfile(gpuProgProfile);
 	}

CamelotRenderer/Source/CmHardwareVertexBuffer.cpp

@@ -32,7 +32,6 @@ THE SOFTWARE.
 #include "CmHardwareBufferManager.h"
 #include "CmDefaultHardwareBufferManager.h"
 #include "CmRenderSystem.h"
-#include "CmRenderSystemManager.h"
 #include "CmVertexDeclarationRTTI.h"
 
 namespace CamelotEngine {
@@ -175,9 +174,9 @@ namespace CamelotEngine {
 	VertexElementType VertexElement::getBestColourVertexElementType(void)
 	{
 		// Use the current render system to determine if possible
-		if (CamelotEngine::RenderSystemManager::getActive())
+		if (CamelotEngine::RenderSystem::instancePtr())
 		{
-			return CamelotEngine::RenderSystemManager::getActive()->getColorVertexElementType();
+			return CamelotEngine::RenderSystem::instancePtr()->getColorVertexElementType();
 		}
 		else
 		{

CamelotRenderer/Source/CmHighLevelGpuProgram.cpp

@@ -27,11 +27,9 @@ THE SOFTWARE.
 */
 #include "CmHighLevelGpuProgram.h"
 #include "CmHighLevelGpuProgramManager.h"
-#include "CmRenderSystemManager.h"
 #include "CmRenderSystem.h"
 #include "CmException.h"
 #include "CmRenderSystem.h"
-#include "CmRenderSystemManager.h"
 #include "CmAsyncOp.h"
 
 #if CM_DEBUG_MODE
@@ -52,7 +50,7 @@ namespace CamelotEngine
 	//---------------------------------------------------------------------------
 	void HighLevelGpuProgram::initialize()
 	{
-		RenderSystemManager::getActive()->queueCommand(boost::bind(&HighLevelGpuProgram::initialize_internal, this));
+		RenderSystem::instancePtr()->queueCommand(boost::bind(&HighLevelGpuProgram::initialize_internal, this));
 	}
     //---------------------------------------------------------------------------
     void HighLevelGpuProgram::initialize_internal()

CamelotRenderer/Source/CmHighLevelGpuProgramManager.cpp

@@ -26,7 +26,6 @@ THE SOFTWARE.
 -----------------------------------------------------------------------------
 */
 #include "CmHighLevelGpuProgramManager.h"
-#include "CmRenderSystemManager.h"
 #include "CmRenderSystem.h"
 
 namespace CamelotEngine {
@@ -136,7 +135,7 @@ namespace CamelotEngine {
 	//---------------------------------------------------------------------------
 	void HighLevelGpuProgramFactory::destroy(HighLevelGpuProgram* prog)
 	{
-		RenderSystemManager::getActive()->queueCommand(boost::bind(&HighLevelGpuProgramFactory::destroy_internal, this, prog));
+		RenderSystem::instancePtr()->queueCommand(boost::bind(&HighLevelGpuProgramFactory::destroy_internal, this, prog));
 	}
 	//---------------------------------------------------------------------
 	bool HighLevelGpuProgramManager::isLanguageSupported(const String& lang)

CamelotRenderer/Source/CmMaterial.cpp

@@ -3,7 +3,6 @@
 #include "CmShader.h"
 #include "CmTechnique.h"
 #include "CmPass.h"
-#include "CmRenderSystemManager.h"
 #include "CmRenderSystem.h"
 #include "CmGpuProgramParams.h"
 #include "CmGpuProgram.h"

CamelotRenderer/Source/CmMesh.cpp

@@ -6,7 +6,6 @@
 #include "CmDebug.h"
 #include "CmHardwareBufferManager.h"
 #include "CmRenderSystem.h"
-#include "CmRenderSystemManager.h"
 #include "CmAsyncOp.h"
 
 #if CM_DEBUG_MODE
@@ -36,7 +35,7 @@ namespace CamelotEngine
 
 	void Mesh::setMeshData(MeshDataPtr meshData)
 	{
-		RenderSystemManager::getActive()->queueCommand(boost::bind(&Mesh::setMeshData_internal, this, meshData));
+		RenderSystem::instancePtr()->queueCommand(boost::bind(&Mesh::setMeshData_internal, this, meshData));
 	}
 
 	void Mesh::setMeshData_internal(MeshDataPtr meshData)
@@ -168,7 +167,7 @@ namespace CamelotEngine
 
 	MeshDataPtr Mesh::getMeshData()
 	{
-		AsyncOp op = RenderSystemManager::getActive()->queueReturnCommand(boost::bind(&Mesh::getMeshData_internal, this, _1), true);
+		AsyncOp op = RenderSystem::instancePtr()->queueReturnCommand(boost::bind(&Mesh::getMeshData_internal, this, _1), true);
 
 		return op.getReturnValue<MeshDataPtr>();
 	}
@@ -306,7 +305,7 @@ namespace CamelotEngine
 	}
 	void Mesh::initialize()
 	{
-		RenderSystemManager::getActive()->queueCommand(boost::bind(&Mesh::initialize_internal, this));
+		RenderSystem::instancePtr()->queueCommand(boost::bind(&Mesh::initialize_internal, this));
 	}
 
 	void Mesh::initialize_internal()
@@ -323,7 +322,7 @@ namespace CamelotEngine
 
 	void Mesh::throwIfNotRenderThread() const
 	{
-		if(CM_THREAD_CURRENT_ID != RenderSystemManager::getActive()->getRenderThreadId())
+		if(CM_THREAD_CURRENT_ID != RenderSystem::instancePtr()->getRenderThreadId())
 			CM_EXCEPT(InternalErrorException, "Calling an internal texture method from a non-render thread!");
 	}
 

CamelotRenderer/Source/CmRenderSystemManager.cpp

@@ -41,9 +41,4 @@ namespace CamelotEngine
 		static std::vector<RenderSystemFactoryPtr> availableFactories;
 		return availableFactories;
 	}
-
-	RenderSystem* RenderSystemManager::getActive()
-	{
-		return RenderSystem::instancePtr();
-	}
 }

CamelotRenderer/Source/CmRenderTarget.cpp

@@ -30,7 +30,6 @@ THE SOFTWARE.
 #include "CmViewport.h"
 #include "CmException.h"
 #include "CmRenderSystem.h"
-#include "CmRenderSystemManager.h"
 
 namespace CamelotEngine {
 
@@ -122,7 +121,7 @@ namespace CamelotEngine {
 		if (swap)
 		{
 			// Swap buffers
-    	    swapBuffers(CamelotEngine::RenderSystemManager::getActive()->getWaitForVerticalBlank());
+    	    swapBuffers(CamelotEngine::RenderSystem::instancePtr()->getWaitForVerticalBlank());
 		}
     }
 	

CamelotRenderer/Source/CmRenderWindowManager.cpp

@@ -1,5 +1,4 @@
 #include "CmRenderWindowManager.h"
-#include "CmRenderSystemManager.h"
 #include "CmRenderSystem.h"
 #include "CmAsyncOp.h"
 
@@ -8,7 +7,7 @@ namespace CamelotEngine
 	RenderWindowPtr RenderWindowManager::create(const String& name, UINT32 width, UINT32 height, 
 		bool fullScreen, const map<String, String>::type* miscParams)
 	{
-		RenderSystem* renderSystem = RenderSystemManager::getActive();
+		RenderSystem* renderSystem = RenderSystem::instancePtr();
 
 		AsyncOp op;
 

CamelotRenderer/Source/CmResource.cpp

@@ -2,7 +2,6 @@
 #include "CmResourceRTTI.h"
 #include "CmUUID.h"
 #include "CmRenderSystem.h"
-#include "CmRenderSystemManager.h"
 
 namespace CamelotEngine
 {
@@ -30,7 +29,7 @@ namespace CamelotEngine
 	void Resource::waitUntilInitialized()
 	{
 #if CM_DEBUG_MODE
-		if(CM_THREAD_CURRENT_ID == RenderSystemManager::getActive()->getRenderThreadId())
+		if(CM_THREAD_CURRENT_ID == RenderSystem::instancePtr()->getRenderThreadId())
 			CM_EXCEPT(InternalErrorException, "You cannot call this method on the render thread. It will cause a deadlock!");
 #endif
 

CamelotRenderer/Source/CmTechnique.cpp

@@ -1,6 +1,5 @@
 #include "CmTechnique.h"
 #include "CmException.h"
-#include "CmRenderSystemManager.h"
 #include "CmRenderSystem.h"
 #include "CmRendererManager.h"
 #include "CmPass.h"
@@ -49,7 +48,7 @@ namespace CamelotEngine
 
 	bool Technique::isSupported() const
 	{
-		if(RenderSystemManager::getActive()->getName() == mRenderSystem &&
+		if(RenderSystem::instancePtr()->getName() == mRenderSystem &&
 			RendererManager::getActive()->getName() == mRenderer)
 		{
 			return true;

CamelotRenderer/Source/CmTexture.cpp

@@ -32,7 +32,6 @@ THE SOFTWARE.
 #include "CmException.h"
 #include "CmDebug.h"
 #include "CmRenderSystem.h"
-#include "CmRenderSystemManager.h"
 #include "CmAsyncOp.h"
 
 #if CM_DEBUG_MODE
@@ -74,7 +73,7 @@ namespace CamelotEngine {
 
 		mSize = getNumFaces() * PixelUtil::getMemorySize(mWidth, mHeight, mDepth, mFormat);
 
-		RenderSystemManager::getActive()->queueCommand(boost::bind(&Texture::initialize_internal, this));
+		RenderSystem::instancePtr()->queueCommand(boost::bind(&Texture::initialize_internal, this));
 	}
     //--------------------------------------------------------------------------
     bool Texture::hasAlpha(void) const
@@ -109,12 +108,12 @@ namespace CamelotEngine {
 
 	void Texture::setRawPixels(const PixelData& data, UINT32 face, UINT32 mip)
 	{
-		RenderSystemManager::getActive()->queueCommand(boost::bind(&Texture::setRawPixels_internal, this, data, face, mip), true);
+		RenderSystem::instancePtr()->queueCommand(boost::bind(&Texture::setRawPixels_internal, this, data, face, mip), true);
 	}
 
 	void Texture::setRawPixels_async(const PixelData& data, UINT32 face, UINT32 mip)
 	{
-		RenderSystemManager::getActive()->queueCommand(boost::bind(&Texture::setRawPixels_internal, this, data, face, mip));
+		RenderSystem::instancePtr()->queueCommand(boost::bind(&Texture::setRawPixels_internal, this, data, face, mip));
 	}
 
 	void Texture::setRawPixels_internal(const PixelData& data, UINT32 face, UINT32 mip)
@@ -143,14 +142,14 @@ namespace CamelotEngine {
 
 	PixelDataPtr Texture::getRawPixels(UINT32 face, UINT32 mip)
 	{
-		AsyncOp op = RenderSystemManager::getActive()->queueReturnCommand(boost::bind(&Texture::getRawPixels_internal, this, face, mip, _1), true);
+		AsyncOp op = RenderSystem::instancePtr()->queueReturnCommand(boost::bind(&Texture::getRawPixels_internal, this, face, mip, _1), true);
 
 		return op.getReturnValue<PixelDataPtr>();
 	}
 
 	AsyncOp Texture::getRawPixels_async(UINT32 face, UINT32 mip)
 	{
-		return RenderSystemManager::getActive()->queueReturnCommand(boost::bind(&Texture::getRawPixels_internal, this, face, mip, _1));
+		return RenderSystem::instancePtr()->queueReturnCommand(boost::bind(&Texture::getRawPixels_internal, this, face, mip, _1));
 	}
 
 	void Texture::getRawPixels_internal(UINT32 face, UINT32 mip, AsyncOp& op)
@@ -216,7 +215,7 @@ namespace CamelotEngine {
 	//----------------------------------------------------------------------------- 
 	void Texture::throwIfNotRenderThread() const
 	{
-		if(CM_THREAD_CURRENT_ID != RenderSystemManager::getActive()->getRenderThreadId())
+		if(CM_THREAD_CURRENT_ID != RenderSystem::instancePtr()->getRenderThreadId())
 			CM_EXCEPT(InternalErrorException, "Calling an internal texture method from a non-render thread!");
 	}
 

CamelotRenderer/Source/CmTextureManager.cpp

@@ -28,7 +28,6 @@ THE SOFTWARE.
 #include "CmTextureManager.h"
 #include "CmException.h"
 #include "CmPixelUtil.h"
-#include "CmRenderSystemManager.h"
 #include "CmRenderSystem.h"
 
 namespace CamelotEngine {
@@ -45,7 +44,7 @@ namespace CamelotEngine {
 	//-----------------------------------------------------------------------
 	void TextureManager::destroy(Texture* texture)
 	{
-		RenderSystemManager::getActive()->queueCommand(boost::bind(&TextureManager::destroy_internal, this, texture));
+		RenderSystem::instancePtr()->queueCommand(boost::bind(&TextureManager::destroy_internal, this, texture));
 	}
 	//-----------------------------------------------------------------------
 	void TextureManager::destroy_internal(Texture* texture)

CamelotRenderer/Source/CmVertexIndexData.cpp

@@ -34,7 +34,6 @@ THE SOFTWARE.
 #include "CmAxisAlignedBox.h"
 #include "CmException.h"
 #include "CmRenderSystem.h"
-#include "CmRenderSystemManager.h"
 
 namespace CamelotEngine {
 

CamelotRenderer/Source/CmViewport.cpp

@@ -31,7 +31,6 @@ THE SOFTWARE.
 #include "CmRenderTarget.h"
 #include "CmMath.h"
 #include "CmRenderSystem.h"
-#include "CmRenderSystemManager.h"
 
 namespace CamelotEngine {
 
@@ -175,7 +174,7 @@ namespace CamelotEngine {
 	void Viewport::clear(unsigned int buffers, const Color& col,  
 						 float depth, unsigned short stencil)
 	{
-		RenderSystem* rs = CamelotEngine::RenderSystemManager::getActive();
+		RenderSystem* rs = CamelotEngine::RenderSystem::instancePtr();
 		if (rs)
 		{
 			Viewport currentvp = rs->getViewport();