Project library will no longer try to unload resources during reimport, unless project library was the system that loaded them

Fixed renderer materials so they are properly destroyed on the core thread

BansheeCore/Include/BsCoreApplication.h

@@ -94,6 +94,11 @@ namespace BansheeEngine
 		 */
 		virtual void postUpdate();
 
+		/**
+		 * @brief	Activates the renderer specified during construction. Called during initialization.
+		 */
+		virtual void startUpRenderer();
+
 		/**
 		 * @brief	Returns a handler that is used for resolving shader include file paths.
 		 */

BansheeCore/Include/BsResourceHandle.h

@@ -96,7 +96,7 @@ namespace BansheeEngine
 	public:
 		friend class ResourceHandleRTTI;
 		static RTTITypeBase* getRTTIStatic();
-		virtual RTTITypeBase* getRTTI() const;
+		virtual RTTITypeBase* getRTTI() const override;
 	};
 
 	/**

BansheeCore/Include/BsResources.h

@@ -124,6 +124,16 @@ namespace BansheeEngine
 		 */
 		void save(HResource resource);
 
+		/**
+		 * @brief	Checks is the resource with the specified UUID loaded.
+		 *
+		 * @param	uuid			UUID of the resource to check.
+		 * @param	checkInProgress	Should this method also check resources that are in progress of being asynchronously loaded.
+		 * 							
+		 * @return	True if loaded or loading in progress, false otherwise.
+		 */
+		bool isLoaded(const String& uuid, bool checkInProgress = true);
+
 		/**
 		 * @brief	Creates a new resource handle from a resource pointer. 
 		 *

BansheeCore/Source/BsCoreApplication.cpp

@@ -145,7 +145,7 @@ namespace BansheeEngine
 		loadPlugin(mStartUpDesc.renderer, &mRendererPlugin);
 
 		SceneManagerFactory::create();
-		RendererManager::instance().setActive(mStartUpDesc.renderer);
+		startUpRenderer();
 
 		ProfilerGPU::startUp();
 		MeshManager::startUp();
@@ -266,6 +266,11 @@ namespace BansheeEngine
 		BS_THREAD_NOTIFY_ONE(mFrameRenderingFinishedCondition);
 	}
 
+	void CoreApplication::startUpRenderer()
+	{
+		RendererManager::instance().setActive(mStartUpDesc.renderer);
+	}
+
 	void CoreApplication::beginCoreProfiling()
 	{
 		gProfilerCPU().beginThread("Core");

BansheeCore/Source/BsResources.cpp

@@ -429,6 +429,30 @@ namespace BansheeEngine
 		return nullptr;
 	}
 
+	bool Resources::isLoaded(const String& uuid, bool checkInProgress)
+	{
+		if (checkInProgress)
+		{
+			BS_LOCK_MUTEX(mInProgressResourcesMutex);
+			auto iterFind2 = mInProgressResources.find(uuid);
+			if (iterFind2 != mInProgressResources.end())
+			{
+				return true;
+			}
+
+			{
+				BS_LOCK_MUTEX(mLoadedResourceMutex);
+				auto iterFind = mLoadedResources.find(uuid);
+				if (iterFind != mLoadedResources.end())
+				{
+					return true;
+				}
+			}
+		}
+
+		return false;
+	}
+
 	HResource Resources::_createResourceHandle(const ResourcePtr& obj)
 	{
 		String uuid = UUIDGenerator::generateRandom();
@@ -445,15 +469,6 @@ namespace BansheeEngine
 
 	HResource Resources::_getResourceHandle(const String& uuid)
 	{
-		{
-			BS_LOCK_MUTEX(mLoadedResourceMutex);
-			auto iterFind = mLoadedResources.find(uuid);
-			if (iterFind != mLoadedResources.end()) // Resource is already loaded
-			{
-				return iterFind->second;
-			}
-		}
-
 		{
 			BS_LOCK_MUTEX(mInProgressResourcesMutex);
 			auto iterFind2 = mInProgressResources.find(uuid);
@@ -461,6 +476,15 @@ namespace BansheeEngine
 			{
 				return iterFind2->second->resource;
 			}
+
+			{
+				BS_LOCK_MUTEX(mLoadedResourceMutex);
+				auto iterFind = mLoadedResources.find(uuid);
+				if (iterFind != mLoadedResources.end()) // Resource is already loaded
+				{
+					return iterFind->second;
+				}
+			}
 		}
 
 		return HResource();

BansheeEditor/Source/BsProjectLibrary.cpp

@@ -392,13 +392,17 @@ namespace BansheeEngine
 			else
 				curImportOptions = importOptions;
 
+			bool unloadWhenDone = false;
 			HResource importedResource;
 			if (isNativeResource)
 			{
 				// If meta exists make sure it is registered in the manifest before load, otherwise it will get assigned a new UUID.
 				// This can happen if library isn't properly saved before exiting the application.
 				if (resource->meta != nullptr)
+				{
 					mResourceManifest->registerResource(resource->meta->getUUID(), resource->path);
+					unloadWhenDone = !gResources().isLoaded(resource->meta->getUUID());
+				}
 
 				// Don't load dependencies because we don't need them, but also because they might not be in the manifest
 				// which would screw up their UUIDs.
@@ -408,7 +412,10 @@ namespace BansheeEngine
 			if(resource->meta == nullptr)
 			{
 				if (!isNativeResource)
+				{
 					importedResource = Importer::instance().import(resource->path, curImportOptions);
+					unloadWhenDone = true;
+				}
 
 				if (importedResource != nullptr)
 				{
@@ -430,7 +437,14 @@ namespace BansheeEngine
 
 				if (!isNativeResource)
 				{
-					importedResource = HResource(resource->meta->getUUID());
+					importedResource = gResources()._getResourceHandle(resource->meta->getUUID());
+
+					if (importedResource == nullptr)
+					{
+						importedResource = HResource(resource->meta->getUUID());
+						unloadWhenDone = true;
+					}
+
 					Importer::instance().reimport(importedResource, resource->path, curImportOptions);
 				}
 			}
@@ -448,7 +462,7 @@ namespace BansheeEngine
 				internalResourcesPath.setFilename(toWString(importedResource.getUUID()) + L".asset");
 				gResources().save(importedResource, internalResourcesPath, true);
 
-				if (!isNativeResource)
+				if (unloadWhenDone)
 					gResources().unload(importedResource);
 
 				mResourceManifest->registerResource(importedResource.getUUID(), internalResourcesPath);

BansheeEngine/Include/BsApplication.h

@@ -90,6 +90,11 @@ namespace BansheeEngine
 		 */
 		virtual void postUpdate() override;
 
