Moved builtin material managers to Banshee

BansheeEngine/BansheeEngine.vcxproj

@@ -168,6 +168,10 @@
     <ClInclude Include="Include\BsOverlayManager.h" />
     <ClInclude Include="Include\BsRenderable.h" />
     <ClInclude Include="Include\BsRenderableRTTI.h" />
+    <ClInclude Include="Include\BsBuiltinMaterialManager.h" />
+    <ClInclude Include="Include\BsD3D11BuiltinMaterialFactory.h" />
+    <ClInclude Include="Include\BsD3D9BuiltinMaterialFactory.h" />
+    <ClInclude Include="Include\BsGLBuiltinMaterialFactory.h" />
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Source\BsApplication.cpp" />
@@ -186,6 +190,10 @@
     <ClCompile Include="Source\BsOverlay.cpp" />
     <ClCompile Include="Source\BsOverlayManager.cpp" />
     <ClCompile Include="Source\BsRenderable.cpp" />
+    <ClCompile Include="Source\BsBuiltinMaterialManager.cpp" />
+    <ClCompile Include="Source\BsD3D11BuiltinMaterialFactory.cpp" />
+    <ClCompile Include="Source\BsD3D9BuiltinMaterialFactory.cpp" />
+    <ClCompile Include="Source\BsGLBuiltinMaterialFactory.cpp" />
   </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">

BansheeEngine/BansheeEngine.vcxproj.filters

@@ -102,6 +102,18 @@
     <ClInclude Include="Include\BsOverlayManager.h">
       <Filter>Header Files\2D</Filter>
     </ClInclude>
+    <ClInclude Include="Include\BsBuiltinMaterialManager.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\BsD3D11BuiltinMaterialFactory.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\BsD3D9BuiltinMaterialFactory.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\BsGLBuiltinMaterialFactory.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Source\BsGUIElement.cpp">
@@ -152,5 +164,17 @@
     <ClCompile Include="Source\BsRenderable.cpp">
       <Filter>Source Files\Components</Filter>
     </ClCompile>
+    <ClCompile Include="Source\BsBuiltinMaterialManager.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Source\BsD3D11BuiltinMaterialFactory.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Source\BsD3D9BuiltinMaterialFactory.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Source\BsGLBuiltinMaterialFactory.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

BansheeEngine/Include/BsBuiltinMaterialManager.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include "BsPrerequisites.h"
+#include "CmModule.h"
+
+namespace BansheeEngine
+{
+	class BS_EXPORT BuiltinMaterialFactory
+	{
+	public:
+		virtual ~BuiltinMaterialFactory() {}
+
+		virtual void startUp() {}
+		virtual void shutDown() {}
+
+		virtual const CM::String& getSupportedRenderSystem() const = 0;
+
+		virtual CM::HMaterial createSpriteTextMaterial() const = 0;
+		virtual CM::HMaterial createSpriteImageMaterial() const = 0;
+	};
+
+	/**
+	 * @brief	Provides access to various materials that are required for core engine systems. 
+	 * 			Each render system implementation needs to provide its own implementation of this
+	 * 			module.
+	 */
+	class BS_EXPORT BuiltinMaterialManager : public CM::Module<BuiltinMaterialManager>
+	{
+	public:
+		BuiltinMaterialManager();
+		~BuiltinMaterialManager();
+
+		CM::HMaterial createSpriteTextMaterial() const;
+		CM::HMaterial createSpriteImageMaterial() const;
+
+		void addFactory(BuiltinMaterialFactory* factory);
+		void setActive(const CM::String& renderSystemName);
+
+	private:
+		std::unordered_map<CM::String, BuiltinMaterialFactory*> mAvailableFactories;
+		BuiltinMaterialFactory* mActiveFactory;
+	};
+}

