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

Assets/ScriptableRenderLoop/HDRenderLoop/HDRenderLoop.cs

             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)
 
             // 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)
                     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

 
 #include "Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/LightDefinition.cs.hlsl"
 
-#ifdef LIGHTLOOP_SINGLE_PASS 
+#ifdef LIGHTLOOP_SINGLE_PASS
+#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
 // 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

             #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
-        // 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
                 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);
 
 
                 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

                 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

 // ----------------------------------------------------------------------------
 
 // 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

 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

 
 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;
-    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

         {
             string GetKeyword()
             {
-                return "LIGHTLOOP_SINGLE_PASS";
+                return "LIGHTLOOP_TILE_PASS";
             }
 
             public const int MaxNumLights = 1024;
             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;
             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()
             {
                 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()
                 s_EnvLightList = null;
                 s_PunctualShadowList.Release();
                 s_PunctualShadowList = null;
-/*
+
-*/
             }
 
             public bool NeedResize()
                 }
             }
 
-            // 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;
                 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);
 
                     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);
             }
 
                 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;
 
                     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);
                 }
                 {
                     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);
-/*
+
-                    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);
                 {
                     VoxelLightListGeneration(cmd, camera, projscr, invProjscr, cameraDepthBuffer);
                 }
-                */
+
                 loop.ExecuteCommandBuffer(cmd);
                 cmd.Dispose();
             }
                 Shader.SetGlobalBuffer("_AreaLightList", s_AreaLightList);
                 Shader.SetGlobalBuffer("_PunctualShadowList", s_PunctualShadowList);
                 Shader.SetGlobalBuffer("_EnvLightList", s_EnvLightList);
