HDRenderLoop: Merge FTPL - application of opaque tiled lists (untested)

Author: sebastienlagarde

Assets/ScriptableRenderLoop/HDRenderLoop/HDRenderLoop.cs

@@ -468,7 +468,7 @@ void RenderDeferredLighting(Camera camera, RenderLoop renderLoop)
             m_LitRenderLoop.Bind();
 
             m_SinglePassLightLoop.RenderDeferredLighting(camera, renderLoop, m_CameraColorBuffer);
-           // m_TilePassLightLoop.RenderDeferredLighting(camera, renderLoop, );
+          //  m_TilePassLightLoop.RenderDeferredLighting(camera, renderLoop, m_CameraColorBuffer);
         }
 
         void RenderSky(Camera camera, RenderLoop renderLoop)
@@ -810,7 +810,7 @@ void PrepareLightsForGPU(CullResults cullResults, Camera camera, ref ShadowOutpu
 
             // build per tile light lists           
             m_SinglePassLightLoop.PrepareLightsForGPU(cullResults, camera, m_lightList);
-            m_TilePassLightLoop.PrepareLightsForGPU(cullResults, camera, m_lightList);
+            //m_TilePassLightLoop.PrepareLightsForGPU(cullResults, camera, m_lightList);
         }
 
         void Resize(Camera camera)
@@ -891,7 +891,7 @@ public override void Render(Camera[] cameras, RenderLoop renderLoop)
                     renderLoop.SetupCameraProperties(camera); // Need to recall SetupCameraProperties after m_ShadowPass.Render
 
                     PrepareLightsForGPU(cullResults, camera, ref shadows, ref m_lightList);
-                    m_TilePassLightLoop.BuildGPULightLists(camera, renderLoop, m_lightList, m_CameraDepthBuffer);
+                    //m_TilePassLightLoop.BuildGPULightLists(camera, renderLoop, m_lightList, m_CameraDepthBuffer);
 
                     PushGlobalParams(camera, renderLoop, m_lightList);
 

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/Lighting.hlsl

@@ -18,8 +18,10 @@
 
 #include "Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/LightDefinition.cs.hlsl"
 
-#ifdef LIGHTLOOP_SINGLE_PASS 
+#ifdef LIGHTLOOP_SINGLE_PASS
 #include "Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/SinglePass/SinglePass.hlsl"
+#elif  LIGHTLOOP_TILED_PASS
+#include "Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/TilePass/TilePass.hlsl"
 #endif
 
 // Shadow use samling function define in header above and must be include before Material.hlsl
@@ -29,6 +31,8 @@
 // LightLoop use evaluation BSDF function for light type define in Material.hlsl
 #ifdef LIGHTLOOP_SINGLE_PASS 
 #include "Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/SinglePass/SinglePassLoop.hlsl"
+#elif  LIGHTLOOP_TILED_PASS
+#include "Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/TilePass/TilePassLoop.hlsl"
 #endif
 
 

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/Resources/Deferred.shader

@@ -16,12 +16,13 @@ Shader "Hidden/HDRenderLoop/Deferred"
             #pragma fragment FragDeferred
 
             // Chose supported lighting architecture in case of deferred rendering
-            #pragma multi_compile LIGHTLOOP_SINGLE_PASS
+            #pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
             //#pragma multi_compile SHADOWFILTERING_FIXED_SIZE_PCF 
 
-        // TODO: This must be on lightloop side and include here....
-#pragma multi_compile USE_FPTL_LIGHTLIST    USE_CLUSTERED_LIGHTLIST
-#pragma multi_compile __ ENABLE_DEBUG
+            // TODO: Workflow problem here, I would like to only generate variant for the LIGHTLOOP_TILE_PASS case, not the LIGHTLOOP_SINGLE_PASS case. This must be on lightloop side and include here.... (Can we codition
+            #pragma multi_compile LIGHTLOOP_TILE_DIRECT LIGHTLOOP_TILE_INDIRECT LIGHTLOOP_TILE_ALL
+            #pragma multi_compile USE_FPTL_LIGHTLIST USE_CLUSTERED_LIGHTLIST
+            #pragma multi_compile _ ENABLE_DEBUG
 
             //-------------------------------------------------------------------------------------
             // Include
