Merge pull request #8077 from Unity-Technologies/internal/master

Internal/master

Author: UnityAljosha

Packages/com.unity.render-pipelines.core/Documentation~/Rendering-Debugger.md

@@ -9,27 +9,47 @@ If your project uses the Universal Render Pipeline (URP) or the High-Definition
 - [Add controls to the Rendering Debugger in URP](https://docs.unity3d.com/Packages/[email protected]/manual/features/rendering-debugger-add-controls.html)
 - [Add controls to the Rendering Debugger in HDRP](https://docs.unity3d.com/Packages/[email protected]/manual/Rendering-Debugger-Add-Controls.html)
 
-## Open the Rendering Debugger
+## How to access the Rendering Debugger
 
-You can open the **Rendering Debugger** in the following ways:
+The Rendering Debugger window is available in the following modes:
 
-- As a window in the Editor.
-- An overlay in the Game view in Play Mode.
-- An overlay in your built application.
+| Mode       | Platform       | Availability                   | How to Open the Rendering Debugger                                                                                                                                                                                            |
+|------------|----------------|--------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| Editor     | All            | Yes (window in the Editor)     | Select **Window > Analysis > Rendering Debugger**                                                                                                                                                                             |
+| Play mode  | All            | Yes (overlay in the Game view) | On a desktop or laptop computer, press **LeftCtrl+Backspace** (**LeftCtrl+Delete** on macOS)<br>On a console controller, press L3 and R3 (Left Stick and Right Stick) |
+| Runtime    | Desktop/Laptop | Yes (only in Development builds) | Press **LeftCtrl+Backspace** (**LeftCtrl+Delete** on macOS)                                                                                                                                                                   |
+| Runtime    | Console        | Yes (only in Development builds) | Press L3 and R3 (Left Stick and Right Stick)                                                                                                                                                                                  |
+| Runtime    | Mobile         | Yes (only in Development builds) | Use a three-finger double tap                                                                                                                                                                                                 |
 
-### As a window in the Editor
 
-Select **Window > Analysis > Rendering Debugger** in the Editor.
+To disable the runtime UI, use the [enableRuntimeUI](https://docs.unity3d.com/Packages/[email protected]/api/UnityEngine.Rendering.DebugManager.html#UnityEngine_Rendering_DebugManager_enableRuntimeUI) property.
 
-### As an overlay
+## Navigation at runtime
 
-To enable the **Rendering Debugger** in your built application, you must enable **Development build** in your [build settings](https://docs.unity3d.com/2023.1/Documentation/Manual/BuildSettings.html).
+### Keyboard
 
-To open the overlay in your built application, or the Game view in Play Mode:
+| Action                                             | Control                                                                                   |
+|----------------------------------------------------|-------------------------------------------------------------------------------------------|
+| **Change the current active item**                 | Use the arrow keys                                                                        |
+| **Change the current tab**                         | Use the Page up and Page down keys (Fn + Up and Fn + Down keys respectively for MacOS)    |
+| **Display the current active item independently of the debug window** | Press the right Shift key                                                                 |
+
+### Xbox Controller
+
+| Action                                             | Control                                                                                   |
+|----------------------------------------------------|-------------------------------------------------------------------------------------------|
+| **Change the current active item**                 | Use the Directional pad (D-Pad)                                                           |
+| **Change the current tab**                         | Use the Left Bumper and Right Bumper                                                      |
+| **Display the current active item independently of the debug window** | Press the X button                                                                        |
+
+### PlayStation Controller
+
+| Action                                             | Control                                                                                   |
+|----------------------------------------------------|-------------------------------------------------------------------------------------------|
+| **Change the current active item**                 | Use the Directional buttons                                                               |
+| **Change the current tab**                         | Use the L1 button and R1 button                                                           |
+| **Display the current active item independently of the debug window** | Press the Square button                                                                   |
 
-- On a keyboard, press Left Ctrl + Backspace (macOS: Left Ctrl + Delete).
-- On a console controller, press L3 + R3.
-- On a mobile device, use a three-finger double tap.
 
 ## Add a control
 

Packages/com.unity.render-pipelines.core/Editor/BuildProcessors/CorePreprocessBuild.cs

@@ -6,7 +6,7 @@ namespace UnityEditor.Rendering
     //Make CoreBuildData constructed and kept till end of build
     class CorePreprocessBuild : IPreprocessBuildWithReport, IPostprocessBuildWithReport
     {
-        int IOrderedCallback.callbackOrder => -1;
+        int IOrderedCallback.callbackOrder => int.MinValue + 50;
 
         private static CoreBuildData m_BuildData = null;
 
@@ -22,4 +22,4 @@ void IPostprocessBuildWithReport.OnPostprocessBuild(BuildReport report)
             m_BuildData = null;
         }
     }
-}
+}

Packages/com.unity.render-pipelines.core/Editor/Gizmo/HierarchicalBox.cs

@@ -190,7 +190,7 @@ public HierarchicalBox(Color baseColor, Color[] polychromeHandleColors = null, H
         public void DrawHull(bool filled)
         {
             Color previousColor = Handles.color;
-            if (filled)
+            if (filled && Event.current.type == EventType.Repaint)
             {
                 // Draw the hull
                 var xSize = new Vector3(size.z, size.y, 1f);

Packages/com.unity.render-pipelines.core/Editor/Lighting/ProbeVolume/ProbeAdjustmentVolumeEditor.cs

@@ -274,10 +274,11 @@ static void DrawBakingHelpers(SerializedProbeAdjustmentVolume p, Editor owner)
                 if (owner.targets.Length == 1)
                 {
                     EditorGUILayout.Space();
-                    using (new EditorGUI.DisabledScope(bakingSet == null))
+                    using (new EditorGUI.DisabledScope(Lightmapping.isRunning || bakingSet == null))
                     {
-                        if (GUILayout.Button(Styles.s_PreviewLighting))
-                            AdaptiveProbeVolumes.BakeAdjustmentVolume(bakingSet, ptv);
+                        using (new EditorGUI.DisabledScope(AdaptiveProbeVolumes.isRunning))
+                            if (GUILayout.Button(Styles.s_PreviewLighting))
+                                AdaptiveProbeVolumes.BakeAdjustmentVolume(bakingSet, ptv);
 
                         ProbeVolumeLightingTab.BakeAPVButton();
                     }

Packages/com.unity.render-pipelines.core/Editor/Lighting/ProbeVolume/ProbeGIBaking.Dilate.cs

@@ -172,6 +172,18 @@ public void Dispose()
         static readonly int _NeedDilating = Shader.PropertyToID("_NeedDilating");
         static readonly int _DilationParameters = Shader.PropertyToID("_DilationParameters");
         static readonly int _OutputProbes = Shader.PropertyToID("_OutputProbes");
+        
+        // We need to keep the original list of cells that were actually baked to feed it to the dilation process.
+        // This is because during partial bake we only want to dilate those cells.
+        static Dictionary<int, BakingCell> m_CellsToDilate = new Dictionary<int, BakingCell>();
+        static Dictionary<Vector3Int, int> m_CellPosToIndex = new Dictionary<Vector3Int, int>();
+
+        // Free up dilation related data
+        static internal void FinalizeDilation()
+        {
+            m_CellPosToIndex.Clear();
+            m_CellsToDilate.Clear();
+        }
 
         // Can definitively be optimized later on.
         // Also note that all the bookkeeping of all the reference volumes will likely need to change when we move to

Packages/com.unity.render-pipelines.core/Editor/Lighting/ProbeVolume/ProbeGIBaking.LightTransport.cs

@@ -117,6 +117,13 @@ public override bool Step()
                     context.Dispose();
                 }
 
+                // Fixup lighting for probes part of bricks with different subdivision levels
+                // When baking reflection probes, we want to skip this step
+                if (m_BakingBatch != null)
+                {
+                    FixSeams(s_BakeData.positionRemap, positions, irradiance, validity);
+                }
+
                 return true;
             }
 

Packages/com.unity.render-pipelines.core/Editor/Lighting/ProbeVolume/ProbeGIBaking.Placement.cs

@@ -170,7 +170,6 @@ static NativeList<Vector3> ApplySubdivisionResults(ProbeSubdivisionResult result
             BakingSetupProfiling.GetProgressRange(out float progress0, out float progress1);
 
             var positions = new NativeList<Vector3>(Allocator.Persistent);
-            Dictionary<int, int> positionToIndex = new();
             foreach ((var position, var bounds, var bricks) in results.cells)
             {
                 if (++cellIdx % freq == 0)
@@ -179,7 +178,7 @@ static NativeList<Vector3> ApplySubdivisionResults(ProbeSubdivisionResult result
                 int positionStart = positions.Length;
 
                 ConvertBricksToPositions(bricks, out var probePositions, out var brickSubdivLevels);
-                DeduplicateProbePositions(in probePositions, in brickSubdivLevels, positionToIndex, m_BakingBatch, positions, out var probeIndices);
+                DeduplicateProbePositions(in probePositions, in brickSubdivLevels, m_BakingBatch, positions, out var probeIndices);
 
                 BakingCell cell = new BakingCell()
                 {
@@ -198,19 +197,19 @@ static NativeList<Vector3> ApplySubdivisionResults(ProbeSubdivisionResult result
             return positions;
         }
 
-        private static void DeduplicateProbePositions(in Vector3[] probePositions, in int[] brickSubdivLevel, Dictionary<int, int> positionToIndex, BakingBatch batch,
+        private static void DeduplicateProbePositions(in Vector3[] probePositions, in int[] brickSubdivLevel, BakingBatch batch,
             NativeList<Vector3> uniquePositions, out int[] indices)
         {
             indices = new int[probePositions.Length];
-            int uniqueIndex = positionToIndex.Count;
+            int uniqueIndex = batch.positionToIndex.Count;
 
             for (int i = 0; i < probePositions.Length; i++)
             {
                 var pos = probePositions[i];
                 var brickSubdiv = brickSubdivLevel[i];
                 int probeHash = batch.GetProbePositionHash(pos);
 
-                if (positionToIndex.TryGetValue(probeHash, out var index))
+                if (batch.positionToIndex.TryGetValue(probeHash, out var index))
                 {
                     indices[i] = index;
                     int oldBrickLevel = batch.uniqueBrickSubdiv[probeHash];
@@ -219,7 +218,7 @@ private static void DeduplicateProbePositions(in Vector3[] probePositions, in in
                 }
                 else
                 {
-                    positionToIndex[probeHash] = uniqueIndex;
+                    batch.positionToIndex[probeHash] = uniqueIndex;
                     indices[i] = uniqueIndex;
                     batch.uniqueBrickSubdiv[probeHash] = brickSubdiv;
                     uniquePositions.Add(pos);

Packages/com.unity.render-pipelines.core/Editor/Lighting/ProbeVolume/ProbeGIBaking.RenderingLayers.cs

@@ -58,7 +58,7 @@ class DefaultRenderingLayer : RenderingLayerBaker
             NativeArray<uint> layerMask;
 
             public override NativeArray<uint> renderingLayerMasks => layerMask;
-            
+
             CommandBuffer cmd;
             IRayTracingAccelStruct m_AccelerationStructure;
             GraphicsBuffer scratchBuffer;
@@ -141,7 +141,7 @@ public override bool Step()
             {
                 if (currentStep >= stepCount)
                     return true;
-                
+
                 var shader = s_TracingContext.shaderRL;
 
                 int batchOffset = batchIndex * k_MaxProbeCountPerBatch;
@@ -152,7 +152,7 @@ public override bool Step()
                 shader.SetVectorParam(cmd, _RenderingLayerMasks, regionMasks);
                 shader.SetBufferParam(cmd, _ProbePositions, probePositionsBuffer);
                 shader.SetBufferParam(cmd, _LayerMasks, layerMaskBuffer);
-                
+
                 shader.Dispatch(cmd, scratchBuffer, (uint)batchSize, 1, 1);
                 batchIndex++;
 

Packages/com.unity.render-pipelines.core/Editor/Lighting/ProbeVolume/ProbeGIBaking.SkyOcclusion.cs

@@ -40,10 +40,10 @@ public abstract class SkyOcclusionBaker : IDisposable
             /// Performs necessary tasks to free allocated resources.
             /// </summary>
             public abstract void Dispose();
-            
+
             internal NativeArray<uint> encodedDirections;
             internal void Encode() { encodedDirections = EncodeShadingDirection(shadingDirections); }
-            
+
             static int k_MaxProbeCountPerBatch = 65535;
             static readonly int _SkyShadingPrecomputedDirection = Shader.PropertyToID("_SkyShadingPrecomputedDirection");
             static readonly int _SkyShadingDirections = Shader.PropertyToID("_SkyShadingDirections");
@@ -71,7 +71,7 @@ internal static NativeArray<uint> EncodeShadingDirection(NativeArray<Vector3> di
                 {
                     int batchOffset = batchIndex * k_MaxProbeCountPerBatch;
                     int probeInBatch = Mathf.Min(probeCount - batchOffset, k_MaxProbeCountPerBatch);
-                    
+
                     directionBuffer.SetData(directions, batchOffset, 0, probeInBatch);
 
                     cs.SetBuffer(kernel, _SkyShadingPrecomputedDirection, precomputedShadingDirections);
@@ -84,7 +84,7 @@ internal static NativeArray<uint> EncodeShadingDirection(NativeArray<Vector3> di
                     var batchResult = directionResults.GetSubArray(batchOffset, probeInBatch);
                     AsyncGPUReadback.RequestIntoNativeArray(ref batchResult, encodedBuffer, probeInBatch * sizeof(uint), 0).WaitForCompletion();
                 }
-                
+
                 directionBuffer.Dispose();
                 encodedBuffer.Dispose();