- 
+
-                /*
+                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);
 
                     }
                 }
 
-                cmd.SetGlobalFloat("g_nNumDirLights", numDirLights);
-                cmd.SetGlobalBuffer("g_dirLightData", s_DirLightList);
-
-                */
-                /*
                 var bUseClusteredForDeferred = !usingFptl;       // doesn't work on reflections yet but will soon
                 var cmd = new CommandBuffer();
 
                 }
                 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();
             }
         }
     }

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

-// uses the optimized single layered light list for opaques only
+#if defined (LIGHTLOOP_TILE_DIRECT) || defined(LIGHTLOOP_TILE_ALL)
+#define PROCESS_DIRECTIONAL_LIGHT
+#define PROCESS_PUNCTUAL_LIGHT
+#define PROCESS_AREA_LIGHT
+#endif
-#ifdef USE_FPTL_LIGHTLIST
-#define OPAQUES_ONLY
+#if defined (LIGHTLOOP_TILE_INDIRECT) || defined(LIGHTLOOP_TILE_ALL)
+#define PROCESS_ENV_LIGHT
+
+
+uint _NumTileX;
+uint _NumTileY;
+
+#define TILE_SIZE 16 // This is fixed
+#define DWORD_PER_TILE 16 // See dwordsPerTile in TilePass.cs, we have roomm for 31 lights and a number of light value all store on 16 bit (ushort)
+
+// 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
+float g_fClustScale;
+float g_fClustBase;
+float g_fNearPlane;
+float g_fFarPlane;
+int g_iLog2NumClusters;	// We need to always define these to keep constant buffer layouts compatible
+
+uint g_isLogBaseBufferEnabled;
+uint g_isOpaquesOnlyEnabled;
+//#endif
+
+#ifdef USE_CLUSTERED_LIGHTLIST
+Buffer<uint> g_vLayeredOffsetsBuffer;
+Buffer<float> g_logBaseBuffer;
+#endif
+
+// TODO: Need to correctly define the shadow framework, WIP
+#include "../SinglePass/SinglePass.hlsl"

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

 // LightLoop
 // ----------------------------------------------------------------------------
 
+// Calculate the offset in global light index light for current light category
+int GetTileOffset(Coordinate coord, uint lightCategory)
+{
+    uint2 tileIndex = coord.unPositionSS / TILE_SIZE;
+    return (tileIndex.y + lightCategory * _NumTileY) * _NumTileX + tileIndex.x;
+}
+
+void GetCountAndStartOpaque(Coordinate coord, uint lightCategory, float linearDepth, out uint start, out uint lightCount)
+{
+    const int tileOffset = GetTileOffset(coord, lightCategory);
+
+    // The first entry inside a tile is the number of light for lightCategory (thus the +0)
+    lightCount = g_vLightListGlobal[DWORD_PER_TILE * tileOffs + 0] & 0xffff;
+    start = tileOffset;
+}
+
+uint FetchIndexOpaque(uint tileOffset, uint lightIndex)
+{
+    const uint lightIndexPlusOne = lightIndex + 1; // Add +1 as first slot is reserved to store number of light
+    // Light index are store on 16bit
+    return (g_vLightListGlobal[DWORD_PER_TILE * tileOffset + (lightIndexPlusOne >> 1)] >> ((lightIndexPlusOne & 1) * DWORD_PER_TILE)) & 0xffff;
+}
+
+#ifdef USE_FPTL_LIGHTLIST
+
+void GetCountAndStart(Coordinate coord, uint lightCategory, float linearDepth, out uint start, out uint lightCount)
+{
+    GetCountAndStartOpaque(coord, lightCategory, linearDepth, start, lightCount);
+}
+
+uint FetchIndex(uint tileOffset, uint lightIndex)
+{
+    return FetchIndexOpaque(tileOffs, lightIndex);
+}
+
+#else
+
+#include "ClusteredUtils.hlsl"
+
+void GetCountAndStart(Coordinate coord, uint lightCategory, float linearDepth, out uint start, out uint lightCount)
+{
+    if(g_isOpaquesOnlyEnabled)
+    {
+        GetCountAndStartOpaque(coord, lightCategory, linearDepth, start, lightCount);
+    }
+    else
+    {
+        uint2 tileIndex = coord.unPositionSS / TILE_SIZE;
+
+        float logBase = g_fClustBase;
+        if (g_isLogBaseBufferEnabled)
+        {
+            logBase = g_logBaseBuffer[tileIndex.y * _NumTileX + tileIndex.x];
+        }
+
+        int clustIdx = SnapToClusterIdxFlex(linearDepth, logBase, g_isLogBaseBufferEnabled != 0);
+
+        int nrClusters = (1 << g_iLog2NumClusters);
+        const int idx = ((model * nrClusters + clustIdx) * _NumTileY + tileIndex.y) * _NumTileX + tileIndex.x;
+        uint dataPair = g_vLayeredOffsetsBuffer[idx];
+        start = dataPair & 0x7ffffff;
+        lightCount = (dataPair >> 27) & 31;
+    }
+}
+
+uint FetchIndex(uint tileOffset, uint lightIndex)
+{
+    if(g_isOpaquesOnlyEnabled)
+        return FetchIndexOpaque(tileOffset, lightIndex);
+    else
+        return g_vLightListGlobal[tileOffset + lightIndex];
+}
+
+float GetLinearDepth(float zDptBufSpace)    // 0 is near 1 is far
+{
+    // todo (simplify): m22 is zero and m23 is +1/-1 (depends on left/right hand proj)
+    float m22 = g_mInvScrProjection[2].z, m23 = g_mInvScrProjection[2].w;
+    float m32 = g_mInvScrProjection[3].z, m33 = g_mInvScrProjection[3].w;
+
+    return (m22 * zDptBufSpace + m23) / (m32 * zDptBufSpace + m33);
+
+    //float3 vP = float3(0.0f,0.0f,zDptBufSpace);
+    //float4 v4Pres = mul(g_mInvScrProjection, float4(vP,1.0));
+    //return v4Pres.z / v4Pres.w;
+}
+
+#endif
+
-void LightLoop(float3 V, float3 positionWS, PreLightData prelightData, BSDFData bsdfData, float3 bakeDiffuseLighting,
-    out float3 diffuseLighting,
-    out float3 specularLighting)
+void LightLoop( float3 V, float3 positionWS, Coordinate coord, PreLightData prelightData, BSDFData bsdfData, float3 bakeDiffuseLighting,
+                out float3 diffuseLighting,
+                out float3 specularLighting)
+#if USE_CLUSTERED_LIGHTLIST
+    // TODO: Think more about the design, it is ok to do that ? hope the compiler could optimize it out as we do it before LightLoop call, else need to pass it as argument...
+    float depth = LOAD_TEXTURE2D(_CameraDepthTexture, coord.unPositionSS).x;
+    float linearDepth = GetLinearDepth(depth); // View space linear depth
+#else
+    float linearDepth = 0.0; // unsued
+#endif
+
     LightLoopContext context;
     ZERO_INITIALIZE(LightLoopContext, context);
 
     int i = 0; // Declare once to avoid the D3D11 compiler warning.
 
+#ifdef PROCESS_DIRECTIONAL_LIGHT
-        EvaluateBSDF_Directional(context, V, positionWS, prelightData, _DirectionalLightList[i], bsdfData,
-            localDiffuseLighting, localSpecularLighting);
+        EvaluateBSDF_Directional(   context, V, positionWS, prelightData, _DirectionalLightList[i], bsdfData,
+                                    localDiffuseLighting, localSpecularLighting);
+#endif
-    for (i = 0; i < _PunctualLightCount; ++i)
+#ifdef PROCESS_PUNCTUAL_LIGHT
+    uint punctualLightStart;
+    uint punctualLightCount;
+    GetCountAndStart(coord, DIRECT_LIGHT, linearDepth, start, punctualLightCount);
+    for (i = 0; i < punctualLightCount; ++i)
-        EvaluateBSDF_Punctual(context, V, positionWS, prelightData, _PunctualLightList[i], bsdfData,
-            localDiffuseLighting, localSpecularLighting);
+        EvaluateBSDF_Punctual(  context, V, positionWS, prelightData, _PunctualLightList[FetchIndex(punctualLightStart, i)], bsdfData,
+                                localDiffuseLighting, localSpecularLighting);
+#endif
-    for (i = 0; i < _AreaLightCount; ++i)
+#ifdef PROCESS_AREA_LIGHT
+    /*
+    // TODO: Area lights are where the sorting is important (Morten approach with while loop)
+    uint areaLightStart;
+    uint areaLightCount;
+    GetCountAndStart(coord, LightCatergory.AreaLight, linearDepth, start, punctualLightCount);
+    for (i = 0; i < areaLightCount; ++i)
-        EvaluateBSDF_Area(context, V, positionWS, prelightData, _AreaLightList[i], bsdfData,
-            localDiffuseLighting, localSpecularLighting);
+        EvaluateBSDF_Area(  context, V, positionWS, prelightData, _AreaLightList[FetchIndex(areaLightStart, i)], bsdfData,
+                            localDiffuseLighting, localSpecularLighting);
+    */
+#endif
+
+#ifdef PROCESS_ENV_LIGHT
+    uint envLightStart;
+    uint envLightCount;
+    GetCountAndStart(coord, REFLECTION_LIGHT, linearDepth, start, envLightCount);
+
+    float3 iblDiffuseLighting = float3(0.0, 0.0, 0.0);
+    float3 iblSpecularLighting = float3(0.0, 0.0, 0.0);
+
+    for (i = 0; i < envLightCount; ++i)
+    {
+        float3 localDiffuseLighting, localSpecularLighting;
+        float2 weight;
+        context.sampleReflection = SINGLE_PASS_CONTEXT_SAMPLE_REFLECTION_PROBES;
+        EvaluateBSDF_Env(context, V, positionWS, prelightData, _EnvLightList[FetchIndex(punctualLightStart, i)], bsdfData, localDiffuseLighting, localSpecularLighting, 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
+
+    // TODO
+#if ENABLE_DEBUG
+//    c = OverlayHeatMap(pixCoord & 15, numLightsProcessed, c);
+#endif
 }

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Lit/Lit.hlsl

     GetPreIntegratedFGD(iblNdotV, bsdfData.perceptualRoughness, bsdfData.fresnel0, preLightData.specularFGD, preLightData.diffuseFGD);
 
     // #if SHADERPASS == SHADERPASS_GBUFFER
-    // preLightData.ambientOcclusion = LOAD_TEXTURE2D(_AmbientOcclusion, uint3(coord.unPositionSS, 0)).x;
+    // preLightData.ambientOcclusion = LOAD_TEXTURE2D(_AmbientOcclusion, coord.unPositionSS).x;
     // #endif
 
     // Area light specific

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Material.hlsl

         TEXTURE2D(MERGE_NAME(NAME, 0));  \
         TEXTURE2D(MERGE_NAME(NAME, 1));
 
-#define FETCH_GBUFFER(NAME, TEX, UV)                                        \
-        GBufferType0 MERGE_NAME(NAME, 0) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 0), uint3(UV, 0)); \
-        GBufferType1 MERGE_NAME(NAME, 1) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 1), uint3(UV, 0));
+#define FETCH_GBUFFER(NAME, TEX, unCoord2)                                        \
+        GBufferType0 MERGE_NAME(NAME, 0) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 0), unCoord2); \
+        GBufferType1 MERGE_NAME(NAME, 1) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 1), unCoord2);
 
 #define ENCODE_INTO_GBUFFER(SURFACE_DATA, BAKE_DIFFUSE_LIGHTING, NAME) EncodeIntoGBuffer(SURFACE_DATA, BAKE_DIFFUSE_LIGHTING, MERGE_NAME(NAME,0), MERGE_NAME(NAME,1))
 #define DECODE_FROM_GBUFFER(NAME, BSDF_DATA, BAKE_DIFFUSE_LIGHTING) DecodeFromGBuffer(MERGE_NAME(NAME,0), MERGE_NAME(NAME,1), BSDF_DATA, BAKE_DIFFUSE_LIGHTING)
         TEXTURE2D(MERGE_NAME(NAME, 1));  \
         TEXTURE2D(MERGE_NAME(NAME, 2));
 
