Application using OpenGL renderer shuts down properly

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 );
@@ -225,7 +225,7 @@ int CALLBACK WinMain(
 	gApplication().runMainLoop();
 
 	// Release everything before shutdown
-	//testMaterial->destroy();
+	testMaterial->destroy();
 	testMaterial.reset();
 
 	testTex->destroy();
@@ -244,6 +244,12 @@ int CALLBACK WinMain(
 
 	testModelGO->destroy();
 	testModelGO = nullptr;
+	testRenderable = nullptr;
+
+	cameraGO->destroy();
+	cameraGO = nullptr;
+	camera = nullptr;
+	debugCamera = nullptr;
 
 	newPassGL = nullptr;
 	newTechniqueGL = nullptr;
@@ -255,6 +261,8 @@ int CALLBACK WinMain(
 	newTechniqueDX11 = nullptr;
 
 	testShader = nullptr;
+	
+	renderWindow = nullptr;
 
 	gApplication().shutDown();
 

CamelotGLRenderer/Source/CmGLRenderSystem.cpp

@@ -211,12 +211,6 @@ namespace CamelotEngine
 		if(mProgramPipelineManager != nullptr)
 			delete mProgramPipelineManager;
 
-		// Destroy render windows
-		for (auto i = mRenderTargets.begin(); i != mRenderTargets.end(); ++i)
-		{
-			delete *i;
-		}
-
 		mRenderTargets.clear();
 
 		if(mGLSupport)
@@ -231,24 +225,6 @@ namespace CamelotEngine
 		GpuProgram* bindingPrg = prg->getBindingDelegate();
 		GLSLGpuProgram* glprg = static_cast<GLSLGpuProgram*>(bindingPrg);
 
-		// Unbind previous gpu program first.
-		//
-		// Note:
-		//  1. Even if both previous and current are the same object, we can't
-		//     bypass re-bind completely since the object itself maybe modified.
-		//     But we can bypass unbind based on the assumption that object
-		//     internally GL program type shouldn't be changed after it has
-		//     been created. The behavior of bind to a GL program type twice
-		//     should be same as unbind and rebind that GL program type, even
-		//     for difference objects.
-		//  2. We also assumed that the program's type (vertex or fragment) should
-		//     not be changed during it's in using. If not, the following switch
-		//     statement will confuse GL state completely, and we can't fix it
-		//     here. To fix this case, we must coding the program implementation
-		//     itself, if type is changing (during load/unload, etc), and it's inuse,
-		//     unbind and notify render system to correct for its state.
-		//
-
 		switch (glprg->getType())
 		{
 		case GPT_VERTEX_PROGRAM:

CamelotRenderer/Include/CmMaterial.h

@@ -31,6 +31,8 @@ namespace CamelotEngine
 	class CM_EXPORT Material : public Resource
 	{
 	public:
+		~Material();
+
 		/**
 		 * @brief	Sets a shader that will be used by the material. 
 		 * 			Shaders best technique will be retrieved and used in all subsequent Material

CamelotRenderer/Include/CmRenderStateManager.h

@@ -8,6 +8,8 @@ namespace CamelotEngine
 	class CM_EXPORT RenderStateManager : public Module<RenderStateManager>
 	{
 	public:
+		RenderStateManager();
+
 		/**
 		 * @brief	Creates and initializes a new SamplerState.
 		 */
@@ -55,5 +57,15 @@ namespace CamelotEngine
 		 * 			as it requires additional manual initialization that is not required normally.
 		 */
 		virtual BlendStatePtr createEmptyBlendState() const;
+
+		const SamplerStatePtr& getDefaultSamplerState() const { return mDefaultSamplerState; }
+		const BlendStatePtr& getDefaultBlendState() const { return mDefaultBlendState; }
+		const RasterizerStatePtr& getDefaultRasterizerState() const { return mDefaultRasterizerState; }
+		const DepthStencilStatePtr& getDefaultDepthStencilState() const { return mDefaultDepthStencilState; }
+	private:
+		SamplerStatePtr mDefaultSamplerState;
+		BlendStatePtr mDefaultBlendState;
+		RasterizerStatePtr mDefaultRasterizerState;
+		DepthStencilStatePtr mDefaultDepthStencilState;
 	};
 }

CamelotRenderer/Source/CmApplication.cpp

@@ -147,6 +147,9 @@ namespace CamelotEngine
 
 	void Application::shutDown()
 	{
+		mPrimaryRenderWindow->destroy();
+		mPrimaryRenderWindow = nullptr;
+
 		Importer::shutDown();
 		MeshManager::shutDown();
 

CamelotRenderer/Source/CmBlendState.cpp

@@ -14,9 +14,7 @@ namespace CamelotEngine
 
 	const BlendStatePtr& BlendState::getDefault()
 	{
-		static BlendStatePtr blendState = RenderStateManager::instance().createBlendState(BLEND_STATE_DESC());
-
-		return blendState;
+		return RenderStateManager::instance().getDefaultBlendState();
 	}
 
 	bool BlendState::getBlendEnabled(UINT32 renderTargetIdx) const

CamelotRenderer/Source/CmCoreGpuObject.cpp

@@ -21,6 +21,14 @@ namespace CamelotEngine
 			LOGWRN("Destructor called but object is not destroyed. Object will leak.")
 		}
 
+#if CM_DEBUG_MODE
+		if(!mThis.expired())
+		{
+			CM_EXCEPT(InternalErrorException, "Shared pointer to this object still has active references but " \
+				"the object is being deleted? You shouldn't delete CoreGpuObjects manually.");
+		}
+#endif
+
 		CoreGpuObjectManager::instance().unregisterObject(this);
 	}
 

CamelotRenderer/Source/CmDeferredRenderContext.cpp

@@ -179,6 +179,7 @@ namespace CamelotEngine
 	void DeferredRenderContext::cancelAll()
 	{
 		vector<CommandQueue::Command>::type* commands = mCommandQueue->flush();
+		delete commands;
 
 		// TODO - This cancels the commands but doesn't revert the state variables
 	}

CamelotRenderer/Source/CmDepthStencilState.cpp

@@ -15,9 +15,7 @@ namespace CamelotEngine
 
 	const DepthStencilStatePtr& DepthStencilState::getDefault()
 	{
-		static DepthStencilStatePtr depthStencilState = RenderStateManager::instance().createDepthStencilState(DEPTH_STENCIL_STATE_DESC());
-
-		return depthStencilState;
+		return RenderStateManager::instance().getDefaultDepthStencilState();
 	}
 
 	DepthStencilStatePtr DepthStencilState::create(const DEPTH_STENCIL_STATE_DESC& desc)

CamelotRenderer/Source/CmMaterial.cpp

@@ -18,6 +18,11 @@ namespace CamelotEngine
 
 	}
 
+	Material::~Material()
+	{
+
+	}
+
 	void Material::setShader(ShaderPtr shader)
 	{
 		mShader = shader;

CamelotRenderer/Source/CmRasterizerState.cpp

@@ -14,9 +14,7 @@ namespace CamelotEngine
 
 	const RasterizerStatePtr& RasterizerState::getDefault()
 	{
-		static RasterizerStatePtr rasterizerState = RenderStateManager::instance().createRasterizerState(RASTERIZER_STATE_DESC());
-
-		return rasterizerState;
+		return RenderStateManager::instance().getDefaultRasterizerState();
 	}
 
 	RasterizerStatePtr RasterizerState::create(const RASTERIZER_STATE_DESC& desc)

CamelotRenderer/Source/CmRenderStateManager.cpp

@@ -6,6 +6,14 @@
 
 namespace CamelotEngine
 {
+	RenderStateManager::RenderStateManager()
+	{
+		mDefaultSamplerState = createSamplerState(SAMPLER_STATE_DESC());
+		mDefaultBlendState = createBlendState(BLEND_STATE_DESC());
+		mDefaultRasterizerState = createRasterizerState(RASTERIZER_STATE_DESC());
+		mDefaultDepthStencilState = createDepthStencilState(DEPTH_STENCIL_STATE_DESC());
+	}
+
 	SamplerStatePtr RenderStateManager::createSamplerState(const SAMPLER_STATE_DESC& desc) const
 	{
 		SamplerStatePtr samplerState = SamplerStatePtr(new SamplerState());

CamelotRenderer/Source/CmRenderSystem.cpp

@@ -113,16 +113,6 @@ namespace CamelotEngine {
 	void RenderSystem::destroy_internal()
 	{
 		// Remove all the render targets.
-		// (destroy primary target last since others may depend on it)
-		RenderTarget* primary = 0;
-		for (auto it = mRenderTargets.begin(); it != mRenderTargets.end(); ++it)
-		{
-			if (!primary && (*it)->isPrimary())
-				primary = *it;
-			else
-				delete *it;
-		}
-		delete primary;
 		mRenderTargets.clear();
 
 		mPrioritisedRenderTargets.clear();

CamelotRenderer/Source/CmSamplerState.cpp

@@ -15,9 +15,7 @@ namespace CamelotEngine
 
 	const SamplerStatePtr& SamplerState::getDefault()
 	{
-		static SamplerStatePtr samplerState = RenderStateManager::instance().createSamplerState(SAMPLER_STATE_DESC());
-
-		return samplerState;
+		return RenderStateManager::instance().getDefaultSamplerState();
 	}
 
 	FilterOptions SamplerState::getTextureFiltering(FilterType ft) const