[APV] Offset on probe positions at bake time

On very simple scenes with grid aligned objects (eg. see this [forum post](https://forum.unity.com/threads/adaptive-probe-volumes-apvs-experimental-release-for-hdrp-in-2021-2.1238824/page-16#post-9620177)), probe placement can be very suboptimal.

For example on this screenshot, a total of 8 cells are generated, and most of the probes are placed inside geometry
![image](https://media.github.cds.internal.unity3d.com/user/2154/files/45038237-d2a0-4e5f-94a0-02dc7f608d75)

Simply offsetting the cell placement without moving any geometry helps a lot
![image](https://media.github.cds.internal.unity3d.com/user/2154/files/3a420e12-bdd3-46a8-9e18-71b7ea5f1e81)

Only one cell gets generated and all probes are not inside geometry anymore
![image](https://media.github.cds.internal.unity3d.com/user/2154/files/50da4dde-4cc5-40eb-bd46-15f307113019)

Author: adrien-de-tocqueville

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

@@ -139,7 +139,6 @@ public bool RunVirtualOffsetStep()
                 if (currentStep >= stepCount)
                     return true;
 
-                float cellSize = m_ProfileInfo.cellSizeInMeters;
                 float minBrickSize = m_ProfileInfo.minBrickSize;
 
                 // Prepare batch
@@ -151,7 +150,7 @@ 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;
@@ -243,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);
@@ -346,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();
@@ -361,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++)
                 {
@@ -389,10 +386,9 @@ 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)

Packages/com.unity.render-pipelines.core/Editor/Lighting/ProbeVolume/ProbeGIBaking.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/ProbePlacement.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}");
 
@@ -373,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
@@ -632,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);

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

@@ -159,24 +159,23 @@ public void Initialize(ProbeVolumeBakingSet bakingSet, ProbeVolumeProfileInfo pr
             foreach (var pv in probeVolumes)
             {
                 // This method generates many cells outside of the probe volumes but it's ok because next step will do obb collision tests between each cell and each probe volumes so we will eliminate them.
-                var minCellPosition = pv.bounds.min / cellSize;
-                var maxCellPosition = pv.bounds.max / cellSize;
+                var min = profileInfo.PositionToCell(pv.bounds.min);
+                var max = profileInfo.PositionToCell(pv.bounds.max);
 
-                Vector3Int min = new Vector3Int(Mathf.FloorToInt(minCellPosition.x), Mathf.FloorToInt(minCellPosition.y), Mathf.FloorToInt(minCellPosition.z));
-                Vector3Int max = new Vector3Int(Mathf.CeilToInt(maxCellPosition.x), Mathf.CeilToInt(maxCellPosition.y), Mathf.CeilToInt(maxCellPosition.z));
-
-                for (int x = min.x; x < max.x; x++)
+                for (int x = min.x; x <= max.x; x++)
                 {
-                    for (int y = min.y; y < max.y; y++)
-                        for (int z = min.z; z < max.z; z++)
+                    for (int y = min.y; y <= max.y; y++)
+                    {
+                        for (int z = min.z; z <= max.z; z++)
                         {
                             var cellPos = new Vector3Int(x, y, z);
                             if (cellPositions.Add(cellPos))
                             {
-                                var center = new Vector3((cellPos.x + 0.5f) * cellSize, (cellPos.y + 0.5f) * cellSize, (cellPos.z + 0.5f) * cellSize);
+                                var center = profileInfo.probeOffset + new Vector3((cellPos.x + 0.5f) * cellSize, (cellPos.y + 0.5f) * cellSize, (cellPos.z + 0.5f) * cellSize);
                                 cells.Add((cellPos, new Bounds(center, cellDimensions)));
                             }
                         }
+                    }
                 }
             }
 

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

@@ -38,6 +38,7 @@ internal class ProbeVolumeBakingSetEditor : Editor
         SerializedProperty m_MinRendererVolumeSize;
         SerializedProperty m_RenderersLayerMask;
         SerializedProperty m_FreezePlacement;
+        SerializedProperty m_ProbeOffset;
         SerializedProperty m_ProbeVolumeBakingSettings;
         SerializedProperty m_LightingScenarios;
         SerializedProperty m_SkyOcclusion;
@@ -63,6 +64,7 @@ static class Styles
 
             // Probe Placement section
             public static readonly string msgProbeFreeze = "Some scene(s) in this Baking Set are not currently loaded in the Hierarchy. Set Probe Positions to Don't Recalculate to not break compatibility with already baked scenarios.";
+            public static readonly GUIContent probeOffset = new GUIContent("Probe Offset", "Offset on world origin used during baking. Can be used to have cells on positions that are not multiples of the probe spacing.");
             public static readonly GUIContent maxDistanceBetweenProbes = new GUIContent("Max Probe Spacing", "Maximum distance between probes, in meters. Determines the number of Bricks in a streamable unit.");
             public static readonly GUIContent minDistanceBetweenProbes = new GUIContent("Min Probe Spacing", "Minimum distance between probes, in meters.");
             public static readonly string simplificationLevelsHighWarning = " Using this many brick sizes will result in high memory usage and can cause instabilities.";
@@ -94,6 +96,7 @@ void OnEnable()
             m_MinRendererVolumeSize = serializedObject.FindProperty(nameof(ProbeVolumeBakingSet.minRendererVolumeSize));
             m_RenderersLayerMask = serializedObject.FindProperty(nameof(ProbeVolumeBakingSet.renderersLayerMask));
             m_FreezePlacement = serializedObject.FindProperty(nameof(ProbeVolumeBakingSet.freezePlacement));
+            m_ProbeOffset = serializedObject.FindProperty(nameof(ProbeVolumeBakingSet.probeOffset));
             m_ProbeVolumeBakingSettings = serializedObject.FindProperty(nameof(ProbeVolumeBakingSet.settings));
             m_LightingScenarios = serializedObject.FindProperty(nameof(ProbeVolumeBakingSet.m_LightingScenarios));
 			m_SkyOcclusion = serializedObject.FindProperty(nameof(ProbeVolumeBakingSet.skyOcclusion));
@@ -178,6 +181,22 @@ void ProbePlacementGUI()
 
             using (new EditorGUI.DisabledScope(Lightmapping.isRunning || (canFreezePlacement && ProbeGIBaking.isFreezingPlacement)))
             {
+                // Display vector3 ourselves otherwise display is messed up
+                {
+                    var rect = EditorGUILayout.GetControlRect();
+                    EditorGUI.BeginProperty(rect, Styles.probeOffset, m_ProbeOffset);
+
+                    rect = EditorGUI.PrefixLabel(rect, Styles.probeOffset);
+                    rect.xMin -= 10 * EditorGUIUtility.pixelsPerPoint;
+
+                    EditorGUI.BeginChangeCheck();
+                    var value = EditorGUI.Vector3Field(rect, GUIContent.none, m_ProbeOffset.vector3Value);
+                    if (EditorGUI.EndChangeCheck())
+                        m_ProbeOffset.vector3Value = value;
+
+                    EditorGUI.EndProperty();
+                }
+
                 EditorGUI.BeginChangeCheck();
                 EditorGUILayout.PropertyField(m_MinDistanceBetweenProbes, Styles.minDistanceBetweenProbes);
                 if (EditorGUI.EndChangeCheck())

Packages/com.unity.render-pipelines.core/Editor/Lighting/ProbeVolume/ProbeVolumeCellDilation.compute

@@ -103,7 +103,7 @@ void DilateCell(uint3 id : SV_DispatchThreadID)
 
         if (_NeedDilating[probeIdx] > 0)
         {
-            float3 centralPosition = _ProbePositionsBuffer[probeIdx];
+            float3 centralPosition = _ProbePositionsBuffer[probeIdx] - _WorldOffset;
             DilatedProbe probe = (DilatedProbe)0;
 
             float3 uvw;