+		/**
+		 * @copydoc	CoreApplication::startUpRenderer.
+		 */
+		virtual void startUpRenderer() override;
+
 		/**
 		 * @brief	Loads the script system and all script libraries.
 		 */
@@ -104,15 +109,16 @@ namespace BansheeEngine
 		/**
 		 * @brief	Translates render system type into library name.
 		 */
-		static const String& getLibNameForRenderAPI(RenderAPIPlugin plugin);
+		static String getLibNameForRenderAPI(RenderAPIPlugin plugin);
 
 		/**
 		 * @brief	Translates renderer type into library name.
 		 */
-		static const String& getLibNameForRenderer(RendererPlugin plugin);
+		static String getLibNameForRenderer(RendererPlugin plugin);
 
 		DynLib* mMonoPlugin;
 		DynLib* mSBansheeEnginePlugin;
+		String mRenderer;
 	};
 
 	/**

BansheeEngine/Include/BsRendererMaterial.h

@@ -1,13 +1,25 @@
 #pragma once
 
 #include "BsPrerequisites.h"
+#include "BsMaterial.h"
 #include "BsRendererMaterialManager.h"
 
-#define RMAT_DEF(path) virtual Path getShaderPath() const override { return path; }
+#define RMAT_DEF(path)\
+	public: \
+	static void _initMetaData() \
+	{ \
+		RendererMaterialManager::_registerMaterial(&mMetaData, path); \
+	}; \
 
 namespace BansheeEngine
 {
-	class RendererMaterialManager;
+	/**
+	 * @brief	Contains data common to all render material instances of a specific type.
+	 */
+	struct RendererMaterialMetaData
+	{
+		SPtr<ShaderCore> shader;
+	};
 
 	/**
 	 * @brief	Base class for all RendererMaterial instances, containing common data and methods.
@@ -17,32 +29,33 @@ namespace BansheeEngine
 	public:
 		virtual ~RendererMaterialBase() { }
 
-		/**
-		 * @brief	Returns path relative to the default shader folder where the material shader is located.
-		 */
-		virtual Path getShaderPath() const { return Path::BLANK; }
-
 		/**
 		 * @brief	Returns the internal material.
 		 */
 		SPtr<MaterialCore> getMaterial() const { return mMaterial; }
 
