Various fixes to Renderer

BansheeCore/Include/BsCorePrerequisites.h

@@ -233,6 +233,7 @@ namespace BansheeEngine
 	typedef std::shared_ptr<MaterialProxy> MaterialProxyPtr;
 	typedef std::shared_ptr<MeshProxy> MeshProxyPtr;
 	typedef std::shared_ptr<ShaderProxy> ShaderProxyPtr;
+	typedef std::shared_ptr<GpuParamDesc> GpuParamDescPtr;
 }
 
 /************************************************************************/

BansheeCore/Include/BsGpuParams.h

@@ -24,18 +24,20 @@ namespace BansheeEngine
 		/**
 		 * @brief	Creates new GpuParams object using the specified parameter descriptions.
 		 *
+		 * @param	paramDesc			Reference to parameter descriptions that will be used for
+		 *								finding needed parameters.
 		 * @param	transposeMatrices	If true the stored matrices will be transposed before
 		 *								submitted to the GPU (some APIs require different
 		 *								matrix layout).
 		 *
 		 * @note	You normally do not want to call this manually. Instead use GpuProgram::createParameters.
 		 */
-		GpuParams(GpuParamDesc& paramDesc, bool transposeMatrices);
+		GpuParams(const GpuParamDescPtr& paramDesc, bool transposeMatrices);
 
 		/**
 		 * @brief	Private constructor for internal use. Performs no initialization.
 		 */
-		GpuParams(GpuParamDesc& paramDesc, PrivatelyConstruct& dummy);
+		GpuParams(const GpuParamDescPtr& paramDesc, PrivatelyConstruct& dummy);
 
 		~GpuParams();
 
@@ -71,7 +73,7 @@ namespace BansheeEngine
 		/**
 		 * @brief	Returns a description of all stored parameters.
 		 */
-		const GpuParamDesc& getParamDesc() const { return mParamDesc; }
+		const GpuParamDesc& getParamDesc() const { return *mParamDesc; }
 
 		/**
 		 * @brief	Returns the size of a data parameter with the specified name, in bytes.
@@ -119,9 +121,9 @@ namespace BansheeEngine
 		template<>
 		void getParam<float>(const String& name, TGpuDataParam<float>& output) const
 		{
-			auto iterFind = mParamDesc.params.find(name);
+			auto iterFind = mParamDesc->params.find(name);
 
-			if (iterFind == mParamDesc.params.end() || iterFind->second.type != GPDT_FLOAT1)
+			if (iterFind == mParamDesc->params.end() || iterFind->second.type != GPDT_FLOAT1)
 				BS_EXCEPT(InvalidParametersException, "Cannot find float parameter with the name '" + name + "'");
 
 			output = GpuParamFloat(&iterFind->second, mInternalData);
@@ -133,9 +135,9 @@ namespace BansheeEngine
 		template<>
 		void getParam<Vector2>(const String& name, TGpuDataParam<Vector2>& output) const
 		{
-			auto iterFind = mParamDesc.params.find(name);
+			auto iterFind = mParamDesc->params.find(name);
 
-			if (iterFind == mParamDesc.params.end() || iterFind->second.type != GPDT_FLOAT2)
+			if (iterFind == mParamDesc->params.end() || iterFind->second.type != GPDT_FLOAT2)
 				BS_EXCEPT(InvalidParametersException, "Cannot find vector (2) parameter with the name '" + name + "'");
 
 			output = GpuParamVec2(&iterFind->second, mInternalData);
@@ -147,9 +149,9 @@ namespace BansheeEngine
 		template<>
 		void getParam<Vector3>(const String& name, TGpuDataParam<Vector3>& output) const
 		{
-			auto iterFind = mParamDesc.params.find(name);
+			auto iterFind = mParamDesc->params.find(name);
 
-			if (iterFind == mParamDesc.params.end() || iterFind->second.type != GPDT_FLOAT3)
+			if (iterFind == mParamDesc->params.end() || iterFind->second.type != GPDT_FLOAT3)
 				BS_EXCEPT(InvalidParametersException, "Cannot find vector (3) parameter with the name '" + name + "'");
 
 			output = GpuParamVec3(&iterFind->second, mInternalData);
@@ -161,9 +163,9 @@ namespace BansheeEngine
 		template<>
 		void getParam<Vector4>(const String& name, TGpuDataParam<Vector4>& output) const
 		{
-			auto iterFind = mParamDesc.params.find(name);
+			auto iterFind = mParamDesc->params.find(name);
 
-			if (iterFind == mParamDesc.params.end() || iterFind->second.type != GPDT_FLOAT4)
+			if (iterFind == mParamDesc->params.end() || iterFind->second.type != GPDT_FLOAT4)
 				BS_EXCEPT(InvalidParametersException, "Cannot find vector (4) parameter with the name '" + name + "'");
 
 			output = GpuParamVec4(&iterFind->second, mInternalData);
@@ -175,9 +177,9 @@ namespace BansheeEngine
 		template<>
 		void getParam<Matrix3>(const String& name, TGpuDataParam<Matrix3>& output) const
 		{
-			auto iterFind = mParamDesc.params.find(name);
+			auto iterFind = mParamDesc->params.find(name);
 
-			if (iterFind == mParamDesc.params.end() || iterFind->second.type != GPDT_MATRIX_3X3)
+			if (iterFind == mParamDesc->params.end() || iterFind->second.type != GPDT_MATRIX_3X3)
 				BS_EXCEPT(InvalidParametersException, "Cannot find matrix (3x3) parameter with the name '" + name + "'");
 
 			output = GpuParamMat3(&iterFind->second, mInternalData);
@@ -189,9 +191,9 @@ namespace BansheeEngine
 		template<>
 		void getParam<Matrix4>(const String& name, TGpuDataParam<Matrix4>& output) const
 		{
-			auto iterFind = mParamDesc.params.find(name);
+			auto iterFind = mParamDesc->params.find(name);
 
-			if (iterFind == mParamDesc.params.end() || iterFind->second.type != GPDT_MATRIX_4X4)
+			if (iterFind == mParamDesc->params.end() || iterFind->second.type != GPDT_MATRIX_4X4)
 				BS_EXCEPT(InvalidParametersException, "Cannot find matrix (4x4) parameter with the name '" + name + "'");
 
 			output = GpuParamMat4(&iterFind->second, mInternalData);
@@ -260,7 +262,7 @@ namespace BansheeEngine
 		void _markCoreClean();
 
 	private:
-		GpuParamDesc& mParamDesc;
+		GpuParamDescPtr mParamDesc;
 		std::shared_ptr<GpuParamsInternalData> mInternalData;
 
 		/**

BansheeCore/Include/BsGpuProgram.h

@@ -138,7 +138,7 @@ namespace BansheeEngine
 		/**
 		 * @brief	Returns description of all parameters in this GPU program.
 		 */
