Merge pull request #185 from EvgeniiG/master

Fix single pass loop on PS4

Assets/ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.cs

             cmd.SetGlobalMatrix("_InvProjMatrix",     hdCamera.invProjectionMatrix);
             cmd.SetGlobalVector("_InvProjParam",      hdCamera.invProjectionParam);
 
-            // TODO: cmd.SetGlobalInt() does not exist, so we are forced to use Shader.SetGlobalInt() instead.
-
+            // TODO: setting the Sky Settings to 'None' appears to do nothing (so no invalidation happens).
+                Shader.EnableKeyword("SKY_LIGHTING");
-                Shader.SetGlobalInt("_EnvLightSkyEnabled", 1);
-                Shader.SetGlobalInt("_EnvLightSkyEnabled", 0);
+                Shader.DisableKeyword("SKY_LIGHTING");
             }
 
             // Broadcast SSS parameters to all shaders.

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/Resources/Deferred.shader

             #pragma shader_feature _ SSS_PRE_SCATTER_TEXTURING SSS_POST_SCATTER_TEXTURING
          // #endif
 
+            #pragma multi_compile _ SKY_LIGHTING
+
             #pragma multi_compile _ LIGHTING_DEBUG
 
             //-------------------------------------------------------------------------------------

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePass.cs

             public const int k_MaxCascadeCount = 4; //Should be not less than m_Settings.directionalLightCascadeCount;
 
             // Static keyword is required here else we get a "DestroyBuffer can only be call in main thread"
+            static ComputeBuffer s_LightingSettings = null; // We use a structured buffer instead of a constant buffer due to the delay between setting values via constant and other buffer types on PS4
             static ComputeBuffer s_DirectionalLightDatas = null;
             static ComputeBuffer s_LightDatas = null;
             static ComputeBuffer s_EnvLightDatas = null;
             int m_areaLightCount = 0;
             int m_lightCount = 0;
 
+            // See LightingSettings in TilePass.hlsl.
+            public struct LightingSettings
+            {
+                public uint    directionalLightCount;
+                public uint    punctualLightCount;
+                public uint    areaLightCount;
+                public uint    envLightCount;
+                public uint    numTileFtplX;
+                public uint    numTileFtplY;
+                // public uint    numTileClusteredX;
+                // public uint    numTileClusteredY;
+                // public uint    isLogBaseBufferEnabled;
+                // public uint    log2NumClusters;
+                // public float   clusterScale;
+                // public float   clusterBase;
+                // public float   nearPlane;
+                // public float   farPlane;
+                public Vector4 dirShadowSplitSpheres0;
+                public Vector4 dirShadowSplitSpheres1;
+                public Vector4 dirShadowSplitSpheres2;
+                public Vector4 dirShadowSplitSpheres3;
+            };
+
+            LightingSettings[] m_LightingSettings = new LightingSettings[1];
+
             private ComputeShader buildScreenAABBShader { get { return m_PassResources.buildScreenAABBShader; } }
             private ComputeShader buildPerTileLightListShader { get { return m_PassResources.buildPerTileLightListShader; } }
             private ComputeShader buildPerBigTileLightListShader { get { return m_PassResources.buildPerBigTileLightListShader; } }
                 m_lightList = new LightList();
                 m_lightList.Allocate();
 
+                s_LightingSettings = new ComputeBuffer(1, System.Runtime.InteropServices.Marshal.SizeOf(typeof(LightingSettings)));
                 s_DirectionalLightDatas = new ComputeBuffer(k_MaxDirectionalLightsOnScreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(DirectionalLightData)));
                 s_LightDatas = new ComputeBuffer(k_MaxPunctualLightsOnScreen + k_MaxAreaLightsOnSCreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(LightData)));
                 s_EnvLightDatas = new ComputeBuffer(k_MaxEnvLightsOnScreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(EnvLightData)));
                 UnityEditor.SceneView.onSceneGUIDelegate -= OnSceneGUI;
 #endif
 
+                Utilities.SafeRelease(s_LightingSettings);
                 Utilities.SafeRelease(s_DirectionalLightDatas);
                 Utilities.SafeRelease(s_LightDatas);
                 Utilities.SafeRelease(s_EnvLightDatas);
                 SetGlobalTexture("_CookieCubeTextures", m_CubeCookieTexArray.GetTexCache());
                 SetGlobalTexture("_EnvTextures", m_CubeReflTexArray.GetTexCache());
 