-	private:
-		/**
-		 * @brief	Initializes the internal material. Should be called by the renderer material manager before
-		 * 			material may be used.
-		 */
-		void _initialize(const SPtr<ShaderCore>& shader);
-
 	protected:
 		friend class RendererMaterialManager;
 
+		SPtr<MaterialCore> mMaterial;
+	};
+
+	/**
+	 * @brief	Helper class to initialize all renderer materials as soon as the library is loaded.
+	 */
+	template <class T>
+	struct InitRendererMaterialStart
+	{
+	public:
+		InitRendererMaterialStart()
+		{
+			T::_initMetaData();
+		}
+
 		/**
-		 * @brief	Allows derived classes to initialize their data.
+		 * @brief	Forces the compiler to not optimize out construction of this type.
 		 */
-		virtual void initialize() { }
-
-		SPtr<MaterialCore> mMaterial;
+		void instantiate() { }
 	};
 
 	/**
@@ -52,38 +65,25 @@ namespace BansheeEngine
 	template<class T>
 	class RendererMaterial : public RendererMaterialBase
 	{
-	private:
-		/**
-		 * @brief	Helper class that allows renderer materials be registered on program/library load.
-		 */
-		struct InitOnStart
-		{
-		public:
-			InitOnStart()
-			{
-				RendererMaterialManager::_registerMaterial(&instance);
-			}
-
-			void makeSureIAmInstantiated() { }
-		};
-
 	public:
 		RendererMaterial()
 		{
-			mInit.makeSureIAmInstantiated();
+			mInitOnStart.instantiate();
+			mMaterial = MaterialCore::create(mMetaData.shader);
 		}
+
 		virtual ~RendererMaterial() { }
 
-		static T instance;
-	private:
+	protected:
 		friend class RendererMaterialManager;
 
-		static InitOnStart mInit;
+		static RendererMaterialMetaData mMetaData;
+		static InitRendererMaterialStart<T> mInitOnStart;
 	};
 
 	template<class T>
-	T RendererMaterial<T>::instance;
+	InitRendererMaterialStart<T> RendererMaterial<T>::mInitOnStart;
 
 	template<class T>
-	typename RendererMaterial<T>::InitOnStart RendererMaterial<T>::mInit;
+	RendererMaterialMetaData RendererMaterial<T>::mMetaData;
 }

BansheeEngine/Include/BsRendererMaterialManager.h