-		const GpuParamDesc& getParamDesc() const { return mParametersDesc; }
+		GpuParamDescPtr getParamDesc() const { return mParametersDesc; }
 
 		/**
 		* @brief	Language this shader was created from (e.g. HLSL, GLSL).
@@ -195,7 +195,7 @@ namespace BansheeEngine
 		bool mIsCompiled;
 		String mCompileError;
 
-		GpuParamDesc mParametersDesc;
+		GpuParamDescPtr mParametersDesc;
 
 		/************************************************************************/
 		/* 								SERIALIZATION                      		*/

BansheeCore/Include/BsMaterial.h

@@ -516,23 +516,23 @@ namespace BansheeEngine
 		 * @brief	Constructs a map containing all data parameters (e.g. float, vector3, color).
 		 * 			Map contains parameter names and descriptions.
 		 */
-		Map<String, const GpuParamDataDesc*> determineValidDataParameters(const Vector<const GpuParamDesc*>& paramDescs) const;
+		Map<String, const GpuParamDataDesc*> determineValidDataParameters(const Vector<GpuParamDescPtr>& paramDescs) const;
 
 		/**
 		 * @brief	Constructs a list containing all object parameter (e.g. texture, sampler state) names.
 		 */
-		Set<String> determineValidObjectParameters(const Vector<const GpuParamDesc*>& paramDescs) const;
+		Set<String> determineValidObjectParameters(const Vector<GpuParamDescPtr>& paramDescs) const;
 
 		/**
 		 * @brief	Constructs a list containing all shareable parameter block names. Shareable blocks may be shared between
 		 * 			different GPU programs, passes or even materials. 
 		 */
-		Set<String> determineValidShareableParamBlocks(const Vector<const GpuParamDesc*>& paramDescs) const;
+		Set<String> determineValidShareableParamBlocks(const Vector<GpuParamDescPtr>& paramDescs) const;
 
 		/**
 		 * @brief	Constructs a map that maps parameter names to a parameter block.
 		 */