@@ -75,7 +76,7 @@ Shader "Hidden/HDRenderLoop/Deferred"
                 Coordinate coord = GetCoordinate(unPositionSS.xy, _ScreenSize.zw);
 
                 // No need to manage inverse depth, this is handled by the projection matrix
-                float depth = LOAD_TEXTURE2D(_CameraDepthTexture, uint3(coord.unPositionSS, 0)).x;
+                float depth = LOAD_TEXTURE2D(_CameraDepthTexture, coord.unPositionSS).x;
                 float3 positionWS = UnprojectToWorld(depth, coord.positionSS, _InvViewProjMatrix);
                 float3 V = GetWorldSpaceNormalizeViewDir(positionWS);
 
@@ -88,7 +89,7 @@ Shader "Hidden/HDRenderLoop/Deferred"
 
                 float3 diffuseLighting;
                 float3 specularLighting;
-                LightLoop(V, positionWS, preLightData, bsdfData, bakeDiffuseLighting, diffuseLighting, specularLighting);
+                LightLoop(V, positionWS, coord, preLightData, bsdfData, bakeDiffuseLighting, diffuseLighting, specularLighting);
 
                 return float4(diffuseLighting + specularLighting, 1.0);
             }

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/SinglePass/SinglePass.cs

@@ -61,6 +61,7 @@ public void Rebuild()
                 s_PunctualShadowList = new ComputeBuffer(HDRenderLoop.k_MaxShadowOnScreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(PunctualShadowData)));
 
                 m_DeferredMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderLoop/Deferred");
+                m_DeferredMaterial.EnableKeyword("LIGHTLOOP_SINGLE_PASS");
             }
 
             public void OnDisable()

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/SinglePass/SinglePassLoop.hlsl

@@ -3,7 +3,7 @@
 // ----------------------------------------------------------------------------
 
 // bakeDiffuseLighting is part of the prototype so a user is able to implement a "base pass" with GI and multipass direct light (aka old unity rendering path)
-void LightLoop(	float3 V, float3 positionWS, PreLightData prelightData, BSDFData bsdfData, float3 bakeDiffuseLighting,
+void LightLoop(	float3 V, float3 positionWS, Coordinate coord, PreLightData prelightData, BSDFData bsdfData, float3 bakeDiffuseLighting,
                 out float3 diffuseLighting,
                 out float3 specularLighting)
 {

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/TilePass/Resources/scrbound.compute

@@ -14,8 +14,6 @@ uniform float4x4 g_mProjection;
 StructuredBuffer<SFiniteLightBound> g_data : register( t0 );
 
 
-
-#define FLT_EPSILON     1.192092896e-07F        // smallest such that 1.0+FLT_EPSILON != 1.0
 #define NR_THREADS			64
 
 // output buffer

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/TilePass/ShaderBase.hlsl

@@ -19,12 +19,12 @@
 
 float FetchDepth(Texture2D depthTexture, uint2 pixCoord)
 {
-    return 1 - LOAD_TEXTURE2D(depthTexture, uint3(pixCoord.xy, 0)).x;
+    return 1.0 - LOAD_TEXTURE2D(depthTexture, pixCoord.xy).x;
 }
 
 float FetchDepthMSAA(Texture2DMS<float> depthTexture, uint2 pixCoord, uint sampleIdx)
 {
-    return 1 - LOAD_TEXTURE2D_MSAA(depthTexture, uint3(pixCoord.xy, 0), sampleIdx).x;
+    return 1.0 - LOAD_TEXTURE2D_MSAA(depthTexture, pixCoord.xy, sampleIdx).x;
 }
 
 #endif

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/TilePass/TilePass.cs

@@ -78,7 +78,7 @@ public class LightLoop
         {
             string GetKeyword()
             {
-                return "LIGHTLOOP_SINGLE_PASS";
+                return "LIGHTLOOP_TILE_PASS";
             }
 
             public const int MaxNumLights = 1024;
@@ -121,8 +121,6 @@ string GetKeyword()
             private static ComputeBuffer s_GlobalLightListAtomic;
             // clustered light list specific buffers and data end
 
-            const int k_TileSize = 16;
-
             SFiniteLightBound[] m_boundData;
             SFiniteLightData[] m_lightData;
             int m_lightCount;
@@ -149,6 +147,18 @@ bool usingFptl
             Material m_DeferredMaterial;
             Material m_DeferredReflectionMaterial;
 
+            const int k_TileSize = 16;
+
+            int GetNumTileX(Camera camera)
+            {
+                return (camera.pixelWidth + (k_TileSize - 1)) / k_TileSize;
+            }
+
+            int GetNumTileY(Camera camera)
+            {
+                return (camera.pixelWidth + (k_TileSize - 1)) / k_TileSize;
+            }
+
             // Local function
             void ClearComputeBuffers()
             {
@@ -239,8 +249,13 @@ public void Rebuild()
                 s_EnvLightList = new ComputeBuffer(HDRenderLoop.k_MaxEnvLightsOnSCreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(EnvLightData)));
                 s_PunctualShadowList = new ComputeBuffer(HDRenderLoop.k_MaxShadowOnScreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(PunctualShadowData)));
 
-      //          m_DeferredMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderLoop/TileDeferred");
-       //         m_DeferredReflectionMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderLoop/TileDeferredReflection");
+                m_DeferredMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderLoop/Deferred");
+                m_DeferredMaterial.EnableKeyword("LIGHTLOOP_TILE_PASS");
+                m_DeferredMaterial.EnableKeyword("LIGHTLOOP_TILE_DIRECT");
+                
+                m_DeferredReflectionMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderLoop/Deferred");
+                m_DeferredReflectionMaterial.EnableKeyword("LIGHTLOOP_TILE_PASS");
+                m_DeferredReflectionMaterial.EnableKeyword("LIGHTLOOP_TILE_INDIRECT");
             }
 
             public void OnDisable()
@@ -269,10 +284,9 @@ public void OnDisable()
                 s_EnvLightList = null;
                 s_PunctualShadowList.Release();
                 s_PunctualShadowList = null;
-/*
+
                 Utilities.Destroy(m_DeferredMaterial);
                 Utilities.Destroy(m_DeferredReflectionMaterial);
-*/
             }
 
             public bool NeedResize()