@@ -7,30 +7,53 @@
 namespace BansheeEngine
 {
 	class RendererMaterialBase;
+	struct RendererMaterialMetaData;
 
 	/**
 	 * @brief	Initializes and handles all renderer materials.
 	 */
 	class BS_EXPORT RendererMaterialManager : public Module<RendererMaterialManager>
 	{
+		/**
+		 * @brief	Information used for initializing a renderer material managed by this module.
+		 */	
+		struct RendererMaterialData
+		{
+			RendererMaterialMetaData* metaData;
+			Path shaderPath;
+		};
+
 	public:
 		RendererMaterialManager();
+		~RendererMaterialManager();
+
+		/**
+		 * @brief	Registers a new material that should be initialized on module start-up.
+		 */
+		static void _registerMaterial(RendererMaterialMetaData* metaData, const Path& shaderPath);
 
 	private:
 		template<class T>
 		friend class RendererMaterial;
 
 		/**
-		 * @brief	Registers a new material that should be initialized on module start-up.
+		 * @brief	Initializes all materials on the core thread.
 		 */
-		static void _registerMaterial(RendererMaterialBase* material);
+		static void initOnCore(const Vector<SPtr<ShaderCore>>& shaders);
 
 		/**
-		 * @brief	Initializes all materials on the core thread.
+		 * @brief	Destroys all materials on the core thread.
 		 */
-		static void initOnCore(const Vector<SPtr<ShaderCore>>& shaders);
+		static void destroyOnCore();
+
+		/**
+		 * @brief	Returns a list in which are all materials managed by this module.
+		 */
+		static Vector<RendererMaterialData>& getMaterials();
 
-		static Vector<RendererMaterialBase*> mMaterialsToInit;
-		static Mutex mMutex;
+		/**
+		 * @brief	Returns a mutex used for inter-thread access to the materials list.
+		 */
+		static Mutex& getMutex();
 	};
 }

BansheeEngine/Source/BsApplication.cpp

@@ -16,6 +16,7 @@
 #include "BsImporter.h"
 #include "BsShortcutManager.h"
 #include "BsCoreObjectManager.h"
+#include "BsRendererManager.h"
 #include "BsRendererMaterialManager.h"
 
 namespace BansheeEngine
@@ -38,7 +39,7 @@ namespace BansheeEngine
 
 	Application::Application(RENDER_WINDOW_DESC& primaryWindowDesc, RenderAPIPlugin renderAPI, RendererPlugin renderer)
 		:CoreApplication(createStartUpDesc(primaryWindowDesc, getLibNameForRenderAPI(renderAPI), getLibNameForRenderer(renderer))),
-		mMonoPlugin(nullptr), mSBansheeEnginePlugin(nullptr)
+		mMonoPlugin(nullptr), mSBansheeEnginePlugin(nullptr), mRenderer(getLibNameForRenderer(renderer))
 	{
 
 	}
@@ -72,6 +73,7 @@ namespace BansheeEngine
 		VirtualInput::startUp();
 		BuiltinResources::startUp();
 		RendererMaterialManager::startUp();
+		RendererManager::instance().setActive(mRenderer);
 		GUIManager::startUp();
 		GUIMaterialManager::startUp();
 		ShortcutManager::startUp();
@@ -131,6 +133,11 @@ namespace BansheeEngine
 		unloadPlugin(mMonoPlugin);
 	}
 
+	void Application::startUpRenderer()
+	{
+		// Do nothing, we activate the renderer at a later stage
+	}
+
 	ViewportPtr Application::getPrimaryViewport() const
 	{
 		// TODO - Need a way to determine primary viewport!
@@ -169,7 +176,7 @@ namespace BansheeEngine
 		return assemblyFolder;
 	}
 
-	const String& Application::getLibNameForRenderAPI(RenderAPIPlugin plugin)
+	String Application::getLibNameForRenderAPI(RenderAPIPlugin plugin)
 	{
 		static String DX11Name = "BansheeD3D11RenderAPI";
 		static String DX9Name = "BansheeD3D9RenderAPI";
@@ -188,7 +195,7 @@ namespace BansheeEngine
 		return StringUtil::BLANK;
 	}
 
