Fix Unified Baking

Author: pigselated

Packages/com.unity.render-pipelines.core/Editor/PathTracing/BakeInputSerialization.cs

@@ -708,11 +708,11 @@ public static UInt64 TilingModeToLightmapExpandedBufferSize(TilingMode tilingMod
             // TODO: We need to change the naming of the entries in the enum see: https://jira.unity3d.com/browse/GFXFEAT-728
             switch (tilingMode)
             {
-                case TilingMode.None: bufferSize = 524288; break;                      // UI: Highest Performance
-                case TilingMode.Quarter: bufferSize = 262144; break;                   // UI: High Performance
-                case TilingMode.Sixteenth: bufferSize = 131072; break;                 // UI: Automatic     (but it is not automatic)
-                case TilingMode.Sixtyfourth: bufferSize = 65536; break;                // UI: Low Memory Usage
-                case TilingMode.TwoHundredFiftySixth: bufferSize = 32768; break;       // UI: Lowest Memory Usage
+                case TilingMode.None: bufferSize = 1048576; break;                     // UI: Highest Performance
+                case TilingMode.Quarter: bufferSize = 524288; break;                   // UI: High Performance
+                case TilingMode.Sixteenth: bufferSize = 262144; break;                 // UI: Automatic     (but it is not automatic)
+                case TilingMode.Sixtyfourth: bufferSize = 131072; break;               // UI: Low Memory Usage
+                case TilingMode.TwoHundredFiftySixth: bufferSize = 65536; break;       // UI: Lowest Memory Usage
                 default: Debug.Assert(false, "Unknown tiling mode."); break;
             }
             return math.max(bufferSize, kMinBufferSize);

Packages/com.unity.render-pipelines.core/Editor/PathTracing/LightBakerStrangler.cs

@@ -89,9 +89,9 @@ static SetLightmappingUnifiedBaker()
             try
             {
                 var lightmappingType = typeof(UnityEditor.Lightmapping);
-                var unifiedBakerProperty = lightmappingType.GetProperty("UnifiedBaker", 
+                var unifiedBakerProperty = lightmappingType.GetProperty("UnifiedBaker",
                     System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static);
-                
+
                 if (unifiedBakerProperty != null && unifiedBakerProperty.CanWrite)
                 {
     #if UNIFIED_BAKER
@@ -274,6 +274,7 @@ private static bool LightmapRequestOutputTypeToIntegratedOutputType(LightmapRequ
                 case LightmapRequestOutputType.Normal:
                 case LightmapRequestOutputType.ChartIndex:
                 case LightmapRequestOutputType.OverlapPixelIndex:
+                case LightmapRequestOutputType.IrradianceEnvironment:
                     return false;
             }
             Debug.Assert(false, $"Error unknown LightmapRequestOutputType {type}.");
@@ -1386,6 +1387,10 @@ internal static Result ExecuteLightmapRequests(
                     byte[] compressedBlack = blackOutput.EncodeToR2D();
                     try
                     {
+                        // Environment is part of indirect irradiance.
+                        if (request.outputTypeMask.HasFlag(LightmapRequestOutputType.IrradianceEnvironment))
+                            File.WriteAllBytes(request.outputFolderPath + $"/irradianceEnvironment{lightmapIndex}.r2d", compressedBlack);
+
                         // occupiedTexels is needed for analytics, don't fail the bake if we cannot write it.
                         UInt64 occupiedTexels = (UInt64)lightmapRequestData.atlassing.m_EstimatedTexelCount;
                         if (request.outputTypeMask.HasFlag(LightmapRequestOutputType.Occupancy))

Packages/com.unity.render-pipelines.core/Runtime/PathTracing/LightmapIntegrationHelpers.cs

@@ -508,6 +508,7 @@ public static void ReferenceBoxFilterBlueChannelRenderTexture(CommandBuffer cmd,
         // these regions can overlap for multiple instances, when the instance's UV layout doesn't fully
         // cover the [0; 1] range. We pack based on tight bounding boxes of the instance's UVs,
         // but lightmap STs are with respect to the instance's entire UV layout.
+        // It is assumed that the lightmap offset is aligned to either half or full texel.
         internal static void ComputeOccupiedTexelRegionForInstance(
             uint lightmapWidth,
             uint lightmapHeight,
@@ -540,9 +541,35 @@ internal static void ComputeOccupiedTexelRegionForInstance(
             // Clamp the occupied region to the lightmap bounds.
             float occupiedTexelOffsetXFloat = Mathf.Max(occupiedOffsetX, 0f);
             float occupiedTexelOffsetYFloat = Mathf.Max(occupiedOffsetY, 0f);
-            Debug.Assert(Mathf.Abs(Mathf.Round(occupiedTexelOffsetXFloat) - occupiedTexelOffsetXFloat) < 0.001f, $"Expected offset (X) to be very close to zero. Was {occupiedTexelOffsetXFloat % 1}. Was the scene baked with the same resolution as it was atlassed for?");
-            Debug.Assert(Mathf.Abs(Mathf.Round(occupiedTexelOffsetYFloat) - occupiedTexelOffsetYFloat) < 0.001f, $"Expected offset (Y) to be very close to zero. Was {occupiedTexelOffsetYFloat % 1}. Was the scene baked with the same resolution as it was atlassed for?");
-            occupiedTexelOffset = new((int)Mathf.Round(occupiedTexelOffsetXFloat), (int)Mathf.Round(occupiedTexelOffsetYFloat));
+
+            // Get the fractional value
+            float offsetFracX = Mathf.Abs(occupiedTexelOffsetXFloat - Mathf.Floor(occupiedTexelOffsetXFloat));
+            float offsetFracY = Mathf.Abs(occupiedTexelOffsetYFloat - Mathf.Floor(occupiedTexelOffsetYFloat));
+
+            // Check that we are either aligned to half or full texel
+            float distanceToHalfX = Mathf.Abs(offsetFracX - 0.5f);
+            float distanceToHalfY = Mathf.Abs(offsetFracY - 0.5f);
+            float distanceToWholeX = Mathf.Abs(Mathf.Round(offsetFracX) - offsetFracX);
+            float distanceToWholeY = Mathf.Abs(Mathf.Round(offsetFracY) - offsetFracY);
+
+            Debug.Assert(Mathf.Min(distanceToHalfX, distanceToWholeX) < 0.001f, $"Expected offset (X) to align with an offset of 0.5 (half texel) or 0.0 (whole texel). Was {occupiedTexelOffsetXFloat}. Was the scene baked with the same resolution as it was atlassed for?");
+            Debug.Assert(Mathf.Min(distanceToHalfY, distanceToWholeY) < 0.001f, $"Expected offset (Y) to align with an offset of 0.5 (half texel) or 0.0 (whole texel). Was {occupiedTexelOffsetYFloat}. Was the scene baked with the same resolution as it was atlassed for?");
+            Debug.Assert((distanceToHalfX < distanceToWholeX && distanceToHalfY < distanceToWholeY) || (distanceToHalfX > distanceToWholeX && distanceToHalfY > distanceToWholeY), "Texel alignment with an offset of 0.5 (half texel) or 0.0 (whole texel) must be the same for X and Y");
+
+            int occupiedTexelOffsetX = 0;
+            int occupiedTexelOffsetY = 0;
+
+            if (distanceToHalfX < distanceToWholeX)
+                occupiedTexelOffsetX = (int)Mathf.Floor(occupiedTexelOffsetXFloat);
+            else
+                occupiedTexelOffsetX = (int)Mathf.Round(occupiedTexelOffsetXFloat);
+
+            if (distanceToHalfY < distanceToWholeY)
+                occupiedTexelOffsetY = (int)Mathf.Floor(occupiedTexelOffsetYFloat);
+            else
+                occupiedTexelOffsetY = (int)Mathf.Round(occupiedTexelOffsetYFloat);
+
+            occupiedTexelOffset = new(occupiedTexelOffsetX, occupiedTexelOffsetY);
         }
 
         // Computes the bounding box of a set of UV coordinates.