-		Map<String, String> determineParameterToBlockMapping(const Vector<const GpuParamDesc*>& paramDescs);
+		Map<String, String> determineParameterToBlockMapping(const Vector<GpuParamDescPtr>& paramDescs);
 
 		/**
 		 * @brief	Checks are the specified two parameters equal

BansheeCore/Source/BsGpuParams.cpp

@@ -15,25 +15,25 @@ namespace BansheeEngine
 		mIsDestroyed(false)
 	{ }
 
-	GpuParams::GpuParams(GpuParamDesc& paramDesc, bool transposeMatrices)
+	GpuParams::GpuParams(const GpuParamDescPtr& paramDesc, bool transposeMatrices)
 		:mParamDesc(paramDesc)
 	{
 		mInternalData = bs_shared_ptr<GpuParamsInternalData>();
 		mInternalData->mTransposeMatrices = transposeMatrices;
 
-		for(auto& paramBlock : mParamDesc.paramBlocks)
+		for(auto& paramBlock : mParamDesc->paramBlocks)
 		{
 			if ((paramBlock.second.slot + 1) > mInternalData->mNumParamBlocks)
 				mInternalData->mNumParamBlocks = paramBlock.second.slot + 1;
 		}
 
-		for(auto& texture : mParamDesc.textures)
+		for(auto& texture : mParamDesc->textures)
 		{
 			if ((texture.second.slot + 1) > mInternalData->mNumTextures)
 				mInternalData->mNumTextures = texture.second.slot + 1;
 		}
 
-		for(auto& sampler : mParamDesc.samplers)
+		for(auto& sampler : mParamDesc->samplers)
 		{
 			if ((sampler.second.slot + 1) > mInternalData->mNumSamplerStates)
 				mInternalData->mNumSamplerStates = sampler.second.slot + 1;
@@ -42,7 +42,7 @@ namespace BansheeEngine
 		constructInternalBuffers();
 	}
 
-	GpuParams::GpuParams(GpuParamDesc& paramDesc, PrivatelyConstruct& dummy)
+	GpuParams::GpuParams(const GpuParamDescPtr& paramDesc, PrivatelyConstruct& dummy)
 		:mParamDesc(paramDesc)
 	{
 		
@@ -87,9 +87,9 @@ namespace BansheeEngine
 
 	void GpuParams::setParamBlockBuffer(const String& name, const GpuParamBlockBufferPtr& paramBlockBuffer)
 	{
-		auto iterFind = mParamDesc.paramBlocks.find(name);
+		auto iterFind = mParamDesc->paramBlocks.find(name);
 
-		if(iterFind == mParamDesc.paramBlocks.end())
+		if(iterFind == mParamDesc->paramBlocks.end())
 		{
 			LOGWRN("Cannot find parameter block with the name: " + name);
 			return;
@@ -117,8 +117,8 @@ namespace BansheeEngine
 
 	bool GpuParams::hasTexture(const String& name) const
 	{
-		auto paramIter = mParamDesc.textures.find(name);
-		if(paramIter != mParamDesc.textures.end())
+		auto paramIter = mParamDesc->textures.find(name);
+		if(paramIter != mParamDesc->textures.end())
 			return true;
 
 		return false;
@@ -126,8 +126,8 @@ namespace BansheeEngine
 
 	bool GpuParams::hasSamplerState(const String& name) const
 	{
-		auto paramIter = mParamDesc.samplers.find(name);
-		if(paramIter != mParamDesc.samplers.end())
+		auto paramIter = mParamDesc->samplers.find(name);
+		if(paramIter != mParamDesc->samplers.end())
 			return true;
 
 		return false;
@@ -135,8 +135,8 @@ namespace BansheeEngine
 
 	bool GpuParams::hasParamBlock(const String& name) const
 	{
-		auto paramBlockIter = mParamDesc.paramBlocks.find(name);
-		if(paramBlockIter != mParamDesc.paramBlocks.end())
+		auto paramBlockIter = mParamDesc->paramBlocks.find(name);
+		if(paramBlockIter != mParamDesc->paramBlocks.end())
 			return true;
 
 		return false;
@@ -144,9 +144,9 @@ namespace BansheeEngine
 
 	void GpuParams::getStructParam(const String& name, GpuParamStruct& output) const
 	{
-		auto iterFind = mParamDesc.params.find(name);
+		auto iterFind = mParamDesc->params.find(name);
 
-		if (iterFind == mParamDesc.params.end() || iterFind->second.type != GPDT_STRUCT)
+		if (iterFind == mParamDesc->params.end() || iterFind->second.type != GPDT_STRUCT)
 			BS_EXCEPT(InvalidParametersException, "Cannot find struct parameter with the name '" + name + "'");
 
 		output = GpuParamStruct(&iterFind->second, mInternalData);
@@ -154,9 +154,9 @@ namespace BansheeEngine
 
 	void GpuParams::getTextureParam(const String& name, GpuParamTexture& output) const
 	{
-		auto iterFind = mParamDesc.textures.find(name);
+		auto iterFind = mParamDesc->textures.find(name);
 
-		if (iterFind == mParamDesc.textures.end())
+		if (iterFind == mParamDesc->textures.end())
 			BS_EXCEPT(InvalidParametersException, "Cannot find texture parameter with the name '" + name + "'");
 
 		output = GpuParamTexture(&iterFind->second, mInternalData);
@@ -164,9 +164,9 @@ namespace BansheeEngine
 
 	void GpuParams::getSamplerStateParam(const String& name, GpuParamSampState& output) const
 	{
-		auto iterFind = mParamDesc.samplers.find(name);
+		auto iterFind = mParamDesc->samplers.find(name);
 
-		if (iterFind == mParamDesc.samplers.end())
+		if (iterFind == mParamDesc->samplers.end())
 			BS_EXCEPT(InvalidParametersException, "Cannot find sampler state parameter with the name '" + name + "'");
 
 		output = GpuParamSampState(&iterFind->second, mInternalData);
@@ -174,8 +174,8 @@ namespace BansheeEngine
 
 	GpuParamDataDesc* GpuParams::getParamDesc(const String& name) const
 	{
-		auto paramIter = mParamDesc.params.find(name);
-		if(paramIter != mParamDesc.params.end())
+		auto paramIter = mParamDesc->params.find(name);
+		if(paramIter != mParamDesc->params.end())
 			return &paramIter->second;
 
 		return nullptr;

BansheeCore/Source/BsGpuProgram.cpp

@@ -18,6 +18,8 @@ namespace BansheeEngine
 		:mEntryPoint(entryPoint), mType(gptype), mIsCompiled(false),
 		mProfile(profile), mNeedsAdjacencyInfo(isAdjacencyInfoRequired)
     {
+		mParametersDesc = bs_shared_ptr<GpuParamDesc>();
+
 		if(includes != nullptr)
 		{
 			StringStream stringStream;
@@ -61,7 +63,7 @@ namespace BansheeEngine
 
 	GpuParamsPtr GpuProgram::createParameters()
 	{
-		return bs_shared_ptr<GpuParams, PoolAlloc>(std::ref(mParametersDesc), false);
+		return bs_shared_ptr<GpuParams, PoolAlloc>(mParametersDesc, false);
 	}
 
     const String& GpuProgram::getLanguage() const

BansheeCore/Source/BsMaterial.cpp

@@ -49,7 +49,7 @@ namespace BansheeEngine
 			mValidShareableParamBlocks.clear();
 			mValidParams.clear();
 
-			Vector<const GpuParamDesc*> allParamDescs;
+			Vector<GpuParamDescPtr> allParamDescs;
 
 			// Make sure all gpu programs are fully loaded
 			for(UINT32 i = 0; i < mBestTechnique->getNumPasses(); i++)
@@ -60,42 +60,42 @@ namespace BansheeEngine
 				if(vertProgram)
 				{
 					vertProgram.synchronize();
-					allParamDescs.push_back(&vertProgram->getParamDesc());
+					allParamDescs.push_back(vertProgram->getParamDesc());
 				}
 
 				HGpuProgram fragProgram = curPass->getFragmentProgram();
 				if(fragProgram)
 				{
 					fragProgram.synchronize();
-					allParamDescs.push_back(&fragProgram->getParamDesc());
+					allParamDescs.push_back(fragProgram->getParamDesc());
 				}
 
 				HGpuProgram geomProgram = curPass->getGeometryProgram();
 				if(geomProgram)
 				{
 					geomProgram.synchronize();
-					allParamDescs.push_back(&geomProgram->getParamDesc());
+					allParamDescs.push_back(geomProgram->getParamDesc());
 				}
 
 				HGpuProgram hullProgram = curPass->getHullProgram();
 				if(hullProgram)
 				{
 					hullProgram.synchronize();
-					allParamDescs.push_back(&hullProgram->getParamDesc());
+					allParamDescs.push_back(hullProgram->getParamDesc());
 				}
 
 				HGpuProgram domainProgram = curPass->getDomainProgram();
 				if(domainProgram)
 				{
 					domainProgram.synchronize();
-					allParamDescs.push_back(&domainProgram->getParamDesc());
+					allParamDescs.push_back(domainProgram->getParamDesc());
 				}
 
 				HGpuProgram computeProgram = curPass->getComputeProgram();
 				if(computeProgram)
 				{
 					computeProgram.synchronize();
-					allParamDescs.push_back(&computeProgram->getParamDesc());
+					allParamDescs.push_back(computeProgram->getParamDesc());
 				}
 			}
 
@@ -264,7 +264,7 @@ namespace BansheeEngine
 		mCoreDirtyFlags = 0xFFFFFFFF;
 	}
 
-	Map<String, const GpuParamDataDesc*> Material::determineValidDataParameters(const Vector<const GpuParamDesc*>& paramDescs) const
+	Map<String, const GpuParamDataDesc*> Material::determineValidDataParameters(const Vector<GpuParamDescPtr>& paramDescs) const
 	{
 		Map<String, const GpuParamDataDesc*> foundDataParams;
 		Map<String, bool> validParams;
@@ -305,8 +305,7 @@ namespace BansheeEngine
 		return foundDataParams;
 	}
 
-	
-	Set<String> Material::determineValidObjectParameters(const Vector<const GpuParamDesc*>& paramDescs) const
+	Set<String> Material::determineValidObjectParameters(const Vector<GpuParamDescPtr>& paramDescs) const
 	{
 		Set<String> validParams;
 
@@ -339,10 +338,10 @@ namespace BansheeEngine
 		return validParams;
 	}
 
-	Set<String> Material::determineValidShareableParamBlocks(const Vector<const GpuParamDesc*>& paramDescs) const
+	Set<String> Material::determineValidShareableParamBlocks(const Vector<GpuParamDescPtr>& paramDescs) const
 	{
 		// Make sure param blocks with the same name actually are the same
-		Map<String, std::pair<String, const GpuParamDesc*>> uniqueParamBlocks;
+		Map<String, std::pair<String, GpuParamDescPtr>> uniqueParamBlocks;
 		Map<String, bool> validParamBlocks;
 
 		for(auto iter = paramDescs.begin(); iter != paramDescs.end(); ++iter)
@@ -365,7 +364,7 @@ namespace BansheeEngine
 				}
 
 				String otherBlockName = iterFind->second.first;
-				const GpuParamDesc* otherDesc = iterFind->second.second;
+				GpuParamDescPtr otherDesc = iterFind->second.second;
 
 				for(auto myParamIter = curDesc.params.begin(); myParamIter != curDesc.params.end(); ++myParamIter)
 				{
@@ -413,7 +412,7 @@ namespace BansheeEngine
 		return validParamBlocksReturn;
 	}
 
-	Map<String, String> Material::determineParameterToBlockMapping(const Vector<const GpuParamDesc*>& paramDescs)
+	Map<String, String> Material::determineParameterToBlockMapping(const Vector<GpuParamDescPtr>& paramDescs)
 	{
 		Map<String, String> paramToParamBlock;
 

BansheeD3D11RenderSystem/Source/BsD3D11GpuProgram.cpp

@@ -130,19 +130,19 @@ namespace BansheeEngine
 		if (mType == GPT_VERTEX_PROGRAM)
 		{
 			VertexDeclaration::VertexElementList inputParams;
-			parser.parse(microcode, mParametersDesc, &inputParams);
+			parser.parse(microcode, *mParametersDesc, &inputParams);
 
 			mInputDeclaration = HardwareBufferManager::instance().createVertexDeclaration(inputParams);
 		}
 		else
 		{
-			parser.parse(microcode, mParametersDesc, nullptr);
+			parser.parse(microcode, *mParametersDesc, nullptr);
 		}
 	}
 
 	GpuParamsPtr D3D11GpuProgram::createParameters()
 	{
-		GpuParamsPtr params = bs_shared_ptr<GpuParams, PoolAlloc>(std::ref(mParametersDesc), mColumnMajorMatrices);
+		GpuParamsPtr params = bs_shared_ptr<GpuParams, PoolAlloc>(mParametersDesc, mColumnMajorMatrices);
 		return params;
 	}
 

BansheeD3D11RenderSystem/Source/BsD3D11RenderWindow.cpp

@@ -624,7 +624,7 @@ namespace BansheeEngine
 		mSwapChainDesc.BufferCount = 1;
 		mSwapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD ;
 
-		mSwapChainDesc.Windowed	= false;
+		mSwapChainDesc.Windowed	= true;
 
 		D3D11RenderSystem* rs = static_cast<D3D11RenderSystem*>(RenderSystem::instancePtr());
 		rs->determineMultisampleSettings(mMultisampleCount, mMultisampleHint, format, &mMultisampleType);

BansheeD3D9RenderSystem/Include/BsD3D9HLSLParamParser.h

@@ -12,7 +12,7 @@ namespace BansheeEngine
 			:mpConstTable(constTable), mBlocks(blocks)
 		{ }
 
-		GpuParamDesc buildParameterDescriptions();
+		GpuParamDescPtr buildParameterDescriptions();
 
 	private:
 		void processParameter(GpuParamBlockDesc& blockDesc, const String& paramName, D3DXHANDLE constant,
@@ -24,7 +24,7 @@ namespace BansheeEngine
 	private:
 		LPD3DXCONSTANTTABLE mpConstTable;
 		Vector<D3D9EmulatedParamBlock> mBlocks;
-		GpuParamDesc mParamDesc;
+		GpuParamDescPtr mParamDesc;
 	};
 
 	String D3D9HLSLParamParser::getParamName(D3DXHANDLE constant)
@@ -49,11 +49,13 @@ namespace BansheeEngine
 		return paramName;
 	}
 
-	GpuParamDesc D3D9HLSLParamParser::buildParameterDescriptions()
+	GpuParamDescPtr D3D9HLSLParamParser::buildParameterDescriptions()
 	{
 		// Derive parameter names from const table
 		assert(mpConstTable && "Program not loaded!");
 
+		mParamDesc = bs_shared_ptr<GpuParamDesc>();
+
 		// Get contents of the constant table
 		D3DXCONSTANTTABLE_DESC desc;
 		HRESULT hr = mpConstTable->GetDesc(&desc);
@@ -63,8 +65,8 @@ namespace BansheeEngine
 
 		// DX9 has no concept of parameter blocks so we emulate them if needed
 		String name = "BS_INTERNAL_Globals";
-		mParamDesc.paramBlocks.insert(std::make_pair(name, GpuParamBlockDesc()));
-		GpuParamBlockDesc& globalBlockDesc = mParamDesc.paramBlocks[name];
+		mParamDesc->paramBlocks.insert(std::make_pair(name, GpuParamBlockDesc()));
+		GpuParamBlockDesc& globalBlockDesc = mParamDesc->paramBlocks[name];
 		globalBlockDesc.name = name;
 		globalBlockDesc.slot = 0;
 		globalBlockDesc.blockSize = 0;
@@ -74,8 +76,8 @@ namespace BansheeEngine
 		UINT32 curSlot = 1;
 		for (auto& block : mBlocks)
 		{
-			mParamDesc.paramBlocks.insert(std::make_pair(block.blockName, GpuParamBlockDesc()));
-			GpuParamBlockDesc& blockDesc = mParamDesc.paramBlocks[block.blockName];
+			mParamDesc->paramBlocks.insert(std::make_pair(block.blockName, GpuParamBlockDesc()));
+			GpuParamBlockDesc& blockDesc = mParamDesc->paramBlocks[block.blockName];
 			blockDesc.name = block.blockName;
 			blockDesc.slot = curSlot++;
 			blockDesc.blockSize = 0;
@@ -98,7 +100,7 @@ namespace BansheeEngine
 			if (findIter == nonGlobalBlocks.end())
 				processParameter(globalBlockDesc, paramName, constantHandle, "", i);
 			else
-				processParameter(mParamDesc.paramBlocks[findIter->second], paramName, constantHandle, "", i);
+				processParameter(mParamDesc->paramBlocks[findIter->second], paramName, constantHandle, "", i);
 		}
 
 		return mParamDesc;
@@ -145,7 +147,7 @@ namespace BansheeEngine
 				memberDesc.name = name;
 
 				populateParamMemberDesc(memberDesc, desc);
-				mParamDesc.params.insert(std::make_pair(name, memberDesc));
+				mParamDesc->params.insert(std::make_pair(name, memberDesc));
 
 				blockDesc.blockSize += memberDesc.arrayElementStride * memberDesc.arraySize;
 			}
@@ -181,8 +183,8 @@ namespace BansheeEngine
 					BS_EXCEPT(InternalErrorException, "Invalid sampler type: " + toString(desc.Type) + " for parameter " + paramName);
 				}
 
-				mParamDesc.samplers.insert(std::make_pair(paramName, samplerDesc));
-				mParamDesc.textures.insert(std::make_pair(paramName, textureDesc));
+				mParamDesc->samplers.insert(std::make_pair(paramName, samplerDesc));
+				mParamDesc->textures.insert(std::make_pair(paramName, textureDesc));
 			}
 			else
 			{

BansheeEditor/Source/BsEditorApplication.cpp

@@ -225,7 +225,7 @@ namespace BansheeEngine
 		mTestShader->addParameter("matViewProjection", "matViewProjection", GPDT_MATRIX_4X4);
 
 		if (mActiveRSPlugin == RenderSystemPlugin::DX11)
-			mTestShader->addParameter("input", "input", GPDT_STRUCT, 2, 8);
+			mTestShader->addParameter("input", "input", GPDT_STRUCT, 0, 2, 8);
 
 		mTestShader->addParameter("samp", "samp", GPOT_SAMPLER2D);
 		mTestShader->addParameter("tex", "tex", GPOT_TEXTURE2D);

BansheeEditorExec/BsEditorExec.cpp

@@ -11,7 +11,7 @@ int CALLBACK WinMain(
 	_In_  int nCmdShow
 	)
 {
-	EditorApplication::startUp(RenderSystemPlugin::DX9);
+	EditorApplication::startUp(RenderSystemPlugin::DX11);
 	EditorApplication::instance().runMainLoop();
 	EditorApplication::shutDown();
 

BansheeEngine/Include/BsRenderQueue.h

@@ -50,6 +50,11 @@ namespace BansheeEngine
 		 */
 		virtual void sort();
 