BansheeEngine/Include/BsD3D11BuiltinMaterialFactory.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "BsPrerequisites.h"
+#include "BsBuiltinMaterialManager.h"
+
+namespace BansheeEngine
+{
+	/**
+	 * @copydoc BuiltinMaterialFactory
+	 */
+	class D3D11BuiltinMaterialFactory : public BuiltinMaterialFactory
+	{
+	public:
+		void startUp();
+		void shutDown();
+		const CM::String& getSupportedRenderSystem() const;
+		
+		CM::HMaterial createSpriteTextMaterial() const;
+		CM::HMaterial createSpriteImageMaterial() const;
+
+	protected:
+		CM::ShaderPtr mSpriteTextShader;
+		CM::ShaderPtr mSpriteImageShader;
+
+		void initSpriteTextShader();
+		void initSpriteImageShader();
+	};
+}

BansheeEngine/Include/BsD3D9BuiltinMaterialFactory.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "BsPrerequisites.h"
+#include "BsBuiltinMaterialManager.h"
+
+namespace BansheeEngine
+{
+	/**
+	 * @copydoc BuiltinMaterialFactory
+	 */
+	class D3D9BuiltinMaterialFactory : public BuiltinMaterialFactory
+	{
+	public:
+		void startUp();
+		void shutDown();
+		const CM::String& getSupportedRenderSystem() const;
+
+		CM::HMaterial createSpriteTextMaterial() const;
+		CM::HMaterial createSpriteImageMaterial() const;
+
+	protected:
+		CM::ShaderPtr mSpriteTextShader;
+		CM::ShaderPtr mSpriteImageShader;
+
+		void initSpriteTextShader();
+		void initSpriteImageShader();
+	};
+}

BansheeEngine/Include/BsGLBuiltinMaterialFactory.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "BsPrerequisites.h"
+#include "BsBuiltinMaterialManager.h"
+
+namespace BansheeEngine
+{
+	/**
+	 * @copydoc BuiltinMaterialFactory
+	 */
+	class GLBuiltinMaterialFactory : public BuiltinMaterialFactory
+	{
+	public:
+		void startUp();
+		void shutDown();
+		const CM::String& getSupportedRenderSystem() const;
+
+		CM::HMaterial createSpriteTextMaterial() const;
+		CM::HMaterial createSpriteImageMaterial() const;
+
+	protected:
+		CM::ShaderPtr mSpriteTextShader;
+		CM::ShaderPtr mSpriteImageShader;
+
+		void initSpriteTextShader();
+		void initSpriteImageShader();
+	};
+}

BansheeEngine/Source/BsApplication.cpp

@@ -2,6 +2,10 @@
 #include "BsGUIMaterialManager.h"
 #include "BsGUIManager.h"
 #include "BsOverlayManager.h"
+#include "BsBuiltinMaterialManager.h"
+#include "BsD3D9BuiltinMaterialFactory.h"
+#include "BsD3D11BuiltinMaterialFactory.h"
+#include "BsGLBuiltinMaterialFactory.h"
 #include "CmApplication.h"
 
 using namespace CamelotFramework;
@@ -26,11 +30,17 @@ namespace BansheeEngine
 		desc.importers.push_back("CamelotFBXImporter");
 		desc.importers.push_back("CamelotFontImporter");
 
-		CM::gApplication().startUp(desc);
-
-		OverlayManager::startUp(CM_NEW(OverlayManager, GenAlloc) OverlayManager());
 		GUIManager::startUp(CM_NEW(GUIManager, GenAlloc) GUIManager());
 		GUIMaterialManager::startUp(CM_NEW(GUIMaterialManager, GenAlloc) GUIMaterialManager());
+		OverlayManager::startUp(CM_NEW(OverlayManager, GenAlloc) OverlayManager());
+
+		CM::gApplication().startUp(desc);
+
+		BuiltinMaterialManager::startUp(CM_NEW(BuiltinMaterialManager, GenAlloc) BuiltinMaterialManager());
+		BuiltinMaterialManager::instance().addFactory(CM_NEW(D3D9BuiltinMaterialFactory, GenAlloc) D3D9BuiltinMaterialFactory());
+		BuiltinMaterialManager::instance().addFactory(CM_NEW(D3D11BuiltinMaterialFactory, GenAlloc) D3D11BuiltinMaterialFactory());
+		BuiltinMaterialManager::instance().addFactory(CM_NEW(GLBuiltinMaterialFactory, GenAlloc) GLBuiltinMaterialFactory());
+		BuiltinMaterialManager::instance().setActive(desc.renderSystem);
 	}
 
 	void Application::runMainLoop()