@@ -339,43 +353,6 @@ public void AllocResolutionDependentBuffers(int width, int height)
                 }
             }
 
-            // TEMP: These functions should be implemented C++ side, for now do it in C#
-            private static void SetMatrixCS(CommandBuffer cmd, ComputeShader shadercs, string name, Matrix4x4 mat)
-            {
-                var data = new float[16];
-
-                for (int c = 0; c < 4; c++)
-                    for (int r = 0; r < 4; r++)
-                        data[4 * c + r] = mat[r, c];
-
-                cmd.SetComputeFloatParams(shadercs, name, data);
-            }
-
-            private static void SetMatrixArrayCS(CommandBuffer cmd, ComputeShader shadercs, string name, Matrix4x4[] matArray)
-            {
-                int numMatrices = matArray.Length;
-                var data = new float[numMatrices * 16];
-
-                for (int n = 0; n < numMatrices; n++)
-                    for (int c = 0; c < 4; c++)
-                        for (int r = 0; r < 4; r++)
-                            data[16 * n + 4 * c + r] = matArray[n][r, c];
-
-                cmd.SetComputeFloatParams(shadercs, name, data);
-            }
-
-            private static void SetVectorArrayCS(CommandBuffer cmd, ComputeShader shadercs, string name, Vector4[] vecArray)
-            {
-                int numVectors = vecArray.Length;
-                var data = new float[numVectors * 4];
-
-                for (int n = 0; n < numVectors; n++)
-                    for (int i = 0; i < 4; i++)
-                        data[4 * n + i] = vecArray[n][i];
-
-                cmd.SetComputeFloatParams(shadercs, name, data);
-            }
-
             static Matrix4x4 GetFlipMatrix()
             {
                 Matrix4x4 flip = Matrix4x4.identity;
@@ -617,8 +594,8 @@ void VoxelLightListGeneration(CommandBuffer cmd, Camera camera, Matrix4x4 projsc
                 cmd.DispatchCompute(buildPerVoxelLightListShader, s_ClearVoxelAtomicKernel, 1, 1, 1);
 
                 cmd.SetComputeIntParam(buildPerVoxelLightListShader, "g_iNrVisibLights", m_lightCount);
-                SetMatrixCS(cmd, buildPerVoxelLightListShader, "g_mScrProjection", projscr);
-                SetMatrixCS(cmd, buildPerVoxelLightListShader, "g_mInvScrProjection", invProjscr);
+                Utilities.SetMatrixCS(cmd, buildPerVoxelLightListShader, "g_mScrProjection", projscr);
+                Utilities.SetMatrixCS(cmd, buildPerVoxelLightListShader, "g_mInvScrProjection", invProjscr);
 
                 cmd.SetComputeIntParam(buildPerVoxelLightListShader, "g_iLog2NumClusters", k_Log2NumClusters);
 
@@ -649,17 +626,17 @@ void VoxelLightListGeneration(CommandBuffer cmd, Camera camera, Matrix4x4 projsc
                     cmd.SetComputeBufferParam(buildPerVoxelLightListShader, s_GenListPerVoxelKernel, "g_logBaseBuffer", s_PerTileLogBaseTweak);
                 }
 
-                var numTilesX = (camera.pixelWidth + 15) / 16;
-                var numTilesY = (camera.pixelHeight + 15) / 16;
+                var numTilesX = GetNumTileX(camera);
+                var numTilesY = GetNumTileY(camera);
                 cmd.DispatchCompute(buildPerVoxelLightListShader, s_GenListPerVoxelKernel, numTilesX, numTilesY, 1);
             }
 
             public void BuildGPULightLists(Camera camera, RenderLoop loop, HDRenderLoop.LightList lightList, int cameraDepthBuffer)
             {
                 var w = camera.pixelWidth;
                 var h = camera.pixelHeight;
-                var numTilesX = (w + 15) / 16;
-                var numTilesY = (h + 15) / 16;
+                var numTilesX = GetNumTileX(camera);
+                var numTilesY = GetNumTileY(camera);
                 var numBigTilesX = (w + 63) / 64;
                 var numBigTilesY = (h + 63) / 64;
 
@@ -685,8 +662,8 @@ public void BuildGPULightLists(Camera camera, RenderLoop loop, HDRenderLoop.Ligh
                     var invProjh = projh.inverse;
 
                     cmd.SetComputeIntParam(buildScreenAABBShader, "g_iNrVisibLights", m_lightCount);
-                    SetMatrixCS(cmd, buildScreenAABBShader, "g_mProjection", projh);
-                    SetMatrixCS(cmd, buildScreenAABBShader, "g_mInvProjection", invProjh);
+                    Utilities.SetMatrixCS(cmd, buildScreenAABBShader, "g_mProjection", projh);
+                    Utilities.SetMatrixCS(cmd, buildScreenAABBShader, "g_mInvProjection", invProjh);
                     cmd.SetComputeBufferParam(buildScreenAABBShader, s_GenAABBKernel, "g_vBoundsBuffer", s_AABBBoundsBuffer);
                     cmd.DispatchCompute(buildScreenAABBShader, s_GenAABBKernel, (m_lightCount + 7) / 8, 1, 1);
                 }
@@ -696,20 +673,20 @@ public void BuildGPULightLists(Camera camera, RenderLoop loop, HDRenderLoop.Ligh
                 {
                     cmd.SetComputeIntParams(buildPerBigTileLightListShader, "g_viDimensions", new int[2] { w, h });
                     cmd.SetComputeIntParam(buildPerBigTileLightListShader, "g_iNrVisibLights", m_lightCount);
-                    SetMatrixCS(cmd, buildPerBigTileLightListShader, "g_mScrProjection", projscr);
-                    SetMatrixCS(cmd, buildPerBigTileLightListShader, "g_mInvScrProjection", invProjscr);
+                    Utilities.SetMatrixCS(cmd, buildPerBigTileLightListShader, "g_mScrProjection", projscr);
+                    Utilities.SetMatrixCS(cmd, buildPerBigTileLightListShader, "g_mInvScrProjection", invProjscr);
                     cmd.SetComputeFloatParam(buildPerBigTileLightListShader, "g_fNearPlane", camera.nearClipPlane);
                     cmd.SetComputeFloatParam(buildPerBigTileLightListShader, "g_fFarPlane", camera.farClipPlane);
                     cmd.SetComputeBufferParam(buildPerBigTileLightListShader, s_GenListPerBigTileKernel, "g_vLightList", s_BigTileLightList);
                     cmd.DispatchCompute(buildPerBigTileLightListShader, s_GenListPerBigTileKernel, numBigTilesX, numBigTilesY, 1);
                 }
-/*
+
                 if (usingFptl)       // optimized for opaques only
                 {
                     cmd.SetComputeIntParams(buildPerTileLightListShader, "g_viDimensions", new int[2] { w, h });
                     cmd.SetComputeIntParam(buildPerTileLightListShader, "g_iNrVisibLights", m_lightCount);
-                    SetMatrixCS(cmd, buildPerTileLightListShader, "g_mScrProjection", projscr);
-                    SetMatrixCS(cmd, buildPerTileLightListShader, "g_mInvScrProjection", invProjscr);
+                    Utilities.SetMatrixCS(cmd, buildPerTileLightListShader, "g_mScrProjection", projscr);
+                    Utilities.SetMatrixCS(cmd, buildPerTileLightListShader, "g_mInvScrProjection", invProjscr);
                     cmd.SetComputeTextureParam(buildPerTileLightListShader, s_GenListPerTileKernel, "g_depth_tex", new RenderTargetIdentifier(cameraDepthBuffer));
                     cmd.SetComputeBufferParam(buildPerTileLightListShader, s_GenListPerTileKernel, "g_vLightList", s_LightList);
                     if (enableBigTilePrepass) cmd.SetComputeBufferParam(buildPerTileLightListShader, s_GenListPerTileKernel, "g_vBigTileLightList", s_BigTileLightList);
@@ -720,7 +697,7 @@ public void BuildGPULightLists(Camera camera, RenderLoop loop, HDRenderLoop.Ligh
                 {
                     VoxelLightListGeneration(cmd, camera, projscr, invProjscr, cameraDepthBuffer);
                 }
-                */
+
                 loop.ExecuteCommandBuffer(cmd);
                 cmd.Dispose();
             }
@@ -741,10 +718,14 @@ public void PushGlobalParams(Camera camera, RenderLoop loop, HDRenderLoop.LightL
                 Shader.SetGlobalBuffer("_AreaLightList", s_AreaLightList);
                 Shader.SetGlobalBuffer("_PunctualShadowList", s_PunctualShadowList);
                 Shader.SetGlobalBuffer("_EnvLightList", s_EnvLightList);
- 
+
                 Shader.SetGlobalVectorArray("_DirShadowSplitSpheres", lightList.directionalShadowSplitSphereSqr);
 
-                /*
+                var cmd = new CommandBuffer { name = "Push Global Parameters" };
+
+                cmd.SetGlobalFloat("_NumTileX", (float)GetNumTileX(camera));
+                cmd.SetGlobalFloat("_NumTileY", (float)GetNumTileY(camera));
+
                 if (enableBigTilePrepass)
                     cmd.SetGlobalBuffer("g_vBigTileLightList", s_BigTileLightList);
 
@@ -766,17 +747,12 @@ public void PushGlobalParams(Camera camera, RenderLoop loop, HDRenderLoop.LightL
                     }
                 }
 
-                cmd.SetGlobalFloat("g_nNumDirLights", numDirLights);
-                cmd.SetGlobalBuffer("g_dirLightData", s_DirLightList);
-
                 loop.ExecuteCommandBuffer(cmd);
                 cmd.Dispose();
-                */
             }
 
             public void RenderDeferredLighting(Camera camera, RenderLoop renderLoop, RenderTargetIdentifier colorBuffer)
             {
-                /*
                 var bUseClusteredForDeferred = !usingFptl;       // doesn't work on reflections yet but will soon
                 var cmd = new CommandBuffer();
 
@@ -887,12 +863,12 @@ public void RenderDeferredLighting(Camera camera, RenderLoop renderLoop, RenderT
                 }
                 else
                 {*/
-            //        cmd.Blit(0, colorBuffer, m_DeferredMaterial, 0);
-              //      cmd.Blit(0, colorBuffer, m_DeferredReflectionMaterial, 0);
+                    cmd.Blit(0, colorBuffer, m_DeferredMaterial, 0);
+                    cmd.Blit(0, colorBuffer, m_DeferredReflectionMaterial, 0);
                 //}
 
-               // renderLoop.ExecuteCommandBuffer(cmd);
-               // cmd.Dispose();
+                renderLoop.ExecuteCommandBuffer(cmd);
+                cmd.Dispose();
             }
         }
     }