Added more shader params and preparing RenderBeast for deferred base pass

BansheeCore/Include/BsCoreRenderer.h

@@ -12,7 +12,6 @@ namespace BansheeEngine
 	 * Available parameter block semantics that allow the renderer to identify
 	 * the use of a GPU program parameter block specified in a shader.
 	 */
-
 	static StringID RBS_Static = "Static";
 	static StringID RBS_PerCamera = "PerCamera";
 	static StringID RBS_PerFrame = "PerFrame";
@@ -22,10 +21,11 @@ namespace BansheeEngine
 	 * Available parameter semantics that allow the renderer to identify
 	 * the use of a GPU parameter specified in a shader.
 	 */
-
 	static StringID RPS_WorldViewProjTfrm = "WVP";
 	static StringID RPS_ViewProjTfrm = "VP";
-	static StringID RPS_WorldTfrm = "World";
+	static StringID RPS_ProjTfrm = "P";
+	static StringID RPS_ViewTfrm = "V";
+	static StringID RPS_WorldTfrm = "W";
 	static StringID RPS_Diffuse = "Diffuse";
 	static StringID RPS_ViewDir = "ViewDir";
 

BansheeEditor/Source/BsProjectLibrary.cpp

@@ -615,8 +615,9 @@ namespace BansheeEngine
 
 		resource->setName(path.getWFilename(false));
 
-		Resources::instance().save(resource, assetPath.getAbsolute(getResourcesFolder()), false);
-		checkForModifications(assetPath);
+		Path absPath = assetPath.getAbsolute(getResourcesFolder());
+		Resources::instance().save(resource, absPath, false);
+		checkForModifications(absPath);
 	}
 
 	void ProjectLibrary::saveEntry(const HResource& resource)

BansheeEngine/Source/BsSplashScreen.cpp

@@ -15,7 +15,7 @@ namespace BansheeEngine
 
 	// Note: Never freed, but that's fine
 	SplashScreen::Pimpl* SplashScreen::m = bs_new<Pimpl>();
