Tile debugging 2.0

Assets/ScriptableRenderLoop/HDRenderLoop/Debug/Resources/DebugViewMaterialGBuffer.shader

             DECLARE_GBUFFER_TEXTURE(_GBufferTexture);
 
             TEXTURE2D(_CameraDepthTexture);
-			SAMPLER2D(sampler_CameraDepthTexture);
+            SAMPLER2D(sampler_CameraDepthTexture);
             int         _DebugViewMaterial;
 
             struct Attributes
 
             float4 Frag(Varyings input) : SV_Target
             {
-				float4 unPositionSS = input.positionCS; // as input we have the vpos
-				Coordinate coord = GetCoordinate(unPositionSS.xy, _ScreenSize.zw);
+                float4 unPositionSS = input.positionCS; // as input we have the vpos
+                Coordinate coord = GetCoordinate(unPositionSS.xy, _ScreenSize.zw);
 
                 float depth = LOAD_TEXTURE2D(_CameraDepthTexture, coord.unPositionSS).x;
 

Assets/ScriptableRenderLoop/HDRenderLoop/Debug/Resources/DebugViewTiles.shader

             // variable declaration
             //-------------------------------------------------------------------------------------
 
-            uint _ViewTilesFlags;
-
+
+            uint _ViewTilesFlags;
+            float2 _MousePixelCoord;
+
+            }
+
+            float4 AlphaBlend(float4 c0, float4 c1)	// c1 over c0
+            {
+                return float4(lerp(c0.rgb, c1.rgb, c1.a), c0.a + c1.a - c0.a * c1.a);
             }
 
             float4 OverlayHeatMap(uint2 pixCoord, uint numLights)
             float4 Frag(float4 positionCS : SV_POSITION) : SV_Target
             {
                 Coordinate coord = GetCoordinate(positionCS.xy, _ScreenSize.zw);
-
-                #ifdef USE_CLUSTERED_LIGHTLIST
+                
+                int2 pixelCoord = coord.unPositionSS.xy;
+                int2 tileCoord = pixelCoord / TILE_SIZE;
+                int2 mouseTileCoord = _MousePixelCoord / TILE_SIZE;
+                int2 offsetInTile = pixelCoord - tileCoord * TILE_SIZE;
+                
+#ifdef USE_CLUSTERED_LIGHTLIST
-                #else
+#else
-                #endif
+#endif
 
                 int n = 0;
                 for (int category = 0; category < LIGHTCATEGORY_COUNT; category++)
                     }
                 }
                 