-	const String& Application::getLibNameForRenderer(RendererPlugin plugin)
+	String Application::getLibNameForRenderer(RendererPlugin plugin)
 	{
 		static String DefaultName = "RenderBeast";
 

BansheeEngine/Source/BsRendererMaterial.cpp

@@ -3,10 +3,5 @@
 
 namespace BansheeEngine
 {
-	void RendererMaterialBase::_initialize(const SPtr<ShaderCore>& shader)
-	{
-		mMaterial = MaterialCore::create(shader);
 
-		initialize();
-	}
 }

BansheeEngine/Source/BsRendererMaterialManager.cpp

@@ -5,40 +5,64 @@
 
 namespace BansheeEngine
 {
-	Vector<RendererMaterialBase*> RendererMaterialManager::mMaterialsToInit;
-	Mutex RendererMaterialManager::mMutex;
-
 	RendererMaterialManager::RendererMaterialManager()
 	{
 		BuiltinResources& br = BuiltinResources::instance();
 
+		Vector<RendererMaterialData>& materials = getMaterials();
 		Vector<SPtr<ShaderCore>> shaders;
-		for (auto& material : mMaterialsToInit)
+		for (auto& material : materials)
 		{
-			HShader shader = br.getShader(material->getShaderPath());
+			HShader shader = br.getShader(material.shaderPath);
 			if (shader.isLoaded())
 				shaders.push_back(shader->getCore());
 			else
 				shaders.push_back(nullptr);
 		}
 
-		gCoreAccessor().queueCommand(std::bind(&RendererMaterialManager::initOnCore, shaders));
+		gCoreThread().queueCommand(std::bind(&RendererMaterialManager::initOnCore, shaders));
+	}
+
+	RendererMaterialManager::~RendererMaterialManager()
+	{
+		gCoreAccessor().queueCommand(std::bind(&RendererMaterialManager::destroyOnCore));
 	}
 
-	void RendererMaterialManager::_registerMaterial(RendererMaterialBase* data)
+	void RendererMaterialManager::_registerMaterial(RendererMaterialMetaData* metaData, const Path& shaderPath)
 	{
-		Lock<> lock(mMutex);
+		Lock<> lock(getMutex());
 
-		mMaterialsToInit.push_back(data);
+		Vector<RendererMaterialData>& materials = getMaterials();
+		materials.push_back({metaData, shaderPath});
 	}
 
 	void RendererMaterialManager::initOnCore(const Vector<SPtr<ShaderCore>>& shaders)
 	{
-		Lock<> lock(mMutex);
+		Lock<> lock(getMutex());
 
-		for (UINT32 i = 0; i < mMaterialsToInit.size(); i++)
-		{
-			mMaterialsToInit[i]->_initialize(shaders[i]);
-		}
+		Vector<RendererMaterialData>& materials = getMaterials();
+		for (UINT32 i = 0; i < materials.size(); i++)
+			materials[i].metaData->shader = shaders[i];
+	}
+
+	void RendererMaterialManager::destroyOnCore()
+	{
+		Lock<> lock(getMutex());
+
+		Vector<RendererMaterialData>& materials = getMaterials();
+		for (UINT32 i = 0; i < materials.size(); i++)
+			materials[i].metaData->shader = nullptr;
+	}
+
+	Vector<RendererMaterialManager::RendererMaterialData>& RendererMaterialManager::getMaterials()
+	{
+		static Vector<RendererMaterialData> materials;
+		return materials;
+	}
+
+	Mutex& RendererMaterialManager::getMutex()
+	{
+		static Mutex mutex;
+		return mutex;
 	}
 }

RenderBeast/Include/BsLightRendering.h

@@ -41,16 +41,13 @@ namespace BansheeEngine
 		RMAT_DEF("DeferredDirectionalLightPass.bsl");
 
 	public:
+		DirectionalLightMat();
+
 		/**
 		 * Updates the parameter buffers used by the material.
 		 */
 		void setParameters(const LightCore* light);
 	private:
-		/**
-		 * @copydoc RendererMaterial::initialize
-		 */
-		void initialize() override;
-
 		PerLightParams mParams; // Note: Should this buffer be shared between both point and directional lights?
 	};
 