-#define FETCH_GBUFFER(NAME, TEX, UV)                                        \
-        GBufferType0 MERGE_NAME(NAME, 0) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 0), uint3(UV, 0)); \
-        GBufferType1 MERGE_NAME(NAME, 1) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 1), uint3(UV, 0)); \
-        GBufferType2 MERGE_NAME(NAME, 2) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 2), uint3(UV, 0));
+#define FETCH_GBUFFER(NAME, TEX, unCoord2)                                        \
+        GBufferType0 MERGE_NAME(NAME, 0) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 0), unCoord2); \
+        GBufferType1 MERGE_NAME(NAME, 1) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 1), unCoord2); \
+        GBufferType2 MERGE_NAME(NAME, 2) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 2), unCoord2);
 
 #define ENCODE_INTO_GBUFFER(SURFACE_DATA, BAKE_DIFFUSE_LIGHTING, NAME) EncodeIntoGBuffer(SURFACE_DATA, BAKE_DIFFUSE_LIGHTING, MERGE_NAME(NAME,0), MERGE_NAME(NAME,1), MERGE_NAME(NAME,2))
 #define DECODE_FROM_GBUFFER(NAME, BSDF_DATA, BAKE_DIFFUSE_LIGHTING) DecodeFromGBuffer(MERGE_NAME(NAME,0), MERGE_NAME(NAME,1), MERGE_NAME(NAME,2), BSDF_DATA, BAKE_DIFFUSE_LIGHTING)
         TEXTURE2D(MERGE_NAME(NAME, 2));  \
         TEXTURE2D(MERGE_NAME(NAME, 3));
 