@@ -42,11 +52,13 @@ namespace BansheeEngine
 	{
 		GUIMaterialManager::instance().forceReleaseAllMaterials();
 
+		BuiltinMaterialManager::shutDown();
+
 		CM::gApplication().shutDown();
 
+		OverlayManager::shutDown();
 		GUIMaterialManager::shutDown();
 		GUIManager::shutDown();
-		OverlayManager::shutDown();
 	}
 
 	Application& gBansheeApp()

BansheeEngine/Source/BsBuiltinMaterialManager.cpp

@@ -0,0 +1,55 @@
+#include "BsBuiltinMaterialManager.h"
+
+using namespace CamelotFramework;
+
+namespace BansheeEngine
+{
+	BuiltinMaterialManager::BuiltinMaterialManager()
+		:mActiveFactory(nullptr)
+	{
+
+	}
+
+	BuiltinMaterialManager::~BuiltinMaterialManager()
+	{
+		for(auto& iter : mAvailableFactories)
+		{
+			iter.second->shutDown();
+			CM_DELETE(iter.second, BuiltinMaterialFactory, GenAlloc)
+		}
+	}
+
+	HMaterial BuiltinMaterialManager::createSpriteTextMaterial() const
+	{
+		assert(mActiveFactory != nullptr);
+
+		return mActiveFactory->createSpriteTextMaterial();
+	}
+
+	HMaterial BuiltinMaterialManager::createSpriteImageMaterial() const
+	{
+		assert(mActiveFactory != nullptr);
+
+		return mActiveFactory->createSpriteImageMaterial();
+	}
+
+	void BuiltinMaterialManager::addFactory(BuiltinMaterialFactory* factory)
+	{
+		assert(factory != nullptr);
+
+		mAvailableFactories[factory->getSupportedRenderSystem()] = factory;
+	}
+
+	void BuiltinMaterialManager::setActive(const CM::String& renderSystemName)
+	{
+		auto iterFind = mAvailableFactories.find(renderSystemName);
+
+		if(iterFind == mAvailableFactories.end())
+		{
+			CM_EXCEPT(InvalidParametersException, "Cannot find a factory for the specified render system: " + renderSystemName);
+		}
+
+		mActiveFactory = iterFind->second;
+		mActiveFactory->startUp();
+	}
+}

CamelotD3D11RenderSystem/Source/CmD3D11BuiltinMaterialManager.cpp → BansheeEngine/Source/BsD3D11BuiltinMaterialFactory.cpp

@@ -1,4 +1,4 @@
-#include "CmD3D11BuiltinMaterialManager.h"
+#include "BsD3D11BuiltinMaterialFactory.h"
 #include "CmRendererManager.h"
 #include "CmHighLevelGpuProgram.h"
 #include "CmShader.h"
@@ -7,25 +7,40 @@
 #include "CmMaterial.h"
 #include "CmBlendState.h"
 