@@ -62,16 +59,13 @@ namespace BansheeEngine
 		RMAT_DEF("DeferredPointLightPass.bsl");
 
 	public:
+		PointLightMat();
+
 		/**
 		 * Updates the parameter buffers used by the material.
 		 */
 		void setParameters(const LightCore* light);
 	private:
-		/**
-		 * @copydoc RendererMaterial::initialize
-		 */
-		void initialize() override;
-
 		PerLightParams mParams; // Note: Should this buffer be shared between both point and directional lights?
 	};
 }

RenderBeast/Include/BsRenderBeast.h

@@ -5,6 +5,8 @@
 #include "BsBounds.h"
 #include "BsRenderableElement.h"
 #include "BsSamplerOverrides.h"
+#include "BsRendererMaterial.h"
+#include "BsLightRendering.h"
 
 namespace BansheeEngine
 {
@@ -16,6 +18,12 @@ namespace BansheeEngine
 	 */
 	static StringID RPS_Time = "Time";
 
+	/** Basic shader that is used when no other is available. */
+	class DefaultMaterial : public RendererMaterial<DefaultMaterial> { RMAT_DEF("Default.bsl"); };
+
+	/** Basic shader that is used when no other is available, and the rendered mesh has no normal information. */
+	class DefaultMaterialNoNormal : public RendererMaterial<DefaultMaterialNoNormal> { RMAT_DEF("DefaultNoNormal.bsl"); };
+
 	/**
 	 * @brief	Data used by the renderer when rendering renderable handlers.
 	 */
@@ -275,6 +283,11 @@ namespace BansheeEngine
 
 		SPtr<RenderBeastOptions> mCoreOptions; // Core thread
 
+		DefaultMaterial* mDefaultMaterial; // Core thread
+		DefaultMaterialNoNormal* mDefaultNoNormalMaterial; // Core thread
+		PointLightMat* mPointLightMat; // Core thread
+		DirectionalLightMat* mDirLightMat; // Core thread
+
 		StaticRenderableHandler* mStaticHandler;
 		SPtr<RenderBeastOptions> mOptions;
 		bool mOptionsDirty;

RenderBeast/Source/BsLightRendering.cpp

@@ -59,12 +59,17 @@ namespace BansheeEngine
 		return mBuffer.getBuffer();
 	}
 	
+	DirectionalLightMat::DirectionalLightMat()
+	{
+		mMaterial->setParamBlockBuffer("PerLight", mParams.getBuffer());
+	}
+
 	void DirectionalLightMat::setParameters(const LightCore* light)
 	{
 		mParams.setParameters(light);
 	}
 
-	void DirectionalLightMat::initialize()
+	PointLightMat::PointLightMat()
 	{
 		mMaterial->setParamBlockBuffer("PerLight", mParams.getBuffer());
 	}
@@ -73,9 +78,4 @@ namespace BansheeEngine
 	{
 		mParams.setParameters(light);
 	}
-
-	void PointLightMat::initialize()
-	{
-		mMaterial->setParamBlockBuffer("PerLight", mParams.getBuffer());
-	}
 }

RenderBeast/Source/BsRenderBeast.cpp

@@ -33,20 +33,14 @@
 #include "BsLight.h"
 #include "BsRenderTexturePool.h"
 #include "BsRenderTargets.h"