-#define FETCH_GBUFFER(NAME, TEX, UV)                                        \
-        GBufferType0 MERGE_NAME(NAME, 0) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 0), uint3(UV, 0)); \
-        GBufferType1 MERGE_NAME(NAME, 1) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 1), uint3(UV, 0)); \
-        GBufferType2 MERGE_NAME(NAME, 2) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 2), uint3(UV, 0)); \
-        GBufferType3 MERGE_NAME(NAME, 3) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 3), uint3(UV, 0));
+#define FETCH_GBUFFER(NAME, TEX, unCoord2)                                        \
+        GBufferType0 MERGE_NAME(NAME, 0) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 0), unCoord2); \
+        GBufferType1 MERGE_NAME(NAME, 1) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 1), unCoord2); \
+        GBufferType2 MERGE_NAME(NAME, 2) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 2), unCoord2); \
+        GBufferType3 MERGE_NAME(NAME, 3) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 3), unCoord2);
 
 #define ENCODE_INTO_GBUFFER(SURFACE_DATA, BAKE_DIFFUSE_LIGHTING, NAME) EncodeIntoGBuffer(SURFACE_DATA, BAKE_DIFFUSE_LIGHTING, MERGE_NAME(NAME, 0), MERGE_NAME(NAME, 1), MERGE_NAME(NAME, 2), MERGE_NAME(NAME, 3))
 #define DECODE_FROM_GBUFFER(NAME, BSDF_DATA, BAKE_DIFFUSE_LIGHTING) DecodeFromGBuffer(MERGE_NAME(NAME, 0), MERGE_NAME(NAME, 1), MERGE_NAME(NAME, 2), MERGE_NAME(NAME, 3), BSDF_DATA, BAKE_DIFFUSE_LIGHTING)
         TEXTURE2D(MERGE_NAME(NAME, 3));  \
         TEXTURE2D(MERGE_NAME(NAME, 4));
 
