Merge pull request #43 from Unity-Technologies/tiledebugging2

Tile debugging 2.0
8 年前 · 53173cc7
--- a/Assets/ScriptableRenderLoop/HDRenderLoop/Debug/Resources/DebugViewMaterialGBuffer.shader
+++ b/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;

--- a/Assets/ScriptableRenderLoop/HDRenderLoop/Debug/Resources/DebugViewTiles.shader
+++ b/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
--- a/Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/TilePass/TilePass.cs
+++ b/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");