RendererManager and RenderSystemManager are now modules so their factories get properly released

CamelotClient/CamelotClient.cpp

@@ -216,8 +216,8 @@ int CALLBACK WinMain(
 
 	//_ASSERT(_CrtCheckMemory());
 
-	testRenderable->setMesh(dbgMesh);
-	testRenderable->setMaterial(testMaterial);
+	//testRenderable->setMesh(dbgMesh);
+	//testRenderable->setMaterial(testMaterial);
 
 	//// Set the new state for the flag
 	//_CrtSetDbgFlag( tmpFlag );

CamelotD3D11RenderSystem/Include/CmD3D11RenderSystemFactory.h

@@ -25,7 +25,7 @@ namespace CamelotEngine
 				if(newFactory == nullptr)
 				{
 					newFactory = RenderSystemFactoryPtr(new D3D11RenderSystemFactory());
-					RenderSystemManager::registerRenderSystemFactory(newFactory);
+					RenderSystemManager::instance().registerRenderSystemFactory(newFactory);
 				}
 			}
 		};

CamelotD3D9Renderer/Include/CmD3D9RenderSystemFactory.h

@@ -25,7 +25,7 @@ namespace CamelotEngine
 						if(newFactory == nullptr)
 						{
 							newFactory = RenderSystemFactoryPtr(new D3D9RenderSystemFactory());
-							RenderSystemManager::registerRenderSystemFactory(newFactory);
+							RenderSystemManager::instance().registerRenderSystemFactory(newFactory);
 						}
 					}
 			};

CamelotForwardRenderer/Source/CmForwardRendererPlugin.cpp

@@ -11,6 +11,6 @@ namespace CamelotEngine
 
 	extern "C" CM_FWDRND_EXPORT void loadPlugin()
 	{
-		RendererManager::registerFactory(RendererFactoryPtr(new ForwardRendererFactory()));
+		RendererManager::instance().registerFactory(RendererFactoryPtr(new ForwardRendererFactory()));
 	}
 }

CamelotGLRenderer/Include/CmGLRenderSystemFactory.h

@@ -25,7 +25,7 @@ namespace CamelotEngine
 				if(newFactory == nullptr)
 				{
 					newFactory = RenderSystemFactoryPtr(new GLRenderSystemFactory());
-					RenderSystemManager::registerRenderSystemFactory(newFactory);
+					RenderSystemManager::instance().registerRenderSystemFactory(newFactory);
 				}
 			}
 		};

CamelotRenderer/Include/CmRenderSystemManager.h

@@ -1,20 +1,21 @@
 #pragma once
 
 #include "CmPrerequisites.h"
+#include "CmModule.h"
 #include "CmRenderSystemFactory.h"
 
 namespace CamelotEngine
 {
 	typedef std::shared_ptr<RenderSystemFactory> RenderSystemFactoryPtr;
 
-	class CM_EXPORT RenderSystemManager
+	class CM_EXPORT RenderSystemManager : public Module<RenderSystemManager>
 	{
 	public:
-		static void startUp(const String& name);
+		void setActive(const String& name);
 
-		static void registerRenderSystemFactory(RenderSystemFactoryPtr factory);
+		void registerRenderSystemFactory(RenderSystemFactoryPtr factory);
 	private:
-		static std::vector<RenderSystemFactoryPtr>& getAvailableFactories();
+		std::vector<RenderSystemFactoryPtr> mAvailableFactories;
 	};
 }
 

CamelotRenderer/Include/CmRendererManager.h

@@ -2,20 +2,21 @@
 
 #include "CmPrerequisites.h"
 #include "CmRendererFactory.h"
+#include "CmModule.h"
 
 namespace CamelotEngine
 {
-	class CM_EXPORT RendererManager
+	class CM_EXPORT RendererManager : public Module<RendererManager>
 	{
 	public:
-		static void setActive(const String& name);
-		static RendererPtr getActive() { return mActiveRenderer; }
+		void setActive(const String& name);
+		RendererPtr getActive() { return mActiveRenderer; }
 
-		static void registerFactory(RendererFactoryPtr factory);
+		void registerFactory(RendererFactoryPtr factory);
 	private:
-		static std::vector<RendererFactoryPtr>& getAvailableFactories();
+		std::vector<RendererFactoryPtr> mAvailableFactories;
 
-		static RendererPtr mActiveRenderer;
+		RendererPtr mActiveRenderer;
 	};
 }
 

