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

Internal/master

Author: UnityAljosha

Packages/com.unity.render-pipelines.core/Editor/Icons/RenderGraphViewer/[email protected]

@@ -35,6 +35,7 @@ internal static class Styles
 
             internal static readonly GUIContent s_Mode = new GUIContent("Mode", "Choose which type of adjustment to apply to probes covered by this volume.");
             internal static readonly GUIContent s_DilationThreshold = new GUIContent("Dilation Validity Threshold", "Override the Dilation Validity Threshold for probes covered by this Probe Adjustment Volume. Higher values increase the chance of probes being considered invalid.");
+            internal static readonly GUIContent virtualOffsetThreshold = new GUIContent("Validity Threshold", "Override the Virtual Offset Validity Threshold for probes covered by this Probe Adjustment Volume. Higher values increase the chance of probes being considered invalid.");
             internal static readonly GUIContent s_VODirection = new GUIContent("Direction", "Rotate the axis along which probes will be pushed when applying Virtual Offset.");
             internal static readonly GUIContent s_VODistance = new GUIContent("Distance", "Determines how far probes are pushed in the direction of the Virtual Offset.");
             internal static readonly GUIContent s_PreviewLighting = new GUIContent("Preview Probe Adjustments", "Quickly preview the effect of adjustments on probes covered by this volume.");
