Internal/6000.3/staging

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

@@ -36,6 +36,7 @@
   * [Customize the UI of a setting](customize-ui-for-a-setting.md)
   * [Get custom graphics settings](get-custom-graphics-settings.md)
   * [Include or exclude a setting in your build](choose-whether-unity-includes-a-graphics-setting-in-your-build.md)
+  * [Advanced Properties](advanced-properties.md)
 * [Shaders](shaders.md)
   * [Use shader methods from the SRP Core shader library](built-in-shader-methods.md)
   * [Synchronizing shader code and C#](generating-shader-includes.md)

Packages/com.unity.render-pipelines.core/Documentation~/advanced-properties.md

@@ -12,29 +12,29 @@ There is a global state per user that stores if Unity displays **advanced proper
 ## Exposing advanced properties within the inspector
 
 Not every component or Volume Override includes advanced properties.
-If one does, it has a contextual menu to the right of each property section header that includes additional properties. To expose advanced properties for that section, open the contextual menu and click **Advanced Properties**.
+If one does, it has a contextual menu to the right of each property section header that includes additional properties. To expose advanced properties for that section, open the contextual menu and click **Show All Advanced Properties**.
 
 For an example, refer to the **Water Surface** component in [High Definition Render Pipeline (HDRP)](https://docs.unity3d.com/Packages/com.unity.render-pipelines.high-definition@latest?subfolder=/manual/settings-and-properties-related-to-the-water-system.html).
 
 By default only standard properties are shown.
 
 ![](Images/Preferences/HDRP_WaterSurface_General.png)
 
-When you select **Advanced Properties**:
+When you select **Show All Advanced Properties**:
 
 ![](Images/Preferences/PopUpAdvanced.png)
 
 **Advanced Properties** become visible:
 
 ![](Images/Preferences/HDRP_WaterSurface_General_Visible.png)
 
-For Volume Overrides, the already existing contextual menu has a **Advanced Properties** toggle as well.
+For Volume Overrides, the already existing contextual menu has a **Show All Advanced Properties** toggle as well.
 
 ## Exposing advanced properties on preferences
 
 You can also access to this global preference by:
 
-1. Open the **Graphics** tab in the **Preferences** window (menu: **Edit > Preferences > Graphics**).
-2. Under **Properties**. Set **Advanced Properties** to **All Visible**.
+1. Open the **Graphics** tab in the **Preferences** window (menu: **Edit > Preferences**, macOS: **Unity > Settings**).
+2. Under **Graphics**, select **Properties**. Set **Advanced Properties** to **All Visible**.
 
 ![](Images/Preferences/AdvancedProperties_Settings.png)

Packages/com.unity.render-pipelines.core/Editor/AssemblyInfo.cs

@@ -4,6 +4,5 @@
 [assembly: InternalsVisibleTo("Unity.RenderPipelines.Core.Editor.Tests")]
 [assembly: InternalsVisibleTo("Unity.RenderPipelines.HighDefinition.Editor.Tests")]
 [assembly: InternalsVisibleTo("Unity.RenderPipelines.Universal.Editor.Tests")]
-[assembly: InternalsVisibleTo("Unity.Testing.VisualEffectGraph.EditorTests")]
 [assembly: InternalsVisibleTo("Assembly-CSharp-Editor-testable")]
 

Packages/com.unity.render-pipelines.core/Editor/Debugging/DebugWindow.cs

@@ -30,7 +30,7 @@ public int selectedPanel
             get => Mathf.Max(0, DebugManager.instance.PanelIndex(selectedPanelDisplayName));
             set
             {
-                var displayName = DebugManager.instance.PanelDiplayName(value);
+                var displayName = DebugManager.instance.PanelDisplayName(value);
                 if (!string.IsNullOrEmpty(displayName))
                     selectedPanelDisplayName = displayName;
             }

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

@@ -116,6 +116,9 @@ static AccelStructAdapter BuildAccelerationStructure()
                     if (mesh == null)
                         continue;
 
+                    if (renderer.component is SkinnedMeshRenderer)
+                        continue;
+
                     int subMeshCount = mesh.subMeshCount;
                     var matIndices = new uint[subMeshCount];
                     Array.Fill(matIndices, renderer.component.renderingLayerMask); // repurpose the material id as we don't need it here

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

@@ -213,6 +213,9 @@ static AccelStructAdapter BuildAccelerationStructure()
                     if (!s_TracingContext.TryGetMeshForAccelerationStructure(renderer.component, out var mesh))
                         continue;
 
+                    if (renderer.component is SkinnedMeshRenderer)
+                        continue;
+
                     int subMeshCount = mesh.subMeshCount;
                     var matIndices = GetMaterialIndices(renderer.component);
                     var perSubMeshMask = new uint[subMeshCount];

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

@@ -140,6 +140,9 @@ static AccelStructAdapter BuildAccelerationStructure(int mask)
                     if (!s_TracingContext.TryGetMeshForAccelerationStructure(renderer.component, out var mesh))
                         continue;
 
+                    if (renderer.component is SkinnedMeshRenderer)
+                        continue;
+
                     int subMeshCount = mesh.subMeshCount;
                     var maskAndMatDummy = new uint[subMeshCount];
                     System.Array.Fill(maskAndMatDummy, 0xFFFFFFFF);

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

@@ -1162,6 +1162,21 @@ static void BakeDelegate(ref float progress, ref bool done)
             }
         }
 