-namespace CamelotFramework
+using namespace CamelotFramework;
+
+namespace BansheeEngine
 {
-	HMaterial D3D11BuiltinMaterialManager::createSpriteTextMaterial() const
+	void D3D11BuiltinMaterialFactory::startUp()
 	{
-		return Material::create(mSpriteTextShader);
+		initSpriteTextShader();
+		initSpriteImageShader();
 	}
 
-	HMaterial D3D11BuiltinMaterialManager::createSpriteImageMaterial() const
+	void D3D11BuiltinMaterialFactory::shutDown()
 	{
-		return Material::create(mSpriteImageShader);
+		mSpriteTextShader = nullptr;
+		mSpriteImageShader = nullptr;
 	}
 
-	void D3D11BuiltinMaterialManager::onStartUp()
+	const CM::String& D3D11BuiltinMaterialFactory::getSupportedRenderSystem() const
 	{
-		initSpriteTextShader();
-		initSpriteImageShader();
+		static String renderSystem = "CamelotD3D11RenderSystem";
+
+		return renderSystem;
+	}
+
+	HMaterial D3D11BuiltinMaterialFactory::createSpriteTextMaterial() const
+	{
+		return Material::create(mSpriteTextShader);
+	}
+
+	HMaterial D3D11BuiltinMaterialFactory::createSpriteImageMaterial() const
+	{
+		return Material::create(mSpriteImageShader);
 	}
 
-	void D3D11BuiltinMaterialManager::initSpriteTextShader()
+	void D3D11BuiltinMaterialFactory::initSpriteTextShader()
 	{
 		String vsCode = "										\
 			float halfViewportWidth;							\
@@ -87,7 +102,7 @@ namespace CamelotFramework
 		newPass->setBlendState(blendState);
 	}
 
-	void D3D11BuiltinMaterialManager::initSpriteImageShader()
+	void D3D11BuiltinMaterialFactory::initSpriteImageShader()
 	{
 		String vsCode = "										\
 						float halfViewportWidth;							\

BansheeEngine/Source/BsD3D9BuiltinMaterialFactory.cpp

@@ -0,0 +1,52 @@
+#include "BsD3D9BuiltinMaterialFactory.h"
+#include "CmHighLevelGpuProgram.h"
+#include "CmShader.h"
+#include "CmTechnique.h"
+#include "CmPass.h"
+#include "CmMaterial.h"
+#include "CmBlendState.h"
+
+using namespace CamelotFramework;
+
+namespace BansheeEngine
+{
+	void D3D9BuiltinMaterialFactory::startUp()
+	{
+		initSpriteTextShader();
+		initSpriteImageShader();
+	}
+
+	void D3D9BuiltinMaterialFactory::shutDown()
+	{
+		mSpriteTextShader = nullptr;
+		mSpriteImageShader = nullptr;
+	}
+
+	const CM::String& D3D9BuiltinMaterialFactory::getSupportedRenderSystem() const
+	{
+		static String renderSystem = "CamelotD3D9RenderSystem";
+
+		return renderSystem;
+	}
+
+	HMaterial D3D9BuiltinMaterialFactory::createSpriteTextMaterial() const
+	{
+		return Material::create(mSpriteTextShader);
+	}
+
+	HMaterial D3D9BuiltinMaterialFactory::createSpriteImageMaterial() const
+	{
+		return Material::create(mSpriteImageShader);
+	}
+
+
+	void D3D9BuiltinMaterialFactory::initSpriteTextShader()
+	{
+		// TODO
+	}
+
+	void D3D9BuiltinMaterialFactory::initSpriteImageShader()
+	{
+		// TODO
+	}
+}

BansheeEngine/Source/BsGLBuiltinMaterialFactory.cpp

@@ -0,0 +1,51 @@
+#include "BsGLBuiltinMaterialFactory.h"
+#include "CmHighLevelGpuProgram.h"
+#include "CmShader.h"
+#include "CmTechnique.h"
+#include "CmPass.h"
+#include "CmMaterial.h"
+#include "CmBlendState.h"
+
+using namespace CamelotFramework;
+
+namespace BansheeEngine
+{
+	void GLBuiltinMaterialFactory::startUp()
+	{
+		initSpriteTextShader();
+		initSpriteImageShader();
+	}
+
+	void GLBuiltinMaterialFactory::shutDown()
+	{
+		mSpriteTextShader = nullptr;
+		mSpriteImageShader = nullptr;
+	}
+
+	const CM::String& GLBuiltinMaterialFactory::getSupportedRenderSystem() const
+	{
+		static String renderSystem = "CamelotGLRenderSystem";
+
+		return renderSystem;
+	}
+
+	HMaterial GLBuiltinMaterialFactory::createSpriteTextMaterial() const
+	{
+		return Material::create(mSpriteTextShader);
+	}
+
+	HMaterial GLBuiltinMaterialFactory::createSpriteImageMaterial() const
+	{
+		return Material::create(mSpriteImageShader);
+	}
+
+	void GLBuiltinMaterialFactory::initSpriteTextShader()
+	{
+		// TODO
+	}
+
+	void GLBuiltinMaterialFactory::initSpriteImageShader()
+	{
+		// TODO
+	}
+}

BansheeEngine/Source/BsGUIMaterialManager.cpp

@@ -1,7 +1,7 @@
 #include "BsGUIMaterialManager.h"
 #include "CmMaterial.h"
 #include "CmDebug.h"
-#include "CmBuiltinMaterialManager.h"
+#include "BsBuiltinMaterialManager.h"
 
 using namespace CamelotFramework;
 

CamelotCore/CamelotCore.vcxproj

@@ -183,7 +183,6 @@
     <ClInclude Include="Include\CmMemAllocCategories.h" />
     <ClInclude Include="Include\CmApplication.h" />
     <ClInclude Include="Include\CmBlendStateRTTI.h" />
-    <ClInclude Include="Include\CmBuiltinMaterialManager.h" />
     <ClInclude Include="Include\CmCgProgram.h" />
     <ClInclude Include="Include\CmCgProgramFactory.h" />
     <ClInclude Include="Include\CmCgProgramRTTI.h" />
@@ -289,7 +288,6 @@
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Include\CmMaterialManager.cpp" />
-    <ClCompile Include="Source\CmBuiltinMaterialManager.cpp" />
     <ClCompile Include="Source\CmGameObjectHandle.cpp" />
     <ClCompile Include="Source\CmGameObject.cpp" />
     <ClCompile Include="Source\CmApplication.cpp" />

CamelotCore/CamelotCore.vcxproj.filters

@@ -414,9 +414,6 @@
     <ClInclude Include="Include\CmGameObjectRTTI.h">
       <Filter>Header Files\RTTI</Filter>
     </ClInclude>
-    <ClInclude Include="Include\CmBuiltinMaterialManager.h">
-      <Filter>Header Files\Material</Filter>
-    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Source\CmApplication.cpp">
@@ -641,8 +638,5 @@
     <ClCompile Include="Source\CmGameObject.cpp">
       <Filter>Source Files\Scene</Filter>
     </ClCompile>
-    <ClCompile Include="Source\CmBuiltinMaterialManager.cpp">
-      <Filter>Source Files\Material</Filter>
-    </ClCompile>
   </ItemGroup>
 </Project>

CamelotCore/Include/CmBuiltinMaterialManager.h

@@ -1,19 +0,0 @@
-#pragma once
-
-#include "CmPrerequisites.h"
-#include "CmModule.h"
-
-namespace CamelotFramework
-{
-	/**
-	 * @brief	Provides access to various materials that are required for core engine systems. 
-	 * 			Each render system implementation needs to provide its own implementation of this
-	 * 			module.
-	 */
-	class CM_EXPORT BuiltinMaterialManager : public Module<BuiltinMaterialManager>
-	{
-	public:
-		virtual HMaterial createSpriteTextMaterial() const = 0;
-		virtual HMaterial createSpriteImageMaterial() const = 0;
-	};
-}

CamelotCore/Source/CmBuiltinMaterialManager.cpp

@@ -1 +0,0 @@
-#include "CmBuiltinMaterialManager.h"

CamelotD3D11RenderSystem/CamelotD3D11RenderSystem.vcxproj

@@ -151,7 +151,6 @@
   </ItemDefinitionGroup>
   <ItemGroup>
     <ClInclude Include="Include\CmD3D11BlendState.h" />
-    <ClInclude Include="Include\CmD3D11BuiltinMaterialManager.h" />
     <ClInclude Include="Include\CmD3D11DepthStencilState.h" />
     <ClInclude Include="Include\CmD3D11GpuBuffer.h" />
     <ClInclude Include="Include\CmD3D11GpuBufferView.h" />
@@ -189,7 +188,6 @@
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Source\CmD3D11BlendState.cpp" />
-    <ClCompile Include="Source\CmD3D11BuiltinMaterialManager.cpp" />
     <ClCompile Include="Source\CmD3D11DepthStencilState.cpp" />
     <ClCompile Include="Source\CmD3D11Device.cpp" />
     <ClCompile Include="Source\CmD3D11Driver.cpp" />

CamelotD3D11RenderSystem/CamelotD3D11RenderSystem.vcxproj.filters

@@ -123,9 +123,6 @@
     <ClInclude Include="Include\CmD3D11TextureView.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="Include\CmD3D11BuiltinMaterialManager.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Source\CmD3D11GpuProgram.cpp">
@@ -230,8 +227,5 @@
     <ClCompile Include="Source\CmD3D11TextureView.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="Source\CmD3D11BuiltinMaterialManager.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
   </ItemGroup>
 </Project>

CamelotD3D11RenderSystem/Include/CmD3D11BuiltinMaterialManager.h

@@ -1,26 +0,0 @@
-#pragma once
-
-#include "CmD3D11Prerequisites.h"
-#include "CmBuiltinMaterialManager.h"
-
-namespace CamelotFramework
-{
-	/**
-	 * @copydoc BuiltinMaterialManager
-	 */
-	class D3D11BuiltinMaterialManager : public BuiltinMaterialManager
-	{
-	public:
-		HMaterial createSpriteTextMaterial() const;
-		HMaterial createSpriteImageMaterial() const;
-
-	protected:
-		ShaderPtr mSpriteTextShader;
-		ShaderPtr mSpriteImageShader;
-
-		void onStartUp();
-
-		void initSpriteTextShader();
-		void initSpriteImageShader();
-	};
-}

CamelotD3D11RenderSystem/Source/CmD3D11RenderSystem.cpp

@@ -20,7 +20,6 @@
 #include "CmD3D11GpuParamBlock.h"
 #include "CmD3D11InputLayoutManager.h"
 #include "CmD3D11HLSLProgram.h"
-#include "CmD3D11BuiltinMaterialManager.h"
 #include "CmGpuParams.h"
 #include "CmDebug.h"
 #include "CmException.h"
@@ -133,8 +132,6 @@ namespace CamelotFramework
 
 		mIAManager = CM_NEW(D3D11InputLayoutManager, GenAlloc) D3D11InputLayoutManager();
 
-		BuiltinMaterialManager::startUp(CM_NEW(D3D11BuiltinMaterialManager, GenAlloc) D3D11BuiltinMaterialManager());
-
 		RenderSystem::initialize_internal();
 	}
 
@@ -157,7 +154,6 @@ namespace CamelotFramework
 		mActiveVertexDeclaration = nullptr;
 		mActiveVertexShader = nullptr;
 
-		BuiltinMaterialManager::shutDown();
 		RenderStateManager::shutDown();
 		RenderWindowManager::shutDown();
 		GpuProgramManager::shutDown();

CamelotD3D9Renderer/CamelotD3D9Renderer.vcxproj

@@ -151,7 +151,6 @@
     </Link>
   </ItemDefinitionGroup>
   <ItemGroup>
-    <ClInclude Include="Include\CmD3D9BuiltinMaterialManager.h" />
     <ClInclude Include="Include\CmD3D9Device.h" />
     <ClInclude Include="Include\CmD3D9DeviceManager.h" />
     <ClInclude Include="Include\CmD3D9Driver.h" />
@@ -186,7 +185,6 @@
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="CmD3D9Plugin.cpp" />
-    <ClCompile Include="Source\CmD3D9BuiltinMaterialManager.cpp" />
     <ClCompile Include="Source\CmD3D9Device.cpp" />
     <ClCompile Include="Source\CmD3D9DeviceManager.cpp" />
     <ClCompile Include="Source\CmD3D9Driver.cpp" />

CamelotD3D9Renderer/CamelotD3D9Renderer.vcxproj.filters

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

CamelotD3D9Renderer/Include/CmD3D9BuiltinMaterialManager.h

@@ -1,26 +0,0 @@
-#pragma once
-
-#include "CmD3D9Prerequisites.h"
-#include "CmBuiltinMaterialManager.h"
-
-namespace CamelotFramework
-{
-	/**
-	 * @copydoc BuiltinMaterialManager
-	 */
-	class D3D9BuiltinMaterialManager : public BuiltinMaterialManager
-	{
-	public:
-		HMaterial createSpriteTextMaterial() const;
-		HMaterial createSpriteImageMaterial() const;
-
-	protected:
-		ShaderPtr mSpriteTextShader;
-		ShaderPtr mSpriteImageShader;
-
-		void onStartUp();
-
-		void initSpriteTextShader();
-		void initSpriteImageShader();
-	};
-}

CamelotD3D9Renderer/Source/CmD3D9BuiltinMaterialManager.cpp

@@ -1,36 +0,0 @@
-#include "CmD3D9BuiltinMaterialManager.h"
-#include "CmHighLevelGpuProgram.h"
-#include "CmShader.h"
-#include "CmTechnique.h"
-#include "CmPass.h"
-#include "CmMaterial.h"
-#include "CmBlendState.h"
-
-namespace CamelotFramework
-{
-	HMaterial D3D9BuiltinMaterialManager::createSpriteTextMaterial() const
-	{
-		return Material::create(mSpriteTextShader);
-	}
-
-	HMaterial D3D9BuiltinMaterialManager::createSpriteImageMaterial() const
-	{
-		return Material::create(mSpriteImageShader);
-	}
-
-	void D3D9BuiltinMaterialManager::onStartUp()
-	{
-		initSpriteTextShader();
-		initSpriteImageShader();
-	}
-
-	void D3D9BuiltinMaterialManager::initSpriteTextShader()
-	{
-		// TODO
-	}
-
-	void D3D9BuiltinMaterialManager::initSpriteImageShader()
-	{
-		// TODO
-	}
-}

CamelotD3D9Renderer/Source/CmD3D9RenderSystem.cpp

@@ -46,7 +46,6 @@ THE SOFTWARE.
 #include "CmD3D9DeviceManager.h"
 #include "CmD3D9ResourceManager.h"
 #include "CmD3D9RenderWindowManager.h"
-#include "CmD3D9BuiltinMaterialManager.h"
 #include "CmHighLevelGpuProgramManager.h"
 #include "CmRenderStateManager.h"
 #include "CmAsyncOp.h"
@@ -183,8 +182,6 @@ namespace CamelotFramework
 		// Create render state manager
 		RenderStateManager::startUp(CM_NEW(RenderStateManager, GenAlloc) RenderStateManager());
 
-		BuiltinMaterialManager::startUp(CM_NEW(D3D9BuiltinMaterialManager, GenAlloc) D3D9BuiltinMaterialManager());
-
 		// call superclass method
 		RenderSystem::initialize_internal();
 	}