+		/**
+		 * @brief	Returns internal list of render elements (unsorted).
+		 */
+		const Vector<RenderQueueElement>& getElements() const { return mRenderElements; }
+
 		/**
 		 * @brief	Returns a list of sorted render elements. Caller must ensure
 		 * 			"sort" is called before this method.

BansheeEngine/Source/BsRenderQueue.cpp

@@ -47,7 +47,7 @@ namespace BansheeEngine
 		// Just pass-through for now
 		for (auto& renderElem : mRenderElements)
 		{
-			UINT32 numPasses = (UINT32)renderElem.renderElem->material->passes.size();
+			UINT32 numPasses = (UINT32)renderElem.material->passes.size();
 			for (UINT32 i = 0; i < numPasses; i++)
 			{
 				mSortedRenderElements.push_back(RenderQueueElement());

BansheeGLRenderSystem/Source/GLSL/src/BsGLSLGpuProgram.cpp

@@ -122,7 +122,7 @@ namespace BansheeEngine
 		if (mIsCompiled)
 		{
 			GLSLParamParser paramParser;
-			paramParser.buildUniformDescriptions(mGLHandle, mParametersDesc);
+			paramParser.buildUniformDescriptions(mGLHandle, *mParametersDesc);
 
 			if (mType == GPT_VERTEX_PROGRAM)
 			{

BansheeRenderer/Source/BsBansheeLitTexRenderableHandler.cpp

@@ -20,12 +20,12 @@ namespace BansheeEngine
 		PassPtr defaultPass = defaultTechnique->getPass(0);
 
 		bool matrixTranspose = defaultPass->getVertexProgram()->requiresMatrixTranspose(); // Only need this from first vertex program as this is a static setting across all GPU programs
-		const GpuParamDesc& vertParamDesc = defaultPass->getVertexProgram()->getParamDesc();
-		const GpuParamDesc& fragParamDesc = defaultPass->getFragmentProgram()->getParamDesc();
+		GpuParamDescPtr vertParamDesc = defaultPass->getVertexProgram()->getParamDesc();
+		GpuParamDescPtr fragParamDesc = defaultPass->getFragmentProgram()->getParamDesc();
 
-		GpuParamDesc staticParamsDesc;
-		GpuParamDesc perFrameParamsDesc;
-		GpuParamDesc perObjectParamsDesc;
+		GpuParamDescPtr staticParamsDesc = bs_shared_ptr<GpuParamDesc>();
+		GpuParamDescPtr perFrameParamsDesc = bs_shared_ptr<GpuParamDesc>();
+		GpuParamDescPtr perObjectParamsDesc = bs_shared_ptr<GpuParamDesc>();
 
 		bool foundLightDir = false;
 		bool foundTime = false;
@@ -39,32 +39,32 @@ namespace BansheeEngine
 		{
 			if (!foundLightDir && param.second.rendererSemantic == RPS_LightDir)
 			{
-				auto iterFind = fragParamDesc.params.find(param.second.gpuVariableName);
-				if (iterFind == fragParamDesc.params.end())
+				auto iterFind = fragParamDesc->params.find(param.second.gpuVariableName);
+				if (iterFind == fragParamDesc->params.end())
 					continue;
 
 				lightDirParamDesc = iterFind->second;
-				staticParamsDesc.params[iterFind->first] = iterFind->second;
+				staticParamsDesc->params[iterFind->first] = iterFind->second;
 				foundLightDir = true;
 			}
 			else if (!foundTime && param.second.rendererSemantic == RPS_Time)
 			{
-				auto iterFind = vertParamDesc.params.find(param.second.gpuVariableName);
-				if (iterFind == vertParamDesc.params.end())
+				auto iterFind = vertParamDesc->params.find(param.second.gpuVariableName);
+				if (iterFind == vertParamDesc->params.end())
 					continue;
 
 				timeParamDesc = iterFind->second;
-				perFrameParamsDesc.params[iterFind->first] = iterFind->second;
+				perFrameParamsDesc->params[iterFind->first] = iterFind->second;
 				foundTime = true;
 			}
 			else if (!foundWVP && param.second.rendererSemantic == RPS_WorldViewProjTfrm)
 			{
-				auto iterFind = vertParamDesc.params.find(param.second.gpuVariableName);
-				if (iterFind == vertParamDesc.params.end())
+				auto iterFind = vertParamDesc->params.find(param.second.gpuVariableName);
+				if (iterFind == vertParamDesc->params.end())
 					continue;
 
 				wvpParamDesc = iterFind->second;
-				perObjectParamsDesc.params[iterFind->first] = iterFind->second;
+				perObjectParamsDesc->params[iterFind->first] = iterFind->second;
 				foundWVP = true;
 			}
 		}
@@ -74,32 +74,32 @@ namespace BansheeEngine
 		{
 			if (!foundStatic && block.second.rendererSemantic == RBS_Static)
 			{
-				auto iterFind = fragParamDesc.paramBlocks.find(block.second.name);
-				if (iterFind == fragParamDesc.paramBlocks.end())
+				auto iterFind = fragParamDesc->paramBlocks.find(block.second.name);
+				if (iterFind == fragParamDesc->paramBlocks.end())
 					continue;
 
 				staticParamBlockDesc = iterFind->second;
-				staticParamsDesc.paramBlocks[iterFind->first] = iterFind->second;
+				staticParamsDesc->paramBlocks[iterFind->first] = iterFind->second;
 				foundStatic = true;
 			}
 			else if (!foundPerFrame && block.second.rendererSemantic == RBS_PerFrame)
 			{
-				auto iterFind = vertParamDesc.paramBlocks.find(block.second.name);
-				if (iterFind == vertParamDesc.paramBlocks.end())
+				auto iterFind = vertParamDesc->paramBlocks.find(block.second.name);
+				if (iterFind == vertParamDesc->paramBlocks.end())
 					continue;
 
 				perFrameParamBlockDesc = iterFind->second;
-				perFrameParamsDesc.paramBlocks[iterFind->first] = iterFind->second;
+				perFrameParamsDesc->paramBlocks[iterFind->first] = iterFind->second;
 				foundPerFrame = true;
 			}
 			else if (!foundPerObject && block.second.rendererSemantic == RBS_PerObject)
 			{
-				auto iterFind = vertParamDesc.paramBlocks.find(block.second.name);
-				if (iterFind == vertParamDesc.paramBlocks.end())
+				auto iterFind = vertParamDesc->paramBlocks.find(block.second.name);
+				if (iterFind == vertParamDesc->paramBlocks.end())
 					continue;
 
 				perObjectParamBlockDesc = iterFind->second;
-				perObjectParamsDesc.paramBlocks[iterFind->first] = iterFind->second;
+				perObjectParamsDesc->paramBlocks[iterFind->first] = iterFind->second;
 				foundPerObject = true;
 			}
 		}

BansheeRenderer/Source/BsBansheeRenderer.cpp

@@ -57,7 +57,6 @@ namespace BansheeEngine
 		Renderer::_onActivated();
 
 		mLitTexHandler = bs_new<LitTexRenderableHandler>();
-		mLitTexHandler = nullptr;
 	}
 
 	void BansheeRenderer::_onDeactivated()
@@ -141,6 +140,7 @@ namespace BansheeEngine
 			RenderTargetData& renderTargetData = mRenderTargets.back();
 
 			proxy->renderQueue = bs_shared_ptr<RenderQueue>();
+			renderTargetData.target = renderTarget;
 			renderTargetData.cameras.push_back(proxy);
 		}
 
@@ -274,7 +274,7 @@ namespace BansheeEngine
 		const Vector<HCamera>& allCameras = gBsSceneManager().getAllCameras();
 		for (auto& camera : allCameras)
 		{
-			if (!camera->_isCoreDirty())
+			if (camera->_isCoreDirty())
 			{
 				CameraProxyPtr proxy = camera->_getActiveProxy();
 
@@ -289,7 +289,7 @@ namespace BansheeEngine
 				camera->_markCoreClean();
 				dirtySceneObjects.push_back(camera->SO());
 			}
-			else if (!camera->SO()->_isCoreDirty())
+			else if (camera->SO()->_isCoreDirty())
 			{
 				CameraProxyPtr proxy = camera->_getActiveProxy();
 				assert(proxy != nullptr);
@@ -333,10 +333,16 @@ namespace BansheeEngine
 			for (auto& drawOp : drawOps)
 			{
 				if (drawOp.material->_isCoreDirty(MaterialDirtyFlag::Proxy))
+				{
 					drawOp.material->_setActiveProxy(drawOp.material->_createProxy());
+					drawOp.material->_markCoreClean(MaterialDirtyFlag::Proxy);
+				}
 
 				if (drawOp.mesh->_isCoreDirty(MeshDirtyFlag::Proxy))
+				{
 					drawOp.mesh->_setActiveProxy(drawOp.submeshIdx, drawOp.mesh->_createProxy(drawOp.submeshIdx));
+					drawOp.mesh->_markCoreClean(MeshDirtyFlag::Proxy);
+				}
 
 				MaterialProxyPtr materialProxy = drawOp.material->_getActiveProxy();
 				MeshProxyPtr meshProxy = drawOp.mesh->_getActiveProxy(drawOp.submeshIdx);
@@ -354,7 +360,7 @@ namespace BansheeEngine
 	{
 		RenderQueuePtr cameraRenderQueue = proxy->renderQueue;
 
-		const Vector<RenderQueueElement>& queueElements = renderQueue->getSortedElements();
+		const Vector<RenderQueueElement>& queueElements = renderQueue->getElements();
 		for (auto& queueElement : queueElements)
 		{
 			cameraRenderQueue->add(queueElement.material, queueElement.mesh, queueElement.worldPosition);
@@ -451,14 +457,16 @@ namespace BansheeEngine
 
 		for(auto iter = sortedRenderElements.begin(); iter != sortedRenderElements.end(); ++iter)
 		{
-			MaterialProxyPtr materialProxy = iter->renderElem->material;
+			MaterialProxyPtr materialProxy = iter->material;
 
 			if (iter->renderable != nullptr && iter->renderable->handler != nullptr)
 				iter->renderable->handler->bindPerObjectBuffers(iter->renderable, iter->renderElem);
 
 			setPass(materialProxy, iter->passIdx);
-			draw(*iter->renderElem->mesh);
+			draw(*iter->mesh);
 		}
+
+		renderQueue->clear();
 	}
 
 	void BansheeRenderer::setPass(const MaterialProxyPtr& material, UINT32 passIdx)
@@ -479,7 +487,7 @@ namespace BansheeEngine
 		if (pass.fragmentProg)
 		{
 			rs.bindGpuProgram(pass.fragmentProg);
-			rs.bindGpuParams(GPT_FRAGMENT_PROGRAM, material->params[pass.geometryProgParamsIdx]);
+			rs.bindGpuParams(GPT_FRAGMENT_PROGRAM, material->params[pass.fragmentProgParamsIdx]);
 		}
 		else
 			rs.unbindGpuProgram(GPT_FRAGMENT_PROGRAM);