+        // Required by native side.
+        [Scripting.Preserve]
+        static bool CurrentSceneHasBakedData()
+        {
+            if (!ProbeReferenceVolume.instance.isInitialized || !ProbeReferenceVolume.instance.enabledBySRP)
+                return false;
+
+            string sceneGUID = SceneManager.GetActiveScene().GetGUID();
+            ProbeReferenceVolume.instance.TryGetPerSceneData(sceneGUID, out var sceneData);
+            if (sceneData == null || sceneData.bakingSet == null)
+                return false;
+
+            return sceneData.bakingSet.HasBeenBaked();
+        }
+
         static void FinalizeBake(bool cleanup = true)
         {
             using (new BakingCompleteProfiling(BakingCompleteProfiling.Stages.FinalizingBake))

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

@@ -77,11 +77,24 @@ IEnumerator Subdivide(bool showProgress)
                         var ctx = AdaptiveProbeVolumes.PrepareProbeSubdivisionContext(perSceneDataList, true);
                         var contributors = GIContributors.Find(GIContributors.ContributorFilter.All);
 
+                        var cullCtx = new ProbeVolume.CellCullingContext
+                        {
+                            ActiveCamera = null,
+                            FrustumPlanes = stackalloc Plane[6]
+                        };
+                        ProbeVolume.PrepareCellCulling(ref cullCtx);
+
+                        var sceneToBakingSetMap = ProbeVolumeBakingSet.SceneToBakingSet.Instance;
+                        var probeRefVol = ProbeReferenceVolume.instance;
+
                         // Cull all the cells that are not visible (we don't need them for realtime debug)
-                        ctx.cells.RemoveAll(c =>
+                        for (int i = ctx.cells.Count - 1; i >= 0; i--)
                         {
-                            return probeVolume.ShouldCullCell(c.position);
-                        });
+                            var cell = ctx.cells[i];
+                            bool shouldRemove = probeVolume.ShouldCullCell(cullCtx, sceneToBakingSetMap, probeRefVol, cell.position);
+                            if (shouldRemove)
+                                ctx.cells.RemoveAt(i);
+                        }
 
                         Camera activeCamera = Camera.current ?? SceneView.lastActiveSceneView.camera;
 

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