@@ -212,7 +209,6 @@ namespace CamelotFramework
 		}
 		mActiveD3DDriver = NULL;	
 
-		BuiltinMaterialManager::shutDown();
 		TextureManager::shutDown();
 		HardwareBufferManager::shutDown();
 		GpuProgramManager::shutDown();	

CamelotGLRenderer/CamelotGLRenderer.vcxproj

@@ -151,7 +151,6 @@
     </Link>
   </ItemDefinitionGroup>
   <ItemGroup>
-    <ClInclude Include="Include\CmGLBuiltinMaterialManager.h" />
     <ClInclude Include="Include\CmGLContext.h" />
     <ClInclude Include="Include\CmGLFrameBufferObject.h" />
     <ClInclude Include="Include\CmGLGpuBuffer.h" />
@@ -188,7 +187,6 @@
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="CmGLPlugin.cpp" />
-    <ClCompile Include="Source\CmGLBuiltinMaterialManager.cpp" />
     <ClCompile Include="Source\CmGLContext.cpp" />
     <ClCompile Include="Source\CmGLFrameBufferObject.cpp" />
     <ClCompile Include="Source\CmGLGpuBuffer.cpp" />

CamelotGLRenderer/CamelotGLRenderer.vcxproj.filters

@@ -123,9 +123,6 @@
     <ClInclude Include="Include\CmGLGpuBuffer.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="Include\CmGLBuiltinMaterialManager.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Source\GLSL\src\CmGLSLExtSupport.cpp">