-#include "BsLightRendering.h"
 
 using namespace std::placeholders;
 
 namespace BansheeEngine
 {
-	/** Basic shader that is used when no other is available. */
-	class DefaultMaterial : public RendererMaterial<DefaultMaterial> { RMAT_DEF("Default.bsl"); };
-
-	/** Basic shader that is used when no other is available, and the rendered mesh has no normal information. */
-	class DefaultMaterialNoNormal : public RendererMaterial<DefaultMaterialNoNormal> { RMAT_DEF("DefaultNoNormal.bsl"); };
-
 	RenderBeast::RenderBeast()
-		:mOptions(bs_shared_ptr_new<RenderBeastOptions>()), mOptionsDirty(true), mStaticHandler(nullptr)
+		:mOptions(bs_shared_ptr_new<RenderBeastOptions>()), mOptionsDirty(true), mStaticHandler(nullptr),
+		mDefaultMaterial(nullptr), mDefaultNoNormalMaterial(nullptr), mPointLightMat(nullptr), mDirLightMat(nullptr)
 	{
 
 	}
@@ -61,7 +55,7 @@ namespace BansheeEngine
 	{
 		CoreRenderer::_onActivated();
 
-		gCoreAccessor().queueCommand(std::bind(&RenderBeast::initializeCore, this));
+		gCoreThread().queueCommand(std::bind(&RenderBeast::initializeCore, this));
 	}
 
 	void RenderBeast::_onDeactivated()
@@ -77,6 +71,11 @@ namespace BansheeEngine
 		mCoreOptions = bs_shared_ptr_new<RenderBeastOptions>();
 		mStaticHandler = bs_new<StaticRenderableHandler>();
 
+		mDefaultMaterial = bs_new<DefaultMaterial>();
+		mDefaultNoNormalMaterial = bs_new<DefaultMaterialNoNormal>();
+		mPointLightMat = bs_new<PointLightMat>();
+		mDirLightMat = bs_new<DirectionalLightMat>();
+
 		RenderTexturePool::startUp();
 	}
 
@@ -91,6 +90,11 @@ namespace BansheeEngine
 
 		RenderTexturePool::shutDown();
 
+		bs_delete(mDefaultMaterial);
+		bs_delete(mDefaultNoNormalMaterial);
+		bs_delete(mPointLightMat);
+		bs_delete(mDirLightMat);
+
 		assert(mSamplerOverrides.empty());
 	}
 
@@ -142,9 +146,9 @@ namespace BansheeEngine
 					const VertexDeclarationProperties& vertexProps = vertexData->vertexDeclaration->getProperties();
 
 					if (vertexProps.findElementBySemantic(VES_NORMAL))
-						renElement.material = DefaultMaterial::instance.getMaterial();
+						renElement.material = mDefaultMaterial->getMaterial();
 					else
-						renElement.material = DefaultMaterialNoNormal::instance.getMaterial();
+						renElement.material = mDefaultNoNormalMaterial->getMaterial();
 				}
 
 				auto iterFind = mSamplerOverrides.find(renElement.material);
@@ -588,7 +592,7 @@ namespace BansheeEngine
 		// Render lights and resolve gbuffer if there is one
 		if (hasGBuffer)
 		{
-			SPtr<MaterialCore> dirMaterial = DirectionalLightMat::instance.getMaterial();
+			SPtr<MaterialCore> dirMaterial = mDirLightMat->getMaterial();
 			SPtr<PassCore> dirPass = dirMaterial->getPass(0);
 
 			setPass(dirPass);
@@ -598,7 +602,7 @@ namespace BansheeEngine
 				if (!light.internal->getIsActive())
 					continue;
 
-				DirectionalLightMat::instance.setParameters(light.internal);
+				mDirLightMat->setParameters(light.internal);
 
 				SPtr<MeshCore> mesh = nullptr; // TODO - Get full screen quad
 				draw(mesh, mesh->getProperties().getSubMesh(0));
@@ -610,7 +614,7 @@ namespace BansheeEngine
 				if (!light.internal->getIsActive())
 					continue;
 
-				PointLightMat::instance.setParameters(light.internal);
+				mPointLightMat->setParameters(light.internal);
 
 				SPtr<MeshCore> mesh = light.internal->getMesh();
 				draw(mesh, mesh->getProperties().getSubMesh(0));