@@ -0,0 +1,210 @@
+using System.Collections.Generic;
+using UnityEditor;
+
+namespace UnityEngine.Rendering
+{
+    internal static class ProbeVolumeGizmos
+    {
+        static MeshGizmo _brickMeshGizmo;
+        static MeshGizmo _cellMeshGizmo;
+        static double _lastDrawAt = 0;
+
+        static readonly string _gizmoPath = "Packages/com.unity.render-pipelines.core/Editor/Resources/Gizmos";
+        static readonly string _probeAdjustmentVolumeIconPath = _gizmoPath + "/ProbeTouchupVolume.png";
+        static readonly string _probeVolumeIconPath = _gizmoPath + "/ProbeVolume.png";
+
+        static ProbeVolumeGizmos()
+        {
+            EditorApplication.update += Update;
+        }
+
+        static void Update()
+        {
+            bool resourcesAllocated = _brickMeshGizmo != null || _cellMeshGizmo != null;
+
+            if (resourcesAllocated)
+            {
+                bool shouldCleanUp = EditorApplication.timeSinceStartup - _lastDrawAt > 1.0;
+                if (shouldCleanUp)
+                {
+                    _brickMeshGizmo?.Dispose();
+                    _brickMeshGizmo = null;
+                    _cellMeshGizmo?.Dispose();
+                    _cellMeshGizmo = null;
+                }
+            }
+        }
+
+        [DrawGizmo(GizmoType.Active | GizmoType.Selected | GizmoType.NonSelected)]
+        static void DrawProbeAdjustmentVolumes(ProbeAdjustmentVolume volume, GizmoType gizmoType)
+        {
+            Gizmos.DrawIcon(volume.transform.position, _probeAdjustmentVolumeIconPath, true);
+        }
+
+        [DrawGizmo(GizmoType.Active | GizmoType.Selected | GizmoType.NonSelected)]
+        static void DrawProbeVolumeGizmos(ProbeVolume volume, GizmoType gizmoType)
+        {
+            _lastDrawAt = EditorApplication.timeSinceStartup;
+
+            Gizmos.DrawIcon(volume.transform.position, _probeVolumeIconPath, true);
+
+            var probeRefVolume = ProbeReferenceVolume.instance;
+            var sceneToBakingSetMap = ProbeVolumeBakingSet.SceneToBakingSet.Instance;
+            var allVolumes = ProbeVolume.instances;
+
+            if (!probeRefVolume.isInitialized || allVolumes.Count == 0)
+                return;
+
+            // Only the first PV of the available ones will draw gizmos.
+            if (allVolumes[0] != volume)
+                return;
+
+            var debugDisplay = probeRefVolume.probeVolumeDebug;
+
+            float minBrickSize = probeRefVolume.MinBrickSize();
+            var cellSizeInMeters = probeRefVolume.MaxBrickSize();
+            var probeOffset = probeRefVolume.ProbeOffset() + ProbeVolumeDebug.currentOffset;
+            if (debugDisplay.realtimeSubdivision)
+            {
+                var bakingSet = ProbeVolumeBakingSet.GetBakingSetForScene(volume.gameObject.scene);
+                if (bakingSet == null)
+                    return;
+
+                // Overwrite settings with data from profile
+                minBrickSize = ProbeVolumeBakingSet.GetMinBrickSize(bakingSet.minDistanceBetweenProbes);
+                cellSizeInMeters = ProbeVolumeBakingSet.GetCellSizeInBricks(bakingSet.simplificationLevels) * minBrickSize;
+                probeOffset = bakingSet.probeOffset;
+            }
+
+            if (debugDisplay.drawBricks)
+            {
+                var subDivColors = probeRefVolume.subdivisionDebugColors;
+
+                if (_brickMeshGizmo == null)
+                    _brickMeshGizmo = new MeshGizmo((int)(Mathf.Pow(3, ProbeBrickIndex.kMaxSubdivisionLevels) * MeshGizmo.vertexCountPerCube));
+                _brickMeshGizmo.Clear();
+
+                if (debugDisplay.realtimeSubdivision)
+                {
+                    // realtime subdiv cells are already culled
+                    foreach (var kp in probeRefVolume.realtimeSubdivisionInfo)
+                    {
+                        var cellVolume = kp.Key;
+
+                        foreach (var brick in kp.Value)
+                            DrawAndAddBrick(_brickMeshGizmo, brick, minBrickSize, probeOffset, subDivColors);
+                    }
+                }
+                else
+                {
+                    var cullCtx = new ProbeVolume.CellCullingContext
+                    {
+                        ActiveCamera = null,
+                        FrustumPlanes = stackalloc Plane[6]
+                    };
+                    ProbeVolume.PrepareCellCulling(ref cullCtx);
+
+                    foreach (var cell in probeRefVolume.cells.Values)
+                    {
+                        if (!cell.loaded)
+                            continue;
+
+                        if (volume.ShouldCullCell(cullCtx, sceneToBakingSetMap, probeRefVolume, cell.desc.position))
+                            continue;
+
+                        if (cell.data.bricks == null)
+                            continue;
+
+                        foreach (var brick in cell.data.bricks)
+                            DrawAndAddBrick(_brickMeshGizmo, brick, minBrickSize, probeOffset, subDivColors);
+                    }
+                }
+
+                _brickMeshGizmo.RenderWireframe(Matrix4x4.identity, gizmoName: "Brick Gizmo Rendering");
+            }
+
+            if (debugDisplay.drawCells)
+            {
+                Color s_LoadedColor = new Color(0, 1, 0.5f, 0.2f);
+                Color s_UnloadedColor = new Color(1, 0.0f, 0.0f, 0.2f);
+                Color s_StreamingColor = new Color(0.0f, 0.0f, 1.0f, 0.2f);
+                Color s_LowScoreColor = new Color(0, 0, 0, 0.2f);
+                Color s_HighScoreColor = new Color(1, 1, 0, 0.2f);
+
+                var oldGizmoMatrix = Gizmos.matrix;
+                Gizmos.matrix = Matrix4x4.identity;
+
+                if (_cellMeshGizmo == null)
+                    _cellMeshGizmo = new MeshGizmo();
+                _cellMeshGizmo.Clear();
+
+                float minStreamingScore = probeRefVolume.minStreamingScore;
+                float streamingScoreRange = probeRefVolume.maxStreamingScore - probeRefVolume.minStreamingScore;
+
+                if (debugDisplay.realtimeSubdivision)
+                {
+                    foreach (var kp in probeRefVolume.realtimeSubdivisionInfo)
+                    {
+                        DrawAndAddCell(_cellMeshGizmo, kp.Key.center, s_LoadedColor, cellSizeInMeters);
+                    }
+                }
+                else
+                {
+                    var cullCtx = new ProbeVolume.CellCullingContext
+                    {
+                        ActiveCamera = null,
+                        FrustumPlanes = stackalloc Plane[6]
+                    };
+                    ProbeVolume.PrepareCellCulling(ref cullCtx);
+
+                    foreach (var cell in probeRefVolume.cells.Values)
+                    {
+                        if (volume.ShouldCullCell(cullCtx, sceneToBakingSetMap, probeRefVolume, cell.desc.position))
+                            continue;
+
+                        Color color;
+                        if (debugDisplay.displayCellStreamingScore)
+                        {
+                            float lerpFactor = (cell.streamingInfo.streamingScore - minStreamingScore) / streamingScoreRange;
+                            color = Color.Lerp(s_HighScoreColor, s_LowScoreColor, lerpFactor);
+                        }
+                        else
+                        {
+                            if (cell.streamingInfo.IsStreaming())
+                                color = s_StreamingColor;
+                            else
+                                color = cell.loaded ? s_LoadedColor : s_UnloadedColor;
+                        }
+
+                        var positionF = new Vector4(cell.desc.position.x, cell.desc.position.y, cell.desc.position.z, 0.0f);
+                        var center = (Vector4)probeOffset + positionF * cellSizeInMeters + cellSizeInMeters * 0.5f * Vector4.one;
+                        DrawAndAddCell(_cellMeshGizmo, center, color, cellSizeInMeters);
+                    }
+                }
+
+                _cellMeshGizmo.RenderWireframe(Gizmos.matrix, gizmoName: "Brick Gizmo Rendering");
+                Gizmos.matrix = oldGizmoMatrix;
+            }
+        }
+
+        static void DrawAndAddCell(MeshGizmo meshGizmo, Vector4 center, Color color, float cellSizeInMeters)
+        {
+            Gizmos.color = color;
+            Gizmos.DrawCube(center, Vector3.one * cellSizeInMeters);
+            var wireColor = color;
+            wireColor.a = 1.0f;
+            meshGizmo.AddWireCube(center, Vector3.one * cellSizeInMeters, wireColor);
+        }
+
+        static void DrawAndAddBrick(MeshGizmo meshGizmo, ProbeBrickIndex.Brick brick, float minBrickSize, Vector3 probeOffset, Color[] subDivColors)
+        {
+            if (brick.subdivisionLevel < 0)
+                return;
+
+            float brickSize = minBrickSize * ProbeReferenceVolume.CellSize(brick.subdivisionLevel);
+            Vector3 scaledSize = new Vector3(brickSize, brickSize, brickSize);
+            Vector3 scaledPos = probeOffset + new Vector3(brick.position.x * minBrickSize, brick.position.y * minBrickSize, brick.position.z * minBrickSize) + scaledSize / 2;
+            meshGizmo.AddWireCube(scaledPos, scaledSize, subDivColors[brick.subdivisionLevel]);
+        }
+    }
+}