CamelotRenderer/Source/CmApplication.cpp

@@ -48,10 +48,13 @@ namespace CamelotEngine
 		Resources::startUp(new Resources("D:\\CamelotResourceMetas"));
 		HighLevelGpuProgramManager::startUp(new HighLevelGpuProgramManager());
 
-		RenderSystemManager::startUp(renderSystemName);
+		RenderSystemManager::startUp(new RenderSystemManager());
+		RenderSystemManager::instance().setActive(renderSystemName);
+
+		RendererManager::startUp(new RendererManager());
 
 		loadPlugin(rendererName);
-		RendererManager::setActive("ForwardRenderer");
+		RendererManager::instance().setActive("ForwardRenderer");
 
 		RenderSystem* renderSystem = RenderSystem::instancePtr();
 
@@ -88,7 +91,7 @@ namespace CamelotEngine
 			gSceneManager().update();
 
 			RenderSystem* renderSystem = RenderSystem::instancePtr();
-			RendererManager::getActive()->renderAll();
+			RendererManager::instance().getActive()->renderAll();
 
 			// Only queue new commands if render thread has finished rendering
 			// TODO - There might be a more optimal way to sync simulation and render threads so we maximize
@@ -148,6 +151,7 @@ namespace CamelotEngine
 		MeshManager::shutDown();
 
 		SceneManager::shutDown();
+		RendererManager::shutDown();
 		RenderSystem::shutDown();
 
 		HighLevelGpuProgramManager::shutDown();

CamelotRenderer/Source/CmRenderSystemManager.cpp

@@ -6,7 +6,7 @@
 
 namespace CamelotEngine
 {
-	void RenderSystemManager::startUp(const String& pluginFilename)
+	void RenderSystemManager::setActive(const String& pluginFilename)
 	{
 		DynLib* loadedLibrary = gDynLibManager().load(pluginFilename);
 		String name = "";
@@ -19,7 +19,7 @@ namespace CamelotEngine
 			name = getPluginNameFunc();
 		}
 
-		for(auto iter = getAvailableFactories().begin(); iter != getAvailableFactories().end(); ++iter)
+		for(auto iter = mAvailableFactories.begin(); iter != mAvailableFactories.end(); ++iter)
 		{
 			if((*iter)->name() == name)
 			{
@@ -33,12 +33,6 @@ namespace CamelotEngine
 	{
 		assert(factory != nullptr);
 
-		getAvailableFactories().push_back(factory);
-	}
-
-	std::vector<RenderSystemFactoryPtr>& RenderSystemManager::getAvailableFactories()
-	{
-		static std::vector<RenderSystemFactoryPtr> availableFactories;
-		return availableFactories;
+		mAvailableFactories.push_back(factory);
 	}
 }

CamelotRenderer/Source/CmRendererManager.cpp

@@ -4,11 +4,9 @@
 
 namespace CamelotEngine
 {
-	RendererPtr RendererManager::mActiveRenderer;
-
 	void RendererManager::setActive(const String& name)
 	{
-		for(auto iter = getAvailableFactories().begin(); iter != getAvailableFactories().end(); ++iter)
+		for(auto iter = mAvailableFactories.begin(); iter != mAvailableFactories.end(); ++iter)
 		{
 			if((*iter)->name() == name)
 			{
@@ -31,12 +29,6 @@ namespace CamelotEngine
 	{
 		assert(factory != nullptr);
 
-		getAvailableFactories().push_back(factory);
-	}
-
-	std::vector<RendererFactoryPtr>& RendererManager::getAvailableFactories()
-	{
-		static std::vector<RendererFactoryPtr> availableFactories;
-		return availableFactories;
+		mAvailableFactories.push_back(factory);
 	}
 }

CamelotRenderer/Source/CmTechnique.cpp

@@ -49,7 +49,7 @@ namespace CamelotEngine
 	bool Technique::isSupported() const
 	{
 		if(RenderSystem::instancePtr()->getName() == mRenderSystem &&
-			RendererManager::getActive()->getName() == mRenderer)
+			RendererManager::instance().getActive()->getName() == mRenderer)
 		{
 			return true;
 		}