@@ -218,8 +215,5 @@
     <ClCompile Include="Source\CmGLGpuBuffer.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="Source\CmGLBuiltinMaterialManager.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
   </ItemGroup>
 </Project>

CamelotGLRenderer/Include/CmGLBuiltinMaterialManager.h

@@ -1,26 +0,0 @@
-#pragma once
-
-#include "CmGLPrerequisites.h"
-#include "CmBuiltinMaterialManager.h"
-
-namespace CamelotFramework
-{
-	/**
-	 * @copydoc BuiltinMaterialManager
-	 */
-	class GLBuiltinMaterialManager : public BuiltinMaterialManager
-	{
-	public:
-		HMaterial createSpriteTextMaterial() const;
-		HMaterial createSpriteImageMaterial() const;
-
-	protected:
-		ShaderPtr mSpriteTextShader;
-		ShaderPtr mSpriteImageShader;
-
-		void onStartUp();
-
-		void initSpriteTextShader();
-		void initSpriteImageShader();
-	};
-}

CamelotGLRenderer/Source/CmGLBuiltinMaterialManager.cpp

@@ -1,36 +0,0 @@
-#include "CmGLBuiltinMaterialManager.h"
-#include "CmHighLevelGpuProgram.h"
-#include "CmShader.h"
-#include "CmTechnique.h"
-#include "CmPass.h"
-#include "CmMaterial.h"
-#include "CmBlendState.h"
-
-namespace CamelotFramework
-{
-	HMaterial GLBuiltinMaterialManager::createSpriteTextMaterial() const
-	{
-		return Material::create(mSpriteTextShader);
-	}
-
-	HMaterial GLBuiltinMaterialManager::createSpriteImageMaterial() const
-	{
-		return Material::create(mSpriteImageShader);
-	}
-
-	void GLBuiltinMaterialManager::onStartUp()
-	{
-		initSpriteTextShader();
-		initSpriteImageShader();
-	}
-
-	void GLBuiltinMaterialManager::initSpriteTextShader()
-	{
-		// TODO
-	}
-
-	void GLBuiltinMaterialManager::initSpriteImageShader()
-	{
-		// TODO
-	}
-}