-	const UINT32 SplashScreen::SPLASH_SCREEN_DURATION_MS = 3000;
+	const UINT32 SplashScreen::SPLASH_SCREEN_DURATION_MS = 2000;
 
 	void SplashScreen::show()
 	{
@@ -44,9 +44,13 @@ namespace BansheeEngine
 
 	void SplashScreen::hide()
 	{
-		if (m->window == nullptr || m->timer.getMilliseconds() < SPLASH_SCREEN_DURATION_MS)
+		if (m->window == nullptr)
 			return;
 
+		UINT32 currentTime = m->timer.getMilliseconds();
+		if (currentTime < SPLASH_SCREEN_DURATION_MS)
+			BS_THREAD_SLEEP(SPLASH_SCREEN_DURATION_MS - currentTime);
+
 		bs_delete(m->window);
 		m->window = nullptr;
 	}

MBansheeEditor/UnitTests.cs

@@ -218,9 +218,7 @@ namespace BansheeEditor
         /// </summary>
         private static void UnitTest4_Prefabs()
         {
-            return;
-
-            if (EditorApplication.IsProjectLoaded)
+            if (!EditorApplication.IsProjectLoaded)
             {
                 Debug.LogWarning("Skipping unit test as no project is loaded.");
                 return;
@@ -407,6 +405,8 @@ namespace BansheeEditor
                     DebugUnit.Assert(comp0 == null);
                     DebugUnit.Assert(comp0_1_0.otherSO == so1_1);
                     DebugUnit.Assert(comp0_1_0.otherComponent2 == comp1);
+                    DebugUnit.Assert(comp0_1_0.a == 123);
+                    DebugUnit.Assert(comp0_1_0.b == "modifiedValue");
                     DebugUnit.Assert(comp1.otherSO == so1_0);
                     DebugUnit.Assert(comp1.otherComponent2 == comp0_1_0);
                     DebugUnit.Assert(MathEx.ApproxEquals(so1.Position.y, 999.0f));
@@ -468,7 +468,6 @@ namespace BansheeEditor
 
                     SceneObject root = Scene.Root;
                     SceneObject parent2SO0 = root.FindChild("parent2SO0", false);
-                    SceneObject parent2SO1 = root.FindChild("parent2SO1", false);
                     SceneObject parent2SO1_0 = root.FindChild("parent2SO1_0", false);
 
                     SceneObject prefabInstance = parent2SO0.GetChild(0);
@@ -504,12 +503,66 @@ namespace BansheeEditor
 
                 // Load original scene and ensure instance modifications didn't influence it
                 {
-                    // TODO
+                    EditorApplication.LoadScene("unitTest4Scene_1");
+
+                    SceneObject parentSO0 = Scene.Root.FindChild("parentSO0", false);
+                    SceneObject parentSO1_0 = parentSO0.FindChild("parentSO1_0", false);
+
+                    UT1_Component1 parentComp1_0 = parentSO1_0.GetComponent<UT1_Component1>();
+
+                    SceneObject prefabInstance = parentSO0.GetChild(0);
+                    SceneObject so0 = prefabInstance.FindChild("so0", false);
+                    SceneObject so1 = prefabInstance.FindChild("so1_modified", false);
+                    SceneObject so0_0 = so0.FindChild("so0_0", false);
+                    SceneObject so1_0 = so1.FindChild("so1_0", false);
+                    SceneObject so0_1_0 = so1_0.FindChild("so0_1_0", false);
+                    SceneObject so1_1 = so1_0.FindChild("so1_1", false);
+
+                    UT1_Component1 comp0 = so0.GetComponent<UT1_Component1>();
+                    UT1_Component1 comp1 = so1.GetComponent<UT1_Component1>();
+                    UT1_Component1 comp0_1_0 = so0_1_0.GetComponent<UT1_Component1>();
+
+                    DebugUnit.Assert(parentComp1_0.otherSO == so1_0);
+                    DebugUnit.Assert(parentComp1_0.otherComponent2 == comp0_1_0);
+                    DebugUnit.Assert(so1_1 != null);
+                    DebugUnit.Assert(so0_0 == null);
+                    DebugUnit.Assert(comp0 == null);
+                    DebugUnit.Assert(comp0_1_0.otherSO == so1_1);
+                    DebugUnit.Assert(comp0_1_0.otherComponent2 == comp1);
+                    DebugUnit.Assert(comp0_1_0.a == 123);
+                    DebugUnit.Assert(comp0_1_0.b == "modifiedValue");
+                    DebugUnit.Assert(comp1.otherSO == so1_0);
+                    DebugUnit.Assert(comp1.otherComponent2 == comp0_1_0);
+                    DebugUnit.Assert(MathEx.ApproxEquals(so1.Position.y, 999.0f));
                 }
 
                 // Modify prefab and ensure both prefab and instance modifications remain
                 {
-                    // TODO
+                    Scene.Load("unitTest4Scene_0");
+
+                    SceneObject sceneRoot = Scene.Root;
+                    SceneObject so0 = sceneRoot.FindChild("so0", false);
+                    SceneObject so1 = sceneRoot.FindChild("so1_modified", false);
+                    SceneObject so1_0 = so1.FindChild("so1_0", false);
+                    SceneObject so0_1_0 = so1_0.FindChild("so0_1_0", false);
+
+                    SceneObject so1_2 = new SceneObject("so1_2");
+                    so1_2.Parent = so1;
+
+                    UT1_Component2 comp3 = so1_2.AddComponent<UT1_Component2>();
+
+                    UT1_Component1 comp0_1_0 = so0_1_0.GetComponent<UT1_Component1>();
+                    comp0_1_0.b = "modifiedValueAgain";
+                    so1.Name = "so1_modifiedAgain";
+
+                    
+
+                    // TODO - Hook up references for comp3
+                    // TODO - Remove a component/so from the prefab
+
+                    EditorApplication.SaveScene("unitTest4Scene_0");
+
+                    // TODO - Actually test values
                 }
             }
 

RenderBeast/Include/BsRenderBeast.h

@@ -14,9 +14,7 @@ namespace BansheeEngine
 	 * Semantics that may be used for signaling the renderer
 	 * for what is a certain shader parameter used for.
 	 */
-
 	static StringID RPS_Time = "Time";
-	static StringID RPS_LightDir = "LightDir";
 
 	/**
 	 * @brief	Data used by the renderer when rendering renderable handlers.

RenderBeast/Include/BsStaticRenderableHandler.h

@@ -21,6 +21,7 @@ namespace BansheeEngine
 		struct PerObjectData
 		{
 			GpuParamMat4Core wvpParam;
+			GpuParamMat4Core wParam;
 
 			Vector<RenderableElement::BufferBindInfo> perObjectBuffers;
 		};
@@ -47,13 +48,13 @@ namespace BansheeEngine
 		 * @brief	Updates global per frame parameter buffers with new values. 
 		 *			To be called at the start of rendering for every camera.
 		 */
-		void updatePerCameraBuffers(const Vector3& viewDir);
+		void updatePerCameraBuffers(const Matrix4& vpMatrix, const Matrix4& vMatrix, const Matrix4& pMatrix, const Vector3& viewDir);
 
 		/**
 		 * @brief	Updates object specific parameter buffers with new values.
 		 *			To be called whenever object specific values change.
 		 */
-		void updatePerObjectBuffers(RenderableElement& element, const Matrix4& wvpMatrix);
+		void updatePerObjectBuffers(RenderableElement& element, const Matrix4& worldMatrix, const Matrix4& wvpMatrix);
 
 	protected:
 		/**
@@ -71,21 +72,24 @@ namespace BansheeEngine
 		GpuParamBlockDesc perObjectParamBlockDesc;
 
 		GpuParamDataDesc timeParamDesc;
-		GpuParamDataDesc lightDirParamDesc;
 		GpuParamDataDesc wvpParamDesc;
+		GpuParamDataDesc vpParamDesc;
+		GpuParamDataDesc wParamDesc;
+		GpuParamDataDesc vParamDesc;
+		GpuParamDataDesc pParamDesc;
 		GpuParamDataDesc viewDirParamDesc;
 
-		SPtr<GpuParamBlockBufferCore> staticParamBuffer;
 		SPtr<GpuParamBlockBufferCore> perFrameParamBuffer;
 		SPtr<GpuParamBlockBufferCore> perCameraParamBuffer;
 		SPtr<GpuParamBlockBufferCore> perObjectParamBuffer;
 
-		SPtr<GpuParamsCore> staticParams;
 		SPtr<GpuParamsCore> perFrameParams;
 		SPtr<GpuParamsCore> perCameraParams;
 
-		GpuParamVec4Core lightDirParam;
 		GpuParamVec3Core viewDirParam;
+		GpuParamMat4Core viewProjMatParam;
+		GpuParamMat4Core viewMatParam;
+		GpuParamMat4Core projMatParam;
 		GpuParamFloatCore timeParam;
 	};
 }

RenderBeast/Source/BsRenderBeast.cpp

@@ -427,12 +427,12 @@ namespace BansheeEngine
 		CameraData& camData = mCameraData[camera];
 		SPtr<ViewportCore> viewport = camera->getViewport();
 
-		Matrix4 projMatrixCstm = camera->getProjectionMatrixRS();
-		Matrix4 viewMatrixCstm = camera->getViewMatrix();
+		Matrix4 projMatrix = camera->getProjectionMatrixRS();
+		Matrix4 viewMatrix = camera->getViewMatrix();
 
-		Matrix4 viewProjMatrix = projMatrixCstm * viewMatrixCstm;
+		Matrix4 viewProjMatrix = projMatrix * viewMatrix;
 
-		mStaticHandler->updatePerCameraBuffers(camera->getForward());
+		mStaticHandler->updatePerCameraBuffers(viewProjMatrix, viewMatrix, projMatrix, camera->getForward());
 
 		// Render scene object to g-buffer if there are any
 		const Vector<RenderQueueElement>& opaqueElements = camData.opaqueQueue->getSortedElements();
@@ -470,7 +470,7 @@ namespace BansheeEngine
 				UINT32 rendererId = renderElem->renderableId;
 				Matrix4 worldViewProjMatrix = viewProjMatrix * mWorldTransforms[rendererId];
 
-				mStaticHandler->updatePerObjectBuffers(*renderElem, worldViewProjMatrix);
+				mStaticHandler->updatePerObjectBuffers(*renderElem, mWorldTransforms[rendererId], worldViewProjMatrix);
 				mStaticHandler->bindGlobalBuffers(*renderElem); // Note: If I can keep global buffer slot indexes the same between shaders I could only bind these once
 				mStaticHandler->bindPerObjectBuffers(*renderElem);
 
@@ -548,7 +548,7 @@ namespace BansheeEngine
 			UINT32 rendererId = renderElem->renderableId;
 			Matrix4 worldViewProjMatrix = viewProjMatrix * mWorldTransforms[rendererId];
 
-			mStaticHandler->updatePerObjectBuffers(*renderElem, worldViewProjMatrix);
+			mStaticHandler->updatePerObjectBuffers(*renderElem, mWorldTransforms[rendererId], worldViewProjMatrix);
 			mStaticHandler->bindGlobalBuffers(*renderElem); // Note: If I can keep global buffer slot indexes the same between shaders I could only bind these once
 			mStaticHandler->bindPerObjectBuffers(*renderElem);
 
@@ -591,10 +591,10 @@ namespace BansheeEngine
 		RenderAPICore& rs = RenderAPICore::instance();
 		CameraData& cameraData = mCameraData[&camera];
 
-		Matrix4 projMatrixCstm = camera.getProjectionMatrixRS();
-		Matrix4 viewMatrixCstm = camera.getViewMatrix();
+		Matrix4 projMatrix = camera.getProjectionMatrixRS();
+		Matrix4 viewMatrix = camera.getViewMatrix();
 
-		Matrix4 viewProjMatrix = projMatrixCstm * viewMatrixCstm;
+		Matrix4 viewProjMatrix = projMatrix * viewMatrix;
 
 		// Trigger pre-render callbacks
 		auto iterCameraCallbacks = mRenderCallbacks.find(&camera);
@@ -612,7 +612,7 @@ namespace BansheeEngine
 		// Render opaque
 
 		//// Update global per-frame hardware buffers
-		mStaticHandler->updatePerCameraBuffers(camera.getForward());
+		mStaticHandler->updatePerCameraBuffers(viewProjMatrix, viewMatrix, projMatrix, camera.getForward());
 
 		// TODO - This bit can be removed once I fully switch to deferred
 		const Vector<RenderQueueElement>& opaqueElements = cameraData.opaqueQueue->getSortedElements();
@@ -624,7 +624,7 @@ namespace BansheeEngine
 			UINT32 rendererId = renderElem->renderableId;
 			Matrix4 worldViewProjMatrix = viewProjMatrix * mWorldTransforms[rendererId];
 
-			mStaticHandler->updatePerObjectBuffers(*renderElem, worldViewProjMatrix);
+			mStaticHandler->updatePerObjectBuffers(*renderElem, mWorldTransforms[rendererId], worldViewProjMatrix);
 			mStaticHandler->bindGlobalBuffers(*renderElem); // Note: If I can keep global buffer slot indexes the same between shaders I could only bind these once
 			mStaticHandler->bindPerObjectBuffers(*renderElem);
 
@@ -656,7 +656,7 @@ namespace BansheeEngine
 			UINT32 rendererId = renderElem->renderableId;
 			Matrix4 worldViewProjMatrix = viewProjMatrix * mWorldTransforms[rendererId];
 
-			mStaticHandler->updatePerObjectBuffers(*renderElem, worldViewProjMatrix);
+			mStaticHandler->updatePerObjectBuffers(*renderElem, mWorldTransforms[rendererId], worldViewProjMatrix);
 			mStaticHandler->bindGlobalBuffers(*renderElem); // Note: If I can keep global buffer slot indexes the same between shaders I could only bind these once
 			mStaticHandler->bindPerObjectBuffers(*renderElem);
 
@@ -940,7 +940,8 @@ namespace BansheeEngine
 			String vsCode = R"(
 				cbuffer PerObject
 				{
-					float4x4 matWorldViewProj;
+					float4x4 gMatWorldViewProj;
+					float4x4 gMatWorld;
 				}
 
 				void vs_main(
@@ -949,21 +950,24 @@ namespace BansheeEngine
 					out float4 oPosition : SV_Position,
 					out float3 oNormal : NORMAL)
 				{
-					oPosition = mul(matWorldViewProj, float4(inPos.xyz, 1));
+					oPosition = mul(gMatWorldViewProj, float4(inPos.xyz, 1));
 					oNormal = inNormal;
 				})";
 
 			String psCode = R"(
 				cbuffer PerCamera
 				{
-					float4 viewDir;
+					float3 gViewDir;
+					float4x4 gMatViewProj;
+					float4x4 gMatView;
+					float4x4 gMatProj;
 				}
 
 				float4 ps_main(
 					in float4 inPos : SV_Position,
 					in float3 normal : NORMAL) : SV_Target
 				{
-					float4 outColor = float4(0.3f, 0.3f, 0.3f, 1.0f) * clamp(dot(normalize(normal), -viewDir.xyz), 0.5f, 1.0);
+					float4 outColor = float4(0.3f, 0.3f, 0.3f, 1.0f) * clamp(dot(normalize(normal), -gViewDir), 0.5f, 1.0);
 					outColor.a = 1.0f;
 				
 					return outColor;
@@ -975,8 +979,9 @@ namespace BansheeEngine
 		else if (rsName == RenderAPIDX9)
 		{
 			String vsCode = R"(
-				 BS_PARAM_BLOCK PerObject { matWorldViewProj }
-				 float4x4 matWorldViewProj;
+				 BS_PARAM_BLOCK PerObject { gMatWorldViewProj, gMatWorld }
+				 float4x4 gMatWorldViewProj;
+				 float4x4 gMatWorld;
 
 				 void vs_main(
 					in float3 inPos : POSITION,
@@ -984,19 +989,22 @@ namespace BansheeEngine
 					out float4 oPosition : POSITION,
 					out float3 oNormal : TEXCOORD0)
 				 {
-					 oPosition = mul(matWorldViewProj, float4(inPos.xyz, 1));
+					 oPosition = mul(gMatWorldViewProj, float4(inPos.xyz, 1));
 					 oNormal = inNormal;
 				 })";
 
 			String psCode = R"(
-				 BS_PARAM_BLOCK PerCamera { viewDir }
-				 float4 viewDir;
+				 BS_PARAM_BLOCK PerCamera { gViewDir, gMatViewProj, gMatView, gMatProj }
+				 float3 gViewDir;
+				 float4x4 gMatViewProj;
+				 float4x4 gMatView;
+				 float4x4 gMatProj;
 
 				float4 ps_main(
 					in float3 inPos : POSITION,
 					in float3 inNormal : TEXCOORD0) : COLOR0
 				{
-					float4 outColor = float4(0.3f, 0.3f, 0.3f, 1.0f) * clamp(dot(normalize(inNormal), -viewDir.xyz), 0.5f, 1.0);
+					float4 outColor = float4(0.3f, 0.3f, 0.3f, 1.0f) * clamp(dot(normalize(inNormal), -gViewDir), 0.5f, 1.0);
 					outColor.a = 1.0f;
 				
 					return outColor;
@@ -1010,7 +1018,8 @@ namespace BansheeEngine
 			String vsCode = R"(
 				uniform PerObject
 				{
-					mat4 matWorldViewProj;
+					mat4 gMatWorldViewProj;
+					mat4 gMatWorld;
 				};
 
 				in vec3 bs_position;
@@ -1024,14 +1033,17 @@ namespace BansheeEngine
 
 				void main()
 				{
-					gl_Position = matWorldViewProj * vec4(bs_position.xyz, 1);
+					gl_Position = gMatWorldViewProj * vec4(bs_position.xyz, 1);
 					normal = bs_normal;
 				})";
 
 			String psCode = R"(
 				uniform PerCamera
 				{
-					vec4 viewDir;
+					vec3 gViewDir;
+					mat4 gMatViewProj;
+					mat4 gMatView;
+					mat4 gMatProj;
 				};
 
 				in vec3 normal;
@@ -1039,7 +1051,7 @@ namespace BansheeEngine
 
 				void main()
 				{
-					vec4 outColor = vec4(0.3f, 0.3f, 0.3f, 1.0f) * clamp(dot(normalize(normal), -viewDir.xyz), 0.5f, 1.0);
+					vec4 outColor = vec4(0.3f, 0.3f, 0.3f, 1.0f) * clamp(dot(normalize(normal), -gViewDir), 0.5f, 1.0);
 					outColor.a = 1.0f;
 				
 					fragColor = outColor;
@@ -1059,8 +1071,8 @@ namespace BansheeEngine
 		SHADER_DESC_CORE shaderDesc;
 		shaderDesc.setParamBlockAttribs("PerObject", true, GPBU_DYNAMIC, RBS_PerObject);
 		shaderDesc.setParamBlockAttribs("PerCamera", true, GPBU_DYNAMIC, RBS_PerCamera);
-		shaderDesc.addParameter("matWorldViewProj", "matWorldViewProj", GPDT_MATRIX_4X4, RPS_WorldViewProjTfrm);
-		shaderDesc.addParameter("viewDir", "viewDir", GPDT_FLOAT4, RPS_ViewDir);
+		shaderDesc.addParameter("gMatWorldViewProj", "gMatWorldViewProj", GPDT_MATRIX_4X4, RPS_WorldViewProjTfrm);
+		shaderDesc.addParameter("gViewDir", "gViewDir", GPDT_FLOAT3, RPS_ViewDir);
 
 		SPtr<ShaderCore> defaultShader = ShaderCore::create("DummyShader", shaderDesc, { newTechnique });
 

RenderBeast/Source/BsStaticRenderableHandler.cpp

@@ -21,16 +21,17 @@ namespace BansheeEngine
 		GpuParamDescPtr vertParamDesc = defaultPass->getVertexProgram()->getParamDesc();
 		GpuParamDescPtr fragParamDesc = defaultPass->getFragmentProgram()->getParamDesc();
 
-		GpuParamDescPtr staticParamsDesc = bs_shared_ptr_new<GpuParamDesc>();
 		GpuParamDescPtr perFrameParamsDesc = bs_shared_ptr_new<GpuParamDesc>();
 		GpuParamDescPtr perObjectParamsDesc = bs_shared_ptr_new<GpuParamDesc>();
 		GpuParamDescPtr perCameraParamsDesc = bs_shared_ptr_new<GpuParamDesc>();
 
-		bool foundLightDir = false;
 		bool foundTime = false;
 		bool foundWVP = false;
+		bool foundVP = false;
+		bool foundW = false;
+		bool foundV = false;
+		bool foundP = false;
 		bool foundViewDir = false;
-		bool foundStatic = false;
 		bool foundPerFrame = false;
 		bool foundPerObject = false;
 		bool foundPerCamera = false;
@@ -38,17 +39,7 @@ namespace BansheeEngine
 		const Map<String, SHADER_DATA_PARAM_DESC>& dataParams = defaultShader->getDataParams();
 		for (auto& param : dataParams)
 		{
-			if (!foundLightDir && param.second.rendererSemantic == RPS_LightDir)
-			{
-				auto iterFind = fragParamDesc->params.find(param.second.gpuVariableName);
-				if (iterFind == fragParamDesc->params.end())
-					continue;
-
-				lightDirParamDesc = iterFind->second;
-				staticParamsDesc->params[iterFind->first] = iterFind->second;
-				foundLightDir = true;
-			}
-			else if (!foundTime && param.second.rendererSemantic == RPS_Time)
+			if (!foundTime && param.second.rendererSemantic == RPS_Time)
 			{
 				auto iterFind = vertParamDesc->params.find(param.second.gpuVariableName);
 				if (iterFind == vertParamDesc->params.end())
@@ -68,6 +59,46 @@ namespace BansheeEngine
 				perObjectParamsDesc->params[iterFind->first] = iterFind->second;
 				foundWVP = true;
 			}
+			else if (!foundW && param.second.rendererSemantic == RPS_WorldTfrm)
+			{
+				auto iterFind = vertParamDesc->params.find(param.second.gpuVariableName);
+				if (iterFind == vertParamDesc->params.end())
+					continue;
+
+				wParamDesc = iterFind->second;
+				perObjectParamsDesc->params[iterFind->first] = iterFind->second;
+				foundW = true;
+			}
+			else if (!foundVP && param.second.rendererSemantic == RPS_ViewProjTfrm)
+			{
+				auto iterFind = fragParamDesc->params.find(param.second.gpuVariableName);
+				if (iterFind == fragParamDesc->params.end())
+					continue;
+
+				vpParamDesc = iterFind->second;
+				perCameraParamsDesc->params[iterFind->first] = iterFind->second;
+				foundVP = true;
+			}
+			else if (!foundV && param.second.rendererSemantic == RPS_ViewTfrm)
+			{
+				auto iterFind = fragParamDesc->params.find(param.second.gpuVariableName);
+				if (iterFind == fragParamDesc->params.end())
+					continue;
+
+				vParamDesc = iterFind->second;
+				perCameraParamsDesc->params[iterFind->first] = iterFind->second;
+				foundV = true;
+			}
+			else if (!foundP && param.second.rendererSemantic == RPS_ProjTfrm)
+			{
+				auto iterFind = fragParamDesc->params.find(param.second.gpuVariableName);
+				if (iterFind == fragParamDesc->params.end())
+					continue;
+
+				pParamDesc = iterFind->second;
+				perCameraParamsDesc->params[iterFind->first] = iterFind->second;
+				foundP = true;
+			}
 			else if (!foundViewDir && param.second.rendererSemantic == RPS_ViewDir)
 			{
 				auto iterFind = fragParamDesc->params.find(param.second.gpuVariableName);
@@ -83,17 +114,7 @@ namespace BansheeEngine
 		const Map<String, SHADER_PARAM_BLOCK_DESC>& paramBlocks = defaultShader->getParamBlocks();
 		for (auto& block : paramBlocks)
 		{
-			if (!foundStatic && block.second.rendererSemantic == RBS_Static)
-			{
-				auto iterFind = fragParamDesc->paramBlocks.find(block.second.name);
-				if (iterFind == fragParamDesc->paramBlocks.end())
-					continue;
-
-				staticParamBlockDesc = iterFind->second;
-				staticParamsDesc->paramBlocks[iterFind->first] = iterFind->second;
-				foundStatic = true;
-			}
-			else if (!foundPerFrame && block.second.rendererSemantic == RBS_PerFrame)
+			if (!foundPerFrame && block.second.rendererSemantic == RBS_PerFrame)
 			{
 				auto iterFind = vertParamDesc->paramBlocks.find(block.second.name);
 				if (iterFind == vertParamDesc->paramBlocks.end())
@@ -125,29 +146,22 @@ namespace BansheeEngine
 			}
 		}
 
-		if (!foundLightDir || !foundTime || !foundWVP || !foundViewDir || !foundStatic || !foundPerFrame || !foundPerCamera || !foundPerObject)
+		if (!foundTime || !foundWVP || !foundVP || !foundW || !foundV || !foundP || !foundViewDir || !foundPerFrame || !foundPerCamera || !foundPerObject)
 			BS_EXCEPT(InternalErrorException, "Invalid default shader.");
 
 		// Create global GPU param buffers and get parameter handles
-		staticParams = GpuParamsCore::create(staticParamsDesc, false);
 		perFrameParams = GpuParamsCore::create(perFrameParamsDesc, false);
 		perCameraParams = GpuParamsCore::create(perCameraParamsDesc, false);
 
-		staticParamBuffer = HardwareBufferCoreManager::instance().createGpuParamBlockBuffer(staticParamBlockDesc.blockSize * sizeof(UINT32));
 		perFrameParamBuffer = HardwareBufferCoreManager::instance().createGpuParamBlockBuffer(perFrameParamBlockDesc.blockSize * sizeof(UINT32));
 		perCameraParamBuffer = HardwareBufferCoreManager::instance().createGpuParamBlockBuffer(perCameraParamBlockDesc.blockSize * sizeof(UINT32));
 		perObjectParamBuffer = HardwareBufferCoreManager::instance().createGpuParamBlockBuffer(perObjectParamBlockDesc.blockSize * sizeof(UINT32));
 
-		staticParams->setParamBlockBuffer(staticParamBlockDesc.slot, staticParamBuffer);
 		perFrameParams->setParamBlockBuffer(perFrameParamBlockDesc.slot, perFrameParamBuffer);
 		perCameraParams->setParamBlockBuffer(perCameraParamBlockDesc.slot, perCameraParamBuffer);
 
-		staticParams->getParam(lightDirParamDesc.name, lightDirParam);
 		perFrameParams->getParam(timeParamDesc.name, timeParam);
 		perCameraParams->getParam(viewDirParamDesc.name, viewDirParam);
-
-		lightDirParam.set(Vector4(0.707f, 0.707f, 0.707f, 0.0f));
-		staticParams->updateHardwareBuffers();
 	}
 
 	void StaticRenderableHandler::initializeRenderElem(RenderableElement& element)
@@ -170,18 +184,16 @@ namespace BansheeEngine
 
 		const Map<String, SHADER_PARAM_BLOCK_DESC>& paramBlockDescs = shader->getParamBlocks();
 		const Map<String, SHADER_DATA_PARAM_DESC>& dataParamDescs = shader->getDataParams();
-		String staticBlockName;
 		String perFrameBlockName;
 		String perCameraBlockName;
 		String perObjectBlockName;
 
 		String wvpParamName;
+		String wParamName;
 
 		for (auto& paramBlockDesc : paramBlockDescs)
 		{
-			if (paramBlockDesc.second.rendererSemantic == RBS_Static)
-				staticBlockName = paramBlockDesc.second.name;
-			else if (paramBlockDesc.second.rendererSemantic == RBS_PerFrame)
+			if (paramBlockDesc.second.rendererSemantic == RBS_PerFrame)
 				perFrameBlockName = paramBlockDesc.second.name;
 			else if (paramBlockDesc.second.rendererSemantic == RBS_PerCamera)
 				perCameraBlockName = paramBlockDesc.second.name;
@@ -193,6 +205,8 @@ namespace BansheeEngine
 		{
 			if (paramDesc.second.rendererSemantic == RPS_WorldViewProjTfrm)
 				wvpParamName = paramDesc.second.gpuVariableName;
+			else if (paramDesc.second.rendererSemantic == RPS_WorldTfrm)
+				wParamName = paramDesc.second.gpuVariableName;
 		}
 
 		UINT32 numPasses = element.material->getNumPasses();
@@ -208,26 +222,13 @@ namespace BansheeEngine
 
 				const GpuParamDesc& paramsDesc = gpuParams->getParamDesc();
 
-				if (staticBlockName != "")
-				{
-					auto findIter = paramsDesc.paramBlocks.find(staticBlockName);
-					if (findIter != paramsDesc.paramBlocks.end())
-					{
-						// TODO - We only compare block sizes but not actual contents. Should I check them too?
-						//        Probably shouldn't concern myself with that here, instead check that on a higher level.
-						if (findIter->second.blockSize == staticParamBlockDesc.blockSize)
-						{
-							UINT32 slotIdx = findIter->second.slot;
-							element.rendererBuffers.push_back(RenderableElement::BufferBindInfo(i, j, slotIdx, staticParamBuffer));
-						}
-					}
-				}
-
 				if (perFrameBlockName != "")
 				{
 					auto findIter = paramsDesc.paramBlocks.find(perFrameBlockName);
 					if (findIter != paramsDesc.paramBlocks.end())
 					{
+						// TODO - We only compare block sizes but not actual contents. Should I check them too?
+						//        Probably shouldn't concern myself with that here, instead check that on a higher level.
 						if (findIter->second.blockSize == perFrameParamBlockDesc.blockSize)
 						{
 							UINT32 slotIdx = findIter->second.slot;
@@ -267,6 +268,16 @@ namespace BansheeEngine
 										gpuParams->getParam(wvpParamName, rendererData->wvpParam);
 								}
 							}
+
+							if (rendererData->wParam == nullptr && wParamName != "")
+							{
+								auto findIter2 = paramsDesc.params.find(wParamName);
+								if (findIter2 != paramsDesc.params.end())
+								{
+									if (paramsMatch(findIter2->second, wParamDesc))
+										gpuParams->getParam(wParamName, rendererData->wParam);
+								}
+							}
 						}
 					}
 				}
@@ -292,17 +303,21 @@ namespace BansheeEngine
 		perFrameParams->updateHardwareBuffers();
 	}
 
-	void StaticRenderableHandler::updatePerCameraBuffers(const Vector3& viewDir)
+	void StaticRenderableHandler::updatePerCameraBuffers(const Matrix4& vpMatrix, const Matrix4& vMatrix, const Matrix4& pMatrix, const Vector3& viewDir)
 	{
+		viewProjMatParam.set(vpMatrix);
+		viewMatParam.set(vMatrix);
+		projMatParam.set(pMatrix);
 		viewDirParam.set(viewDir);
 
 		perCameraParams->updateHardwareBuffers();
 	}
 
-	void StaticRenderableHandler::updatePerObjectBuffers(RenderableElement& element, const Matrix4& wvpMatrix)
+	void StaticRenderableHandler::updatePerObjectBuffers(RenderableElement& element, const Matrix4& worldMatrix, const Matrix4& wvpMatrix)
 	{
 		PerObjectData* rendererData = any_cast_unsafe<PerObjectData>(&element.rendererData);
 
+		rendererData->wParam.set(worldMatrix);
 		rendererData->wvpParam.set(wvpMatrix);
 	}
 
@@ -318,34 +333,33 @@ namespace BansheeEngine
 			String vsCode = R"(
 			cbuffer PerFrame
 			{
-				float time;
+				float gTime;
 			}
 				
 			cbuffer PerObject
 			{
-				float4x4 matWorldViewProj;
+				float4x4 gMatWorldViewProj;
+				float4x4 gMatWorld;
 			}
 
 			void vs_main(in float3 inPos : POSITION,
 					     out float4 oPosition : SV_Position)
 			{
-				 oPosition = mul(matWorldViewProj, float4(inPos.xyz + float3(sin(time), 0, 0), 1));
+				 oPosition = mul(gMatWorldViewProj, float4(inPos.xyz + float3(sin(gTime), 0, 0), 1));
 			})";
 
 			String psCode = R"(
-			cbuffer Static
-			{
-				float4 lightDir;
-			}
-
 			cbuffer PerCamera
 			{
-				float3 viewDir;
+				float3 gViewDir;
+				float4x4 gMatViewProj;
+				float4x4 gMatView;
+				float4x4 gMatProj;
 			}
 			
 			float4 ps_main() : SV_Target
 			{
-				return dot(lightDir, float4(0.5f, 0.5f, 0.5f, 0.5f)) + dot(viewDir, float4(0.5f, 0.5f, 0.5f, 0.5f));
+				return dot(gViewDir, float4(0.5f, 0.5f, 0.5f, 0.5f));
 			})";	
 
 			vsProgram = GpuProgramCore::create(vsCode, "vs_main", "hlsl", GPT_VERTEX_PROGRAM, GPP_VS_4_0);
@@ -354,28 +368,32 @@ namespace BansheeEngine
 		else if (rsName == RenderAPIDX9)
 		{
 			String vsCode = R"(
-			BS_PARAM_BLOCK PerFrame { time }
-			BS_PARAM_BLOCK PerObject { matWorldViewProj }
+			BS_PARAM_BLOCK PerFrame { gTime }
+			BS_PARAM_BLOCK PerObject { gMatWorldViewProj, gMatWorld }
 
-			float time;
-			float4x4 matWorldViewProj;
+			float gTime;
+			float4x4 gMatWorldViewProj;
+			float4x4 gMatWorld;
 
 			void vs_main(in float3 inPos : POSITION,
 						out float4 oPosition : POSITION)
 			{
-				oPosition = mul(matWorldViewProj, float4(inPos.xyz + float3(sin(time), 0, 0), 1));
+				oPosition = mul(mul(gMatWorld, gMatWorldViewProj), float4(inPos.xyz + float3(sin(gTime), 0, 0), 1));
 			})";
 
 			String psCode = R"(
-			BS_PARAM_BLOCK Static { lightDir }
-			BS_PARAM_BLOCK PerCamera { viewDir }
+			BS_PARAM_BLOCK PerCamera { gViewDir, gMatViewProj, gMatView, gMatProj }
 
-			float4 lightDir;
-			float3 viewDir;
+			float3 gViewDir;
+			float4x4 gMatViewProj;
+			float4x4 gMatView;
+			float4x4 gMatProj;
 
 			float4 ps_main() : COLOR0
 			{
-				return dot(lightDir, float4(0.5f, 0.5f, 0.5f, 0.5f)) + dot(viewDir, float4(0.5f, 0.5f, 0.5f, 0.5f));
+				float4x4 dummy = gMatViewProj * gMatView * gMatProj;
+
+				return dot(mul(dummy, float4(gViewDir, 1.0f)), float4(0.5f, 0.5f, 0.5f, 0.5f));
 			})";
 
 			vsProgram = GpuProgramCore::create(vsCode, "vs_main", "hlsl9", GPT_VERTEX_PROGRAM, GPP_VS_2_0);
@@ -386,12 +404,13 @@ namespace BansheeEngine
 			String vsCode = R"(
 			uniform PerFrame
 			{
-				float time;
+				float gTime;
 			};
 
 			uniform PerObject
 			{
-				mat4 matWorldViewProj;
+				mat4 gMatWorldViewProj;
+				mat4 gMatWorld;
 			};
 
 			in vec3 bs_position;
@@ -403,25 +422,23 @@ namespace BansheeEngine
 
 			void main()
 			{
-				gl_Position = matWorldViewProj * vec4(bs_position.xyz + vec3(sin(time), 0, 0), 1);
+				gl_Position = gMatWorld * gMatWorldViewProj * vec4(bs_position.xyz + vec3(sin(gTime), 0, 0), 1);
 			})";
 
 			String psCode = R"(
-			uniform Static
-			{
-				vec4 lightDir;
-			};
-
 			uniform PerCamera
 			{
-				vec3 viewDir;
+				vec3 gViewDir;
+				mat4 gMatViewProj;
+				mat4 gMatView;
+				mat4 gMatProj;
 			};
 
 			out vec4 fragColor;
 
 			void main()
 			{
-				fragColor.x = dot(lightDir.xyz, vec3(0.5f, 0.5f, 0.5f)) + dot(viewDir, vec3(0.5f, 0.5f, 0.5f));
+				fragColor.x = dot(gMatViewProj * gMatView * gMatProj * vec4(gViewDir, 1.0f), vec4(0.5f, 0.5f, 0.5f, 1.0f));
 			})";
 
 			vsProgram = GpuProgramCore::create(vsCode, "main", "glsl", GPT_VERTEX_PROGRAM, GPP_VS_4_0);
@@ -436,15 +453,17 @@ namespace BansheeEngine
 		SPtr<TechniqueCore> newTechnique = TechniqueCore::create(rsName, RendererDefault, { newPass });
 
 		SHADER_DESC_CORE shaderDesc;
-		shaderDesc.setParamBlockAttribs("Static", true, GPBU_DYNAMIC, RBS_Static);
 		shaderDesc.setParamBlockAttribs("PerFrame", true, GPBU_DYNAMIC, RBS_PerFrame);
 		shaderDesc.setParamBlockAttribs("PerCamera", true, GPBU_DYNAMIC, RBS_PerCamera);
 		shaderDesc.setParamBlockAttribs("PerObject", true, GPBU_DYNAMIC, RBS_PerObject);
 
-		shaderDesc.addParameter("lightDir", "lightDir", GPDT_FLOAT4, RPS_LightDir);
-		shaderDesc.addParameter("time", "time", GPDT_FLOAT1, RPS_Time);
-		shaderDesc.addParameter("viewDir", "viewDir", GPDT_FLOAT4, RPS_ViewDir);
-		shaderDesc.addParameter("matWorldViewProj", "matWorldViewProj", GPDT_MATRIX_4X4, RPS_WorldViewProjTfrm);
+		shaderDesc.addParameter("gTime", "gTime", GPDT_FLOAT1, RPS_Time);
+		shaderDesc.addParameter("gViewDir", "gViewDir", GPDT_FLOAT4, RPS_ViewDir);
+		shaderDesc.addParameter("gMatWorldViewProj", "gMatWorldViewProj", GPDT_MATRIX_4X4, RPS_WorldViewProjTfrm);
+		shaderDesc.addParameter("gMatViewProj", "gMatViewProj", GPDT_MATRIX_4X4, RPS_ViewProjTfrm);
+		shaderDesc.addParameter("gMatWorld", "gMatWorld", GPDT_MATRIX_4X4, RPS_WorldTfrm);
+		shaderDesc.addParameter("gMatView", "gMatView", GPDT_MATRIX_4X4, RPS_ViewTfrm);
+		shaderDesc.addParameter("gMatProj", "gMatProj", GPDT_MATRIX_4X4, RPS_ProjTfrm);
 
 		SPtr<ShaderCore> defaultShader = ShaderCore::create("LitTexDefault", shaderDesc, { newTechnique });
 

TODO.txt

@@ -40,7 +40,6 @@ Stage 2 polish:
  - When managed exception happens log an error and continue execution
   - Doing a pass over all methods referencing Internal_ methods ensuring they do proper checking on C# side would be good
  - Game publishing (Build window, collect resources, output exe, default viewport) (described below)
- - Splash screen
  - Settings/Preferences window (+ menu entry)
  - Console window