+                float4 result = 0.0f;
+
+				// Tile overlap counter
-                    return OverlayHeatMap(int2(coord.unPositionSS.xy) & 15, n);
+                    result = OverlayHeatMap(int2(coord.unPositionSS.xy) & (TILE_SIZE - 1), n);
+                }
+
+				// Highlight selected tile
+                if(all(mouseTileCoord == tileCoord))
+                {
+                    bool border = any(offsetInTile == 0 || offsetInTile == TILE_SIZE - 1);
+                    float4 result2 = float4(1, 1, 1, border ? 1.0f : 0.5);
+                    result = AlphaBlend(result, result2);
-                else
+
+                // Print light lists for selected tile at the bottom of the screen
+                int maxLights = 32;
+                if(tileCoord.y < LIGHTCATEGORY_COUNT && tileCoord.x < maxLights + 3)
-                    return 0.0;
+                    Coordinate mouseCoord = GetCoordinate(_MousePixelCoord, _ScreenSize.zw);
+
+                    int category = (LIGHTCATEGORY_COUNT - 1) - tileCoord.y;
+                    int start;
+                    int count;
+                    GetCountAndStart(mouseCoord, category, linearDepth, start, count);
+
+                    float4 result2 = float4(.1,.1,.1,.9);
+                    int2 fontCoord = int2(pixelCoord.x, offsetInTile.y);
+                    int lightListIndex = tileCoord.x - 2;
+
+                    int n = -1;
+                    if(tileCoord.x == 0)
+                    {
+                        n = count;
+                    }
+                    else if(lightListIndex >= 0 && lightListIndex < count)
+                    {
+                        n = FetchIndex(start, lightListIndex);
+                    }
+
+                    if(n >= 0)
+                    {
+                        if(SampleDebugFontNumber(offsetInTile, n))
+                            result2 = float4(0, 0, 0, 1);
+                        if(SampleDebugFontNumber(offsetInTile + 1, n))
+                            result2 = float4(1, 1, 1, 1);
+                    }
+
+                    result = AlphaBlend(result, result2);
+
+                return result;
             }
 
             ENDHLSL

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

 
         public class LightLoop : BaseLightLoop
         {
-            public const int k_MaxDirectionalLightsOnSCreen = 10;
-            public const int k_MaxPunctualLightsOnSCreen = 512;
+            public const int k_MaxDirectionalLightsOnScreen = 10;
+            public const int k_MaxPunctualLightsOnScreen = 512;
-            public const int k_MaxLightsOnSCreen = k_MaxDirectionalLightsOnSCreen + k_MaxPunctualLightsOnSCreen + k_MaxAreaLightsOnSCreen;
-            public const int k_MaxEnvLightsOnSCreen = 64;
+            public const int k_MaxLightsOnScreen = k_MaxDirectionalLightsOnScreen + k_MaxPunctualLightsOnScreen + k_MaxAreaLightsOnSCreen;
+            public const int k_MaxEnvLightsOnScreen = 64;
             public const int k_MaxShadowOnScreen = 16;
             public const int k_MaxCascadeCount = 4; //Should be not less than m_Settings.directionalLightCascadeCount;
 
                 m_lightList = new LightList();
                 m_lightList.Allocate();
 
-                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)));
+                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)));
                 s_shadowDatas = new ComputeBuffer(k_MaxCascadeCount + k_MaxShadowOnScreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(ShadowData)));
 
                 m_CookieTexArray = new TextureCache2D();
 
                 s_GenAABBKernel = buildScreenAABBShader.FindKernel("ScreenBoundsAABB");
                 s_GenListPerTileKernel = buildPerTileLightListShader.FindKernel(enableBigTilePrepass ? "TileLightListGen_SrcBigTile" : "TileLightListGen");
-                s_AABBBoundsBuffer = new ComputeBuffer(2 * k_MaxLightsOnSCreen, 3 * sizeof(float));
-                s_ConvexBoundsBuffer = new ComputeBuffer(k_MaxLightsOnSCreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(SFiniteLightBound)));
-                s_LightVolumeDataBuffer = new ComputeBuffer(k_MaxLightsOnSCreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(LightVolumeData)));
+                s_AABBBoundsBuffer = new ComputeBuffer(2 * k_MaxLightsOnScreen, 3 * sizeof(float));
+                s_ConvexBoundsBuffer = new ComputeBuffer(k_MaxLightsOnScreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(SFiniteLightBound)));
+                s_LightVolumeDataBuffer = new ComputeBuffer(k_MaxLightsOnScreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(LightVolumeData)));
 
                 buildScreenAABBShader.SetBuffer(s_GenAABBKernel, "g_data", s_ConvexBoundsBuffer);
                 buildPerTileLightListShader.SetBuffer(s_GenListPerTileKernel, "g_vBoundsBuffer", s_AABBBoundsBuffer);
                 m_DebugViewTilesMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderLoop/DebugViewTiles");
 
                 m_SingleDeferredMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderLoop/Deferred");