+                SetGlobalBuffer("_LightingSettings", s_LightingSettings);
-                SetGlobalInt("_DirectionalLightCount", m_lightList.directionalLights.Count);
-                SetGlobalInt("_PunctualLightCount", m_punctualLightCount);
-                SetGlobalInt("_AreaLightCount", m_areaLightCount);
-                SetGlobalInt("_EnvLightCount", m_lightList.envLights.Count);
-                SetGlobalVectorArray("_DirShadowSplitSpheres", m_lightList.directionalShadowSplitSphereSqr);
-
-                SetGlobalInt("_NumTileFtplX", GetNumTileFtplX(camera));
-                SetGlobalInt("_NumTileFtplY", GetNumTileFtplY(camera));
 
                 SetGlobalInt("_NumTileClusteredX", GetNumTileClusteredX(camera));
                 SetGlobalInt("_NumTileClusteredY", GetNumTileClusteredY(camera));
             {
                 var cmd = new CommandBuffer { name = "Push Global Parameters" };
 
+                m_LightingSettings[0].directionalLightCount  = (uint)m_lightList.directionalLights.Count;
+                m_LightingSettings[0].punctualLightCount     = (uint)m_punctualLightCount;
+                m_LightingSettings[0].areaLightCount         = (uint)m_areaLightCount;
+                m_LightingSettings[0].envLightCount          = (uint)m_lightList.envLights.Count;
+                m_LightingSettings[0].numTileFtplX           = (uint)GetNumTileFtplX(camera);
+                m_LightingSettings[0].numTileFtplY           = (uint)GetNumTileFtplY(camera);
+                // m_LightingSettings[0].numTileClusteredX      = (uint)GetNumTileClusteredX(camera);
+                // m_LightingSettings[0].numTileClusteredY      = (uint)GetNumTileClusteredY(camera);
+                // m_LightingSettings[0].isLogBaseBufferEnabled = (uint)(k_UseDepthBuffer ? 1 : 0);
+                // m_LightingSettings[0].log2NumClusters        = k_Log2NumClusters;
+                // m_LightingSettings[0].clusterBase            = k_ClustLogBase;
+                // m_LightingSettings[0].clusterScale           = m_ClustScale;
+                // m_LightingSettings[0].nearPlane              = camera.nearClipPlane;
+                // m_LightingSettings[0].farPlane               = camera.farClipPlane;
+                m_LightingSettings[0].dirShadowSplitSpheres0 = m_lightList.directionalShadowSplitSphereSqr[0];
+                m_LightingSettings[0].dirShadowSplitSpheres1 = m_lightList.directionalShadowSplitSphereSqr[1];
+                m_LightingSettings[0].dirShadowSplitSpheres2 = m_lightList.directionalShadowSplitSphereSqr[2];
+                m_LightingSettings[0].dirShadowSplitSpheres3 = m_lightList.directionalShadowSplitSphereSqr[3];
+                s_LightingSettings.SetData(m_LightingSettings);
                 s_DirectionalLightDatas.SetData(m_lightList.directionalLights.ToArray());
                 s_LightDatas.SetData(m_lightList.lights.ToArray());
                 s_EnvLightDatas.SetData(m_lightList.envLights.ToArray());
 
                             Utilities.SetMatrixCS(cmd, shadeOpaqueShader, "_InvViewProjMatrix", invViewProjection);
                             Utilities.SetMatrixCS(cmd, shadeOpaqueShader, "_ViewProjMatrix", viewProjection);
-                            Utilities.SetMatrixCS(cmd, shadeOpaqueShader, "g_mInvScrProjection", Shader.GetGlobalMatrix("g_mInvScrProjection"));
                             cmd.SetComputeVectorParam(shadeOpaqueShader, "_ScreenSize", Shader.GetGlobalVector("_ScreenSize"));
                             cmd.SetComputeIntParam(shadeOpaqueShader, "_UseTileLightList", Shader.GetGlobalInt("_UseTileLightList"));
 
                             cmd.SetComputeVectorParam(shadeOpaqueShader, "_ScreenParams", Shader.GetGlobalVector("_ScreenParams"));
                             cmd.SetComputeVectorParam(shadeOpaqueShader, "_ZBufferParams", Shader.GetGlobalVector("_ZBufferParams"));
                             cmd.SetComputeVectorParam(shadeOpaqueShader, "unity_OrthoParams", Shader.GetGlobalVector("unity_OrthoParams"));
-                            cmd.SetComputeIntParam(shadeOpaqueShader, "_EnvLightSkyEnabled", Shader.GetGlobalInt("_EnvLightSkyEnabled"));
 
                             Texture skyTexture = Shader.GetGlobalTexture("_SkyTexture");
                             Texture IESArrayTexture = Shader.GetGlobalTexture("_IESArray");

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePass.hlsl

 
 #include "TilePass.cs.hlsl"
 
-// For FPTL
-uint _NumTileFtplX;
-uint _NumTileFtplY;
-
 StructuredBuffer<uint> g_vLightListGlobal;		// don't support Buffer yet in unity
 
 #ifdef USE_FPTL_LIGHTLIST
 // these uniforms are only needed for when OPAQUES_ONLY is NOT defined
 // but there's a problem with our front-end compilation of compute shaders with multiple kernels causing it to error
 //#ifdef USE_CLUSTERED_LIGHTLIST
-float4x4 g_mInvScrProjection;
-
 float g_fClustScale;
 float g_fClustBase;
 float g_fNearPlane;
 StructuredBuffer<float> g_logBaseBuffer;			// don't support Buffer yet in unity
 //#endif
 
-StructuredBuffer<DirectionalLightData>  _DirectionalLightDatas;
-StructuredBuffer<LightData>             _LightDatas;
-StructuredBuffer<EnvLightData>          _EnvLightDatas;
-StructuredBuffer<ShadowData>            _ShadowDatas;
+struct LightingSettings
+{
+    uint   directionalLightCount;
+    uint   punctualLightCount;
+    uint   areaLightCount;
+    uint   envLightCount;
+    uint   numTileFtplX;
+    uint   numTileFtplY;
+    // uint   numTileClusteredX;
+    // uint   numTileClusteredY;
+    // uint   isLogBaseBufferEnabled;
+    // uint   log2NumClusters;
+    // float  clusterScale;
+    // float  clusterBase;
+    // float  nearPlane;
+    // float  farPlane;
+    float4 dirShadowSplitSpheres[4]; // TODO: share this max between C# and hlsl
+};
+
+// We use a structured buffer instead of a constant buffer due to the delay between setting values via constant and other buffer types on PS4
+StructuredBuffer<LightingSettings>     _LightingSettings; // 1 element
+StructuredBuffer<DirectionalLightData> _DirectionalLightDatas;
+StructuredBuffer<LightData>            _LightDatas;
+StructuredBuffer<EnvLightData>         _EnvLightDatas;
+StructuredBuffer<ShadowData>           _ShadowDatas;
 
 // Use texture atlas for shadow map
 //TEXTURE2D(_ShadowAtlas);
 TEXTURECUBE(_SkyTexture);
 SAMPLERCUBE(sampler_SkyTexture); // NOTE: Sampler could be share here with _EnvTextures. Don't know if the shader compiler will complain...
 
+/*
-uint _DirectionalLightCount;
-uint _PunctualLightCount;
-uint _AreaLightCount;
-uint _EnvLightCount;
-float4 _DirShadowSplitSpheres[4]; // TODO: share this max between C# and hlsl
-
-int  _EnvLightSkyEnabled;         // TODO: make it a bool	
+    // See _LightingSettings
+*/
 
 struct LightLoopContext
 {
 
 float GetDirectionalShadowAttenuation(LightLoopContext lightLoopContext, float3 positionWS, int index, float3 L, float2 unPositionSS)
 {
-    // Note Index is 0 for now, but else we need to provide the correct index in _DirShadowSplitSpheres and _ShadowDatas
-    int shadowSplitIndex = GetSplitSphereIndexForDirshadows(positionWS, _DirShadowSplitSpheres);
+    // Note Index is 0 for now, but else we need to provide the correct index in _LightingSettings[0].dirShadowSplitSpheres and _ShadowDatas
+    int shadowSplitIndex = GetSplitSphereIndexForDirshadows(positionWS, _LightingSettings[0].dirShadowSplitSpheres);
     if (shadowSplitIndex == -1)
         return 1.0;
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePassLoop.hlsl

         float shadow = GetDirectionalShadowAttenuation(lightLoopContext, positionWS, 0, float3(0.0, 0.0, 0.0), float2(0.0, 0.0));
 #endif
 
-        int shadowSplitIndex = GetSplitSphereIndexForDirshadows(positionWS, _DirShadowSplitSpheres);
+        int shadowSplitIndex = GetSplitSphereIndexForDirshadows(positionWS, _LightingSettings[0].dirShadowSplitSpheres);
         if (shadowSplitIndex == -1)
             diffuseLighting = float3(0.0, 0.0, 0.0);
         else
 int GetTileOffset(PositionInputs posInput, uint lightCategory)
 {
     uint2 tileIndex = posInput.unPositionSS / TILE_SIZE_FPTL;
-    return (tileIndex.y + lightCategory * _NumTileFtplY) * _NumTileFtplX + tileIndex.x;
+    return (tileIndex.y + lightCategory * _LightingSettings[0].numTileFtplY) * _LightingSettings[0].numTileFtplX + tileIndex.x;
 }
 
 void GetCountAndStartTile(PositionInputs posInput, uint lightCategory, out uint start, out uint lightCount)
     uint i = 0; // Declare once to avoid the D3D11 compiler warning.
 
 #ifdef PROCESS_DIRECTIONAL_LIGHT
-    for (i = 0; i < _DirectionalLightCount; ++i)
+    for (i = 0; i < _LightingSettings[0].directionalLightCount; ++i)
     {
         float3 localDiffuseLighting, localSpecularLighting;
 
     float3 iblSpecularLighting = float3(0.0, 0.0, 0.0);
 
     // Only apply sky IBL if the sky texture is available.
-    if (_EnvLightSkyEnabled)
+#ifdef SKY_LIGHTING
     {
         float3 localDiffuseLighting, localSpecularLighting;
         float2 weight;
         iblDiffuseLighting = lerp(iblDiffuseLighting, localDiffuseLighting, weight.x); // Should be remove by the compiler if it is smart as all is constant 0
         iblSpecularLighting = lerp(iblSpecularLighting, localSpecularLighting, weight.y);
     }
+#endif
 
     uint envLightStart;
     uint envLightCount;
 
     uint i = 0; // Declare once to avoid the D3D11 compiler warning.
 
-    for (i = 0; i < _DirectionalLightCount; ++i)
+    for (i = 0; i < _LightingSettings[0].directionalLightCount; ++i)
     {
         float3 localDiffuseLighting, localSpecularLighting;
 
         specularLighting += localSpecularLighting;
     }
 
-    for (i = 0; i < _PunctualLightCount; ++i)
+
+    for (i = 0; i < _LightingSettings[0].punctualLightCount; ++i)
     {
         float3 localDiffuseLighting, localSpecularLighting;
 
     }
 
     // Area are store with punctual, just offset the index
-    for (i = _PunctualLightCount; i < _AreaLightCount + _PunctualLightCount; ++i)
+    for (i = _LightingSettings[0].punctualLightCount; i < _LightingSettings[0].punctualLightCount + _LightingSettings[0].areaLightCount; ++i)
     {
         float3 localDiffuseLighting, localSpecularLighting;
 
     float3 iblSpecularLighting = float3(0.0, 0.0, 0.0);
 
     // Only apply sky IBL if the sky texture is available.
-    if (_EnvLightSkyEnabled)
+#ifdef SKY_LIGHTING
     {
         float3 localDiffuseLighting, localSpecularLighting;
         float2 weight;
         iblDiffuseLighting = lerp(iblDiffuseLighting, localDiffuseLighting, weight.x); // Should be remove by the compiler if it is smart as all is constant 0
         iblSpecularLighting = lerp(iblSpecularLighting, localSpecularLighting, weight.y);
     }
+#endif
-    for (i = 0; i < _EnvLightCount; ++i)
+    for (i = 0; i < _LightingSettings[0].envLightCount; ++i)
     {
         float3 localDiffuseLighting, localSpecularLighting;
         float2 weight;

Assets/ScriptableRenderPipeline/HDRenderPipeline/ShaderVariables.hlsl

 
 float3 GetCurrentCameraPosition()
 {
-#if SHADERPASS != SHADERPASS_DEPTH_ONLY
+#if defined(SHADERPASS) && (SHADERPASS != SHADERPASS_DEPTH_ONLY)
     return _WorldSpaceCameraPos;
 #else
     // TEMP: this is rather expensive. Then again, we need '_WorldSpaceCameraPos'
     return -viewMat[2].xyz;
 }
 
-// Computes the world space view direction (pointing towards the camera).
-float3 GetWorldSpaceNormalizeViewDir(float3 positionWS)
+// Returns 'true' if the current camera performs a perspective projection.
+bool IsPerspectiveCamera()
-#if SHADERPASS != SHADERPASS_DEPTH_ONLY
-    if (unity_OrthoParams.w == 0)
+#if defined(SHADERPASS) && (SHADERPASS != SHADERPASS_DEPTH_ONLY)
+    return (unity_OrthoParams.w == 0);
-    if (GetWorldToHClipMatrix()[3].x != 0 &&
-        GetWorldToHClipMatrix()[3].y != 0 &&
-        GetWorldToHClipMatrix()[3].z != 0 &&
-        GetWorldToHClipMatrix()[3].w != 1)
+    return (GetWorldToHClipMatrix()[3].x != 0 ||
+            GetWorldToHClipMatrix()[3].y != 0 ||
+            GetWorldToHClipMatrix()[3].z != 0 ||
+            GetWorldToHClipMatrix()[3].w != 1);
+}
+
+// Computes the world space view direction (pointing towards the camera).
+float3 GetWorldSpaceNormalizeViewDir(float3 positionWS)
+{
+    if (IsPerspectiveCamera())
     {
         // Perspective
         float3 V = GetCurrentCameraPosition() - positionWS;