@@ -175,6 +176,7 @@ public static void DrawAdjustmentContent(SerializedProbeAdjustmentVolume seriali
                 else if (serialized.mode.intValue == (int)ProbeAdjustmentVolume.Mode.OverrideVirtualOffsetSettings)
                 {
                     EditorGUI.BeginDisabledGroup(!useVirtualOffset);
+                    EditorGUILayout.PropertyField(serialized.virtualOffsetThreshold, Styles.virtualOffsetThreshold);
                     EditorGUILayout.PropertyField(serialized.geometryBias);
                     EditorGUILayout.PropertyField(serialized.rayOriginBias);
                     EditorGUI.EndDisabledGroup();

Packages/com.unity.render-pipelines.core/Editor/Icons/RenderGraphViewer/[email protected]

@@ -23,7 +23,7 @@ struct ProbeData
                 public float tMax;
                 public float geometryBias;
                 public int probeIndex;
-                internal float _;
+                public float validityThreshold;
             };
 
             int batchPosIdx;
@@ -35,6 +35,7 @@ struct ProbeData
             float scaleForSearchDist;
             float rayOriginBias;
             float geometryBias;
+            float validityThreshold;
 
             // Output buffer
             public Vector3[] offsets;
@@ -57,6 +58,7 @@ public void Initialize(ProbeVolumeBakingSet bakingSet, NativeList<Vector3> probe
                 scaleForSearchDist = voSettings.searchMultiplier;
                 rayOriginBias = voSettings.rayOriginBias;
                 geometryBias = voSettings.outOfGeoOffset;
+                validityThreshold = voSettings.validityThreshold;
 
                 offsets = new Vector3[probePositions.Length];
                 cellToVolumes = GetTouchupsPerCell(out bool hasAppliers);
@@ -137,7 +139,6 @@ public bool RunVirtualOffsetStep()
                 if (currentStep >= stepCount)
                     return true;
 
-                float cellSize = m_ProfileInfo.cellSizeInMeters;
                 float minBrickSize = m_ProfileInfo.minBrickSize;
 
                 // Prepare batch
@@ -149,15 +150,14 @@ public bool RunVirtualOffsetStep()
                     var searchDistance = (brickSize * minBrickSize) / ProbeBrickPool.kBrickCellCount;
                     var distanceSearch = scaleForSearchDist * searchDistance;
 
-                    int cellIndex = PosToIndex(Vector3Int.FloorToInt(positions[batchPosIdx] / cellSize));
+                    int cellIndex = PosToIndex(m_ProfileInfo.PositionToCell(positions[batchPosIdx]));
                     if (cellToVolumes.TryGetValue(cellIndex, out var volumes))
                     {
                         bool adjusted = false;
                         foreach (var (touchup, obb, center, offset) in volumes.appliers)
                         {
                             if (touchup.ContainsPoint(obb, center, positions[batchPosIdx]))
                             {
-                                positions[batchPosIdx] += offset;
                                 offsets[batchPosIdx] = offset;
                                 adjusted = true;
                                 break;
@@ -173,6 +173,7 @@ public bool RunVirtualOffsetStep()
                             {
                                 rayOriginBias = touchup.rayOriginBias;
                                 geometryBias = touchup.geometryBias;
+                                validityThreshold = 1.0f - touchup.virtualOffsetThreshold;
                                 break;
                             }
                         }
@@ -184,6 +185,7 @@ public bool RunVirtualOffsetStep()
                         originBias = rayOriginBias,
                         tMax = distanceSearch,
                         geometryBias = geometryBias,
+                        validityThreshold = validityThreshold,
                         probeIndex = batchPosIdx,
                     };
                 }
@@ -240,7 +242,7 @@ static internal void RecomputeVOForDebugOnly()
                 return;
 
             globalBounds = prv.globalBounds;
-            CellCountInDirections(out minCellPosition, out maxCellPosition, prv.MaxBrickSize());
+            CellCountInDirections(out minCellPosition, out maxCellPosition, prv.MaxBrickSize(), prv.ProbeOffset());
             cellCount = maxCellPosition + Vector3Int.one - minCellPosition;
 
             m_BakingBatch = new BakingBatch(cellCount);
@@ -343,9 +345,7 @@ struct TouchupsPerCell
 
         static Dictionary<int, TouchupsPerCell> GetTouchupsPerCell(out bool hasAppliers)
         {
-            float cellSize = m_ProfileInfo.cellSizeInMeters;
             hasAppliers = false;
-
             var adjustmentVolumes = s_AdjustmentVolumes != null ? s_AdjustmentVolumes : GetAdjustementVolumes();
 
             Dictionary<int, TouchupsPerCell> cellToVolumes = new();
@@ -358,8 +358,8 @@ static Dictionary<int, TouchupsPerCell> GetTouchupsPerCell(out bool hasAppliers)
 
                 hasAppliers |= mode == ProbeAdjustmentVolume.Mode.ApplyVirtualOffset;
 
-                Vector3Int min = Vector3Int.FloorToInt(adjustment.aabb.min / cellSize);
-                Vector3Int max = Vector3Int.FloorToInt(adjustment.aabb.max / cellSize);
+                Vector3Int min = m_ProfileInfo.PositionToCell(adjustment.aabb.min);
+                Vector3Int max = m_ProfileInfo.PositionToCell(adjustment.aabb.max);
 
                 for (int x = min.x; x <= max.x; x++)
                 {
@@ -386,17 +386,15 @@ static Dictionary<int, TouchupsPerCell> GetTouchupsPerCell(out bool hasAppliers)
 
         static Vector3[] DoApplyVirtualOffsetsFromAdjustmentVolumes(NativeList<Vector3> positions, Vector3[] offsets, Dictionary<int, TouchupsPerCell> cellToVolumes)
         {
-            float cellSize = m_ProfileInfo.cellSizeInMeters;
             for (int i = 0; i < positions.Length; i++)
             {
-                int cellIndex = PosToIndex(Vector3Int.FloorToInt(positions[i] / cellSize));
+                int cellIndex = PosToIndex(m_ProfileInfo.PositionToCell(positions[i]));
                 if (cellToVolumes.TryGetValue(cellIndex, out var volumes))
                 {
                     foreach (var (touchup, obb, center, offset) in volumes.appliers)
                     {
                         if (touchup.ContainsPoint(obb, center, positions[i]))
                         {
-                            positions[i] += offset;
                             offsets[i] = offset;
                             break;
                         }

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

@@ -234,6 +234,7 @@ class BakingBatch
         // Utilities to compute unique probe position hash
         Vector3Int maxBrickCount;
         float inverseScale;
+        Vector3 offset;
 
         public Dictionary<(int, int), float> customDilationThresh = new Dictionary<(int, int), float>();
         public Dictionary<Vector3, Bounds> forceInvalidatedProbesAndTouchupVols = new Dictionary<Vector3, Bounds>();
@@ -255,11 +256,12 @@ public BakingBatch(Vector3Int cellCount)
         {
             maxBrickCount = cellCount * ProbeReferenceVolume.CellSize(ProbeReferenceVolume.instance.GetMaxSubdivision());
             inverseScale = ProbeBrickPool.kBrickCellCount / ProbeReferenceVolume.instance.MinBrickSize();
+            offset = ProbeReferenceVolume.instance.ProbeOffset();
         }
 
         public int GetProbePositionHash(Vector3 position)
         {
-            var brickPosition = Vector3Int.RoundToInt(position * inverseScale);
+            var brickPosition = Vector3Int.RoundToInt((position - offset) * inverseScale); // Inverse of op in ConvertBricksToPositions()
             return brickPosition.x + brickPosition.y * maxBrickCount.x + brickPosition.z * maxBrickCount.x * maxBrickCount.y;
         }
 
@@ -270,11 +272,14 @@ class ProbeVolumeProfileInfo
     {
         public int simplificationLevels;
         public float minDistanceBetweenProbes;
+        public Vector3 probeOffset;
 
         public int maxSubdivision => ProbeVolumeBakingSet.GetMaxSubdivision(simplificationLevels);
         public float minBrickSize => ProbeVolumeBakingSet.GetMinBrickSize(minDistanceBetweenProbes);
         public int cellSizeInBricks => ProbeVolumeBakingSet.GetCellSizeInBricks(simplificationLevels);
         public float cellSizeInMeters => (float)cellSizeInBricks * minBrickSize;
+
+        public Vector3Int PositionToCell(Vector3 position) => Vector3Int.FloorToInt((position - probeOffset) / cellSizeInMeters);
     }
 
     /// <summary>
@@ -712,6 +717,7 @@ static ProbeVolumeProfileInfo GetProfileInfoFromBakingSet(ProbeVolumeBakingSet s
             var result = new ProbeVolumeProfileInfo();
             result.minDistanceBetweenProbes = set.minDistanceBetweenProbes;
             result.simplificationLevels = set.simplificationLevels;
+            result.probeOffset = set.probeOffset;
             return result;
         }
 
@@ -756,7 +762,7 @@ static bool InitializeBake()
             }
 
             // Get min/max
-            CellCountInDirections(out minCellPosition, out maxCellPosition, m_ProfileInfo.cellSizeInMeters);
+            CellCountInDirections(out minCellPosition, out maxCellPosition, m_ProfileInfo.cellSizeInMeters, m_ProfileInfo.probeOffset);
             cellCount = maxCellPosition + Vector3Int.one - minCellPosition;
 
             ProbeReferenceVolume.instance.EnsureCurrentBakingSet(m_BakingSet);
@@ -789,14 +795,13 @@ static void OnBakeStarted()
             }
         }
 
-        static void CellCountInDirections(out Vector3Int minCellPositionXYZ, out Vector3Int maxCellPositionXYZ, float cellSizeInMeters)
+        static void CellCountInDirections(out Vector3Int minCellPositionXYZ, out Vector3Int maxCellPositionXYZ, float cellSizeInMeters, Vector3 worldOffset)
         {
             minCellPositionXYZ = Vector3Int.zero;
             maxCellPositionXYZ = Vector3Int.zero;
 
-            Vector3 center = Vector3.zero;
-            var centeredMin = globalBounds.min - center;
-            var centeredMax = globalBounds.max - center;
+            var centeredMin = globalBounds.min - worldOffset;
+            var centeredMax = globalBounds.max - worldOffset;
 
             minCellPositionXYZ.x = Mathf.FloorToInt(centeredMin.x / cellSizeInMeters);
             minCellPositionXYZ.y = Mathf.FloorToInt(centeredMin.y / cellSizeInMeters);
@@ -1209,7 +1214,7 @@ static void ApplyPostBakeOperations(NativeArray<SphericalHarmonicsL2> sh, Native
 
             // Make sure all pending operations are done (needs to be after the Clear to unload all previous scenes)
             probeRefVolume.PerformPendingOperations();
-            probeRefVolume.SetMinBrickAndMaxSubdiv(m_ProfileInfo.minBrickSize, m_ProfileInfo.maxSubdivision);
+            probeRefVolume.SetSubdivisionDimensions(m_ProfileInfo.minBrickSize, m_ProfileInfo.maxSubdivision, m_ProfileInfo.probeOffset);
 
             // Use the globalBounds we just computed, as the one in probeRefVolume doesn't include scenes that have never been baked
             probeRefVolume.globalBounds = globalBounds;
@@ -1702,6 +1707,7 @@ unsafe static void WriteBakingCells(BakingCell[] bakingCells)
             m_BakingSet.cellDescs = new SerializedDictionary<int, CellDesc>();
             m_BakingSet.bakedMinDistanceBetweenProbes = m_ProfileInfo.minDistanceBetweenProbes;
             m_BakingSet.bakedSimplificationLevels = m_ProfileInfo.simplificationLevels;
+            m_BakingSet.bakedProbeOffset = m_ProfileInfo.probeOffset;
             m_BakingSet.bakedSkyOcclusion = m_BakingSet.skyOcclusion;
             m_BakingSet.bakedSkyShadingDirection = m_BakingSet.bakedSkyOcclusion && m_BakingSet.skyOcclusionShadingDirection;
 
@@ -2133,7 +2139,8 @@ static NativeList<Vector3> RunPlacement(Span<BakeJob> jobs)
             // Overwrite loaded settings with data from profile. Note that the m_BakingSet.profile is already patched up if isFreezingPlacement
             float prevBrickSize = ProbeReferenceVolume.instance.MinBrickSize();
             int prevMaxSubdiv = ProbeReferenceVolume.instance.GetMaxSubdivision();
-            ProbeReferenceVolume.instance.SetMinBrickAndMaxSubdiv(m_ProfileInfo.minBrickSize, m_ProfileInfo.maxSubdivision);
+            Vector3 prevOffset = ProbeReferenceVolume.instance.ProbeOffset();
+            ProbeReferenceVolume.instance.SetSubdivisionDimensions(m_ProfileInfo.minBrickSize, m_ProfileInfo.maxSubdivision, m_ProfileInfo.probeOffset);
 
             // All probes need to be baked only once for the whole batch and not once per cell
             // The reason is that the baker is not deterministic so the same probe position baked in two different cells may have different values causing seams artefacts.
@@ -2150,7 +2157,7 @@ static NativeList<Vector3> RunPlacement(Span<BakeJob> jobs)
                 positions = ApplySubdivisionResults(result, jobs);
 
             // Restore loaded asset settings
-            ProbeReferenceVolume.instance.SetMinBrickAndMaxSubdiv(prevBrickSize, prevMaxSubdiv);
+            ProbeReferenceVolume.instance.SetSubdivisionDimensions(prevBrickSize, prevMaxSubdiv, prevOffset);
 
             return positions;
         }
@@ -2271,6 +2278,7 @@ static void ModifyProfileFromLoadedData(ProbeVolumeBakingSet bakingSet)
         {
             m_ProfileInfo.simplificationLevels = bakingSet.bakedSimplificationLevels;
             m_ProfileInfo.minDistanceBetweenProbes = bakingSet.bakedMinDistanceBetweenProbes;
+            m_ProfileInfo.probeOffset = bakingSet.bakedProbeOffset;
             globalBounds = bakingSet.globalBounds;
         }
 
@@ -2279,6 +2287,7 @@ internal static void ConvertBricksToPositions(Brick[] bricks, out Vector3[] outP
         {
             int posIdx = 0;
             float scale = ProbeReferenceVolume.instance.MinBrickSize() / ProbeBrickPool.kBrickCellCount;
+            Vector3 offset = ProbeReferenceVolume.instance.ProbeOffset();
 
             outProbePositions = new Vector3[bricks.Length * ProbeBrickPool.kBrickProbeCountTotal];
             outBrickSubdiv = new int[bricks.Length * ProbeBrickPool.kBrickProbeCountTotal];
@@ -2296,7 +2305,7 @@ internal static void ConvertBricksToPositions(Brick[] bricks, out Vector3[] outP
                         {
                             var probeOffset = brickOffset + new Vector3Int(x, y, z) * brickSize;
 
-                            outProbePositions[posIdx] = (Vector3)probeOffset * scale;
+                            outProbePositions[posIdx] = offset + (Vector3)probeOffset * scale;
                             outBrickSubdiv[posIdx] = b.subdivisionLevel;
 
                             posIdx++;

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

@@ -331,6 +331,7 @@ static void SubdivideSubCell(Bounds cellAABB, ProbeSubdivisionContext subdivisio
             }
 
             float minBrickSize = subdivisionCtx.profile.minBrickSize;
+            var cellOffset = subdivisionCtx.profile.probeOffset;
 
             var cmd = CommandBufferPool.Get($"Subdivide (Sub)Cell {cellAABB.center}");
 
@@ -356,7 +357,8 @@ static void SubdivideSubCell(Bounds cellAABB, ProbeSubdivisionContext subdivisio
             VoxelizeProbeVolumeData(cmd, cellAABB, probeVolumes, ctx);
 
             // Find the maximum subdivision level we can have in this cell (avoid extra work if not needed)
-            int startSubdivisionLevel = Mathf.Max(0, ctx.maxSubdivisionLevelInSubCell - GetMaxSubdivision(ctx, probeVolumes.Max(p => p.component.GetMaxSubdivMultiplier())));
+            int globalMaxSubdiv = ProbeVolumeBakingSet.GetMaxSubdivision(ctx.maxSubdivisionLevel);
+            int startSubdivisionLevel = Mathf.Max(0, ctx.maxSubdivisionLevelInSubCell - GetMaxSubdivision(ctx, probeVolumes.Max(p => p.component.GetMaxSubdivMultiplier(globalMaxSubdiv))));
             for (int subdivisionLevel = startSubdivisionLevel; subdivisionLevel <= ctx.maxSubdivisionLevelInSubCell; subdivisionLevel++)
             {
                 // Add the bricks from the probe volume min subdivision level:
@@ -372,7 +374,7 @@ static void SubdivideSubCell(Bounds cellAABB, ProbeSubdivisionContext subdivisio
                 }
 
                 // Generate the list of bricks on the GPU
-                SubdivideFromDistanceField(cmd, cellAABB, ctx, probeSubdivisionData, bricksBuffer, brickCountPerAxis, subdivisionLevel, minBrickSize);
+                SubdivideFromDistanceField(cmd, cellAABB, ctx, probeSubdivisionData, bricksBuffer, brickCountPerAxis, subdivisionLevel, minBrickSize, cellOffset);
 
                 cmd.CopyCounterValue(bricksBuffer, brickCountReadbackBuffer, 0);
                 // Capture locally the subdivision level to use it inside the lambda
@@ -585,8 +587,9 @@ static void VoxelizeProbeVolumeData(CommandBuffer cmd, Bounds cellAABB,
                 // Prepare list of GPU probe volumes
                 foreach (var kp in probeVolumes)
                 {
-                    int minSubdiv = GetMaxSubdivision(ctx, kp.component.GetMinSubdivMultiplier());
-                    int maxSubdiv = GetMaxSubdivision(ctx, kp.component.GetMaxSubdivMultiplier());
+                    int globalMaxSubdiv = ProbeVolumeBakingSet.GetMaxSubdivision(ctx.maxSubdivisionLevel);
+                    int minSubdiv = GetMaxSubdivision(ctx, kp.component.GetMinSubdivMultiplier(globalMaxSubdiv));
+                    int maxSubdiv = GetMaxSubdivision(ctx, kp.component.GetMaxSubdivMultiplier(globalMaxSubdiv));
 
                     // Constrain the probe volume AABB inside the cell
                     var pvAABB = kp.bounds;
@@ -630,13 +633,13 @@ static void VoxelizeProbeVolumeData(CommandBuffer cmd, Bounds cellAABB,
 
         static void SubdivideFromDistanceField(
             CommandBuffer cmd, Bounds volume, GPUSubdivisionContext ctx, RenderTexture probeVolumeData,
-            ComputeBuffer buffer, int brickCount, int subdivisionLevel, float minBrickSize)
+            ComputeBuffer buffer, int brickCount, int subdivisionLevel, float minBrickSize, Vector3 cellOffset)
         {
             using (new ProfilingScope(cmd, new ProfilingSampler($"Subdivide Bricks at level {Mathf.Log(brickCount, 3)}")))
             {
                 // We convert the world space volume position (of a corner) in bricks.
                 // This is necessary to have correct brick position (the position calculated in the compute shader needs to be in number of bricks from the reference volume (origin)).
-                Vector3 volumeBrickPosition = (volume.center - volume.extents) / minBrickSize;
+                Vector3 volumeBrickPosition = (volume.center - volume.extents - cellOffset) / minBrickSize;
                 cmd.SetComputeVectorParam(subdivideSceneCS, _VolumeOffsetInBricks, volumeBrickPosition);
                 cmd.SetComputeBufferParam(subdivideSceneCS, s_SubdivideKernel, _Bricks, buffer);
                 cmd.SetComputeVectorParam(subdivideSceneCS, _MaxBrickSize, Vector3.one * brickCount);