-#define FETCH_GBUFFER(NAME, TEX, UV)                                        \
-        GBufferType0 MERGE_NAME(NAME, 0) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 0), uint3(UV, 0)); \
-        GBufferType1 MERGE_NAME(NAME, 1) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 1), uint3(UV, 0)); \
-        GBufferType2 MERGE_NAME(NAME, 2) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 2), uint3(UV, 0)); \
-        GBufferType3 MERGE_NAME(NAME, 3) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 3), uint3(UV, 0)); \
-        GBufferType4 MERGE_NAME(NAME, 4) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 4), uint3(UV, 0));
+#define FETCH_GBUFFER(NAME, TEX, unCoord2)                                        \
+        GBufferType0 MERGE_NAME(NAME, 0) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 0), unCoord2); \
+        GBufferType1 MERGE_NAME(NAME, 1) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 1), unCoord2); \
+        GBufferType2 MERGE_NAME(NAME, 2) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 2), unCoord2); \
+        GBufferType3 MERGE_NAME(NAME, 3) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 3), unCoord2); \
+        GBufferType4 MERGE_NAME(NAME, 4) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 4), unCoord2);
 
 #define ENCODE_INTO_GBUFFER(SURFACE_DATA, BAKE_DIFFUSE_LIGHTING, NAME) EncodeIntoGBuffer(SURFACE_DATA, BAKE_DIFFUSE_LIGHTING, MERGE_NAME(NAME, 0), MERGE_NAME(NAME, 1), MERGE_NAME(NAME, 2), MERGE_NAME(NAME, 3), MERGE_NAME(NAME, 4))
 #define DECODE_FROM_GBUFFER(NAME, BSDF_DATA, BAKE_DIFFUSE_LIGHTING) DecodeFromGBuffer(MERGE_NAME(NAME, 0), MERGE_NAME(NAME, 1), MERGE_NAME(NAME, 2), MERGE_NAME(NAME, 3), MERGE_NAME(NAME, 4), BSDF_DATA, BAKE_DIFFUSE_LIGHTING)

Assets/ScriptableRenderLoop/HDRenderLoop/ShaderPass/ShaderPassForward.hlsl

 	float3 diffuseLighting;
 	float3 specularLighting;
     float3 bakeDiffuseLighting = GetBakedDiffuseLigthing(surfaceData, builtinData, bsdfData, preLightData);
-    LightLoop(V, positionWS, preLightData, bsdfData, bakeDiffuseLighting, diffuseLighting, specularLighting);
+    LightLoop(V, positionWS, coord, preLightData, bsdfData, bakeDiffuseLighting, diffuseLighting, specularLighting);
 
 	return float4(diffuseLighting + specularLighting, builtinData.opacity);
 }

Assets/ScriptableRenderLoop/HDRenderLoop/Utilities.cs

         {
             return new Vector4(camera.pixelWidth, camera.pixelHeight, 1.0f / camera.pixelWidth, 1.0f / camera.pixelHeight);
         }
+
+        // TEMP: These functions should be implemented C++ side, for now do it in C#
+        public 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);
+        }
+
+        public 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);
+        }
+
+        public 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);
+        }
     }
 }

Assets/ScriptableRenderLoop/ShaderLibrary/API/D3D11.hlsl

 #define SAMPLER2D_HALF SAMPLER2D
 #define SAMPLER2D_FLOAT SAMPLER2D
 
-#define LOAD_TEXTURE2D(textureName, unCoord3) textureName.Load(unCoord3)
-#define LOAD_TEXTURE2D_MSAA(textureName, unCoord3, sampleIndex) textureName.Load(unCoord3, sampleIndex)
+#define LOAD_TEXTURE2D(textureName, unCoord2) textureName.Load(int3(unCoord2, 0))
+#define LOAD_TEXTURE2D_MSAA(textureName, unCoord2, sampleIndex) textureName.Load(unCoord2, sampleIndex)
 

Assets/ScriptableRenderLoop/ShaderLibrary/Common.hlsl

     // Normalize coordinates
     float2  positionSS;
     // Unormalize coordinates
-    int2    unPositionSS;
+    uint2    unPositionSS;
 };
 
 // This function is use to provide an easy way to sample into a screen texture, either from a pixel or a compute shaders.
 #endif
     coord.positionSS *= invScreenSize;
 
-    coord.unPositionSS = int2(unPositionSS);
+    coord.unPositionSS = uint2(unPositionSS);
 
     return coord;
 }