-                m_SingleDeferredMaterial.EnableKeyword("LIGHTLOOP_SINGLE_PASS");
+                m_SingleDeferredMaterial.EnableKeyword("LIGHTLOOP_SINGLE_PASS");
+
+#if UNITY_EDITOR
+                UnityEditor.SceneView.onSceneGUIDelegate -= OnSceneGUI;
+                UnityEditor.SceneView.onSceneGUIDelegate += OnSceneGUI;
+#endif
-            {
+            {
+#if UNITY_EDITOR
+                UnityEditor.SceneView.onSceneGUIDelegate -= OnSceneGUI;
+#endif
+
                 Utilities.SafeRelease(s_DirectionalLightDatas);
                 Utilities.SafeRelease(s_LightDatas);
                 Utilities.SafeRelease(s_EnvLightDatas);
                 int punctualLightcount = 0;
                 int areaLightCount = 0;
 
-                var sortKeys = new uint[Math.Min(cullResults.visibleLights.Length, k_MaxLightsOnSCreen)];
+                var sortKeys = new uint[Math.Min(cullResults.visibleLights.Length, k_MaxLightsOnScreen)];
                 int sortCount = 0;
 
                 for (int lightIndex = 0, numLights = cullResults.visibleLights.Length; lightIndex < numLights; ++lightIndex)
                         switch (light.lightType)
                         {
                             case LightType.Point:
-                                if (punctualLightcount >= k_MaxPunctualLightsOnSCreen)
+                                if (punctualLightcount >= k_MaxPunctualLightsOnScreen)
                                     continue;
                                 lightCategory = LightCategory.Punctual;
                                 gpuLightType = GPULightType.Point;
 
                             case LightType.Spot:
-                                if (punctualLightcount >= k_MaxPunctualLightsOnSCreen)
+                                if (punctualLightcount >= k_MaxPunctualLightsOnScreen)
                                     continue;
                                 lightCategory = LightCategory.Punctual;
                                 gpuLightType = GPULightType.Spot;
 
                             case LightType.Directional:
-                                if (directionalLightcount >= k_MaxDirectionalLightsOnSCreen)
+                                if (directionalLightcount >= k_MaxDirectionalLightsOnScreen)
                                     continue;
                                 lightCategory = LightCategory.Punctual;
                                 gpuLightType = GPULightType.Directional;
                 // Redo everything but this time with envLights
                 int envLightCount = 0;
 
-                sortKeys = new uint[Math.Min(cullResults.visibleReflectionProbes.Length, k_MaxEnvLightsOnSCreen)];
+                sortKeys = new uint[Math.Min(cullResults.visibleReflectionProbes.Length, k_MaxEnvLightsOnScreen)];
                 sortCount = 0;
 
                 for (int probeIndex = 0, numProbes = cullResults.visibleReflectionProbes.Length; probeIndex < numProbes; probeIndex++)
-                    if (envLightCount >= k_MaxEnvLightsOnSCreen)
+                    if (envLightCount >= k_MaxEnvLightsOnScreen)
                         continue;
 
                     // TODO: Support LightVolumeType.Sphere, currently in UI there is no way to specify a sphere influence volume                    
 
                 loop.ExecuteCommandBuffer(cmd);
                 cmd.Dispose();
-            }
-
+            }
+
+#if UNITY_EDITOR
+            private Vector2 m_mousePosition = Vector2.zero;
+            private void OnSceneGUI(UnityEditor.SceneView sceneview)
+            {
+                m_mousePosition = Event.current.mousePosition;
+            }
+#endif
+
-                var screenSize = Utilities.ComputeScreenSize(camera);
-
+                var screenSize = Utilities.ComputeScreenSize(camera);
+
+                Vector2 mousePixelCoord = Input.mousePosition;
+#if UNITY_EDITOR
+                if (!UnityEditor.EditorApplication.isPlayingOrWillChangePlaymode)
+                {
+                    mousePixelCoord = m_mousePosition;
+                    mousePixelCoord.y = (screenSize.y - 1.0f) - mousePixelCoord.y;
+                }
+#endif
+
                 m_DeferredDirectMaterial.SetMatrix("_InvViewProjMatrix", invViewProj);
                 m_DeferredDirectMaterial.SetVector("_ScreenSize", screenSize);
                 m_DeferredDirectMaterial.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
                 m_DebugViewTilesMaterial.SetMatrix("_InvViewProjMatrix", invViewProj);
                 m_DebugViewTilesMaterial.SetVector("_ScreenSize", screenSize);
                 m_DebugViewTilesMaterial.SetInt("_ViewTilesFlags", debugViewTilesFlags);
+                m_DebugViewTilesMaterial.SetVector("_MousePixelCoord", mousePixelCoord);
                 m_DebugViewTilesMaterial.EnableKeyword(bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
                 m_DebugViewTilesMaterial.DisableKeyword(!bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");