CamelotGLRenderer/Source/CmGLRenderSystem.cpp

@@ -46,7 +46,6 @@ THE SOFTWARE.s
 #include "CmDepthStencilState.h"
 #include "CmGLRenderTexture.h"
 #include "CmGLRenderWindowManager.h"
-#include "CmGLBuiltinMaterialManager.h"
 #include "CmGLSLProgramPipelineManager.h"
 #include "CmRenderStateManager.h"
 #include "CmGpuParams.h"
@@ -146,8 +145,6 @@ namespace CamelotFramework
 
 		RenderStateManager::startUp(CM_NEW(RenderStateManager, GenAlloc) RenderStateManager());
 
-		BuiltinMaterialManager::startUp(CM_NEW(GLBuiltinMaterialManager, GenAlloc) GLBuiltinMaterialManager());
-
 		RenderSystem::initialize_internal();
 	}
 
@@ -191,7 +188,6 @@ namespace CamelotFramework
 		mGLSupport->stop();
 
 		TextureManager::shutDown();
-		BuiltinMaterialManager::shutDown();
 		RenderWindowManager::shutDown();
 		RenderStateManager::shutDown();
 

TODO.txt

@@ -2,9 +2,6 @@
 
 ----------------------------------------------------------------------------------------------
 
-BansheeEngine refactor:
- - Move built-in materials and their managers to BansheeEngine
-
 Immediate TODO:
  - Issue with rendering same object from multiple cameras:
    - Material parameters should be copied after being submitted to the render context
@@ -158,6 +155,7 @@ Optional:
  - Need a way to convert MSAA render texture into a normal render texture
  - Vertex buffer start offset is not supported when calling Draw methods
  - Instead of doing setThisPtr on every CoreGpuObject, use intrusive shared_ptr instead?
+ - Renderer::render(CameraPtr) is currently commented out because I moved Camera out of Camelot and I didn't want to bother figuring how to port this
 
  ----------------------------------------------------------------------------------------------
 After polish and ideas: