Internal/6000.4/staging

.gitattributes

@@ -348,6 +348,9 @@ Editor/Resources/unity[[:space:]]editor[[:space:]]resources filter=lfs diff=lfs
 **/HDRP_RuntimeTests/Assets/Scenes/002-HDMaterials/cloud2.asset filter=lfs diff=lfs merge=lfs -text
 **/HDRP_RuntimeTests/Assets/Scenes/002-HDMaterials/perlin.asset filter=lfs diff=lfs merge=lfs -text
 
+# Gfx ML acceleration test assets
+**/MachineLearning/**/*.bytes filter=lfs diff=lfs merge=lfs -text
+
 #GfxTests
 **/GfxTestProjectFolder/**/*.[hH][dD][rR] filter=lfs diff=lfs merge=lfs -text
 **/GfxTestProjectFolder/**/*.[tT][gG][aA] filter=lfs diff=lfs merge=lfs -text
@@ -382,3 +385,6 @@ Editor/Resources/unity[[:space:]]editor[[:space:]]resources filter=lfs diff=lfs
 # search test cases
 /Modules/QuickSearch/Tests/QuickSearch/Assets/Cases/UUM-113048/uum-113048.index filter=lfs diff=lfs merge=lfs -text
 
+# documentation images
+Documentation/ManualDocs/uploads/Main/unity-xr-tech-stack.png filter=lfs diff=lfs merge=lfs -text
+

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

@@ -1409,8 +1409,11 @@ Vector3Int GetCellPositionFromVoxel(Vector3Int voxelToLookup, int cellSizeInBric
                         continue;
 
                     // 3.
-                    // Overwrite lighting data with trilinear sampled data from the brick with highest subdiv level
-                    float brickSize = ProbeReferenceVolume.instance.BrickSize(largestBrick.subdivisionLevel - 1);
+                    // Overwrite lighting data with trilinear sampled data from the brick with highest subdiv level.
+                    // Use minBrickSize from m_ProfileInfo (live bake settings), not ProbeReferenceVolume.instance,
+                    // because that runtime state is restored to the previous bake's snapshot at the end of
+                    // ApplySubdivisionResults and would be stale here. UUM-141983.
+                    float brickSize = ProbeVolumeUtil.BrickSize(minBrickSize, largestBrick.subdivisionLevel - 1);
                     float3 uvw = math.clamp((pos - (Vector3)largestBrick.position * minBrickSize) / brickSize, 0, 3);
 
                     var probe = Vector3Int.FloorToInt(uvw);

Packages/com.unity.render-pipelines.core/Runtime/GPUDriven/InstanceCullingBatcherBurst.cs

@@ -177,6 +177,7 @@ private static void ProcessRenderer(int i, bool implicitInstanceIndices, in GPUD
             Span<GPUDrivenPackedMaterialData> packedMaterialDatas = stackalloc GPUDrivenPackedMaterialData[materialsCount];
 
             var supportsIndirect = true;
+            var isMetal = SystemInfo.graphicsDeviceType == GraphicsDeviceType.Metal;
             for (int matIndex = 0; matIndex < materialsCount; ++matIndex)
             {
                 if (matIndex >= submeshCount)
@@ -198,7 +199,14 @@ private static void ProcessRenderer(int i, bool implicitInstanceIndices, in GPUD
                     bool isFound = packedMaterialDataHash.TryGetValue(materialID, out packedMaterialData);
                     Assert.IsTrue(isFound);
                 }
-                supportsIndirect &= packedMaterialData.isIndirectSupported;
+
+                var submeshIndex = startSubMesh + matIndex;
+                var subMesh = rendererData.subMeshDesc[subMeshDescOffset + submeshIndex];
+
+                // The indirect path does not support topology adjustment; use the direct path when this is required.
+                // Concretely, for quads, only use the indirect path if we allow quads natively (e.g. tessellation shaders).
+                supportsIndirect &= subMesh.topology != MeshTopology.Quads || packedMaterialData.hasTessellation;
+                supportsIndirect &= !isMetal || !packedMaterialData.hasTessellation;
 
                 packedMaterialDatas[matIndex] = packedMaterialData;
             }

Packages/com.unity.render-pipelines.core/Runtime/Lighting/ProbeVolume/ProbeReferenceVolume.Streaming.cs

@@ -109,6 +109,23 @@ internal struct CellStreamingScratchBufferLayout
             public int _ProbeCountInChunkSlice;
         }
 
+        internal struct BufferLayoutBuilder
+        {
+            int _Offset;
+
+            public BufferLayoutBuilder(int initialOffset = 0)
+            {
+                _Offset = initialOffset;
+            }
+
+            public int AddBlock(int blockSize)
+            {
+                int currentOffset = _Offset;
+                _Offset += blockSize;
+                return currentOffset;
+            }
+        }
+
         internal class CellStreamingScratchBuffer
         {
             public CellStreamingScratchBuffer(int chunkCount, int chunkSize, bool allocateGraphicsBuffers)

Packages/com.unity.render-pipelines.core/Runtime/Lighting/ProbeVolume/ProbeVolumeBakingSet.cs

@@ -769,13 +769,13 @@ void ReleaseStreamableAssetData<T>(NativeArray<T> buffer) where T : struct
                 m_ReadOperationScratchBuffers.Push(buffer.Reinterpret<byte>(UnsafeUtility.SizeOf<T>()));
         }
 
-        void PruneCellIndexList(List<int> cellIndices, List<int> prunedIndexList)
+        internal void PruneCellIndexList(List<int> cellIndices, List<int> prunedIndexList)
         {
             prunedIndexList.Clear();
             foreach (var cellIndex in cellIndices)
             {
                 // When clearing data only partially (ie: not all scenes are loaded), there can be left over indices here but no cells in the set.
-                if (!cellDataMap.ContainsKey(cellIndex))
+                if (!cellDataMap.ContainsKey(cellIndex) && cellDescs.ContainsKey(cellIndex))
                 {
                     prunedIndexList.Add(cellIndex);
                 }

Packages/com.unity.render-pipelines.core/Runtime/Lighting/ProbeVolume/ProbeVolumeScratchBufferPool.cs

@@ -133,18 +133,20 @@ CellStreamingScratchBufferLayout GetOrCreateScratchBufferLayout(int chunkCount)
                                                                     // First destination chunks at offset 0 (no explicit member for this).
                                                                     // Then, shared data destination chunks. Can be different from SH data destination in case of blending
                                                                     // (one pool for blending and one other pool for shared data and blending destination).
-                bufferLayout._SharedDestChunksOffset = destChunksSize;
-                bufferLayout._L0L1rxOffset = bufferLayout._SharedDestChunksOffset + destChunksSize;
-                bufferLayout._L1GryOffset = bufferLayout._L0L1rxOffset + m_L0Size * chunkCount;
-                bufferLayout._L1BrzOffset = bufferLayout._L1GryOffset + m_L1Size * chunkCount;
-                bufferLayout._ValidityOffset = bufferLayout._L1BrzOffset + m_L1Size * chunkCount;
-                bufferLayout._ProbeOcclusionOffset = bufferLayout._ValidityOffset + m_ValiditySize * chunkCount;
-                bufferLayout._SkyOcclusionOffset = bufferLayout._ProbeOcclusionOffset + m_ProbeOcclusionSize * chunkCount;
-                bufferLayout._SkyShadingDirectionOffset = bufferLayout._SkyOcclusionOffset + m_SkyOcclusionSize * chunkCount;
-                bufferLayout._L2_0Offset = bufferLayout._SkyShadingDirectionOffset + m_SkyShadingDirectionSize * chunkCount;
-                bufferLayout._L2_1Offset = bufferLayout._L2_0Offset + m_L2Size * chunkCount;
-                bufferLayout._L2_2Offset = bufferLayout._L2_1Offset + m_L2Size * chunkCount;
-                bufferLayout._L2_3Offset = bufferLayout._L2_2Offset + m_L2Size * chunkCount;
+
+                ProbeReferenceVolume.BufferLayoutBuilder layoutBuilder = new(destChunksSize);
+                bufferLayout._SharedDestChunksOffset = layoutBuilder.AddBlock(destChunksSize);
+                bufferLayout._L0L1rxOffset = layoutBuilder.AddBlock(m_L0Size * chunkCount);
+                bufferLayout._L1GryOffset = layoutBuilder.AddBlock(m_L1Size * chunkCount);
+                bufferLayout._L1BrzOffset = layoutBuilder.AddBlock(m_L1Size * chunkCount);
+                bufferLayout._ValidityOffset = layoutBuilder.AddBlock(m_ValiditySize * chunkCount);
+                bufferLayout._SkyOcclusionOffset = layoutBuilder.AddBlock(m_SkyOcclusionSize * chunkCount);
+                bufferLayout._SkyShadingDirectionOffset = layoutBuilder.AddBlock(m_SkyShadingDirectionSize * chunkCount);
+                bufferLayout._L2_0Offset = layoutBuilder.AddBlock(m_L2Size * chunkCount);
+                bufferLayout._L2_1Offset = layoutBuilder.AddBlock(m_L2Size * chunkCount);
+                bufferLayout._L2_2Offset = layoutBuilder.AddBlock(m_L2Size * chunkCount);
+                bufferLayout._L2_3Offset = layoutBuilder.AddBlock(m_L2Size * chunkCount);
+                bufferLayout._ProbeOcclusionOffset = layoutBuilder.AddBlock(m_ProbeOcclusionSize * chunkCount);
 
                 bufferLayout._ProbeCountInChunkLine = ProbeBrickPool.kChunkProbeCountPerDim;
                 bufferLayout._ProbeCountInChunkSlice = ProbeBrickPool.kChunkProbeCountPerDim * ProbeBrickPool.kBrickProbeCountPerDim;
@@ -234,7 +236,7 @@ public void ReleaseScratchBuffer(CellStreamingScratchBuffer scratchBuffer)
         {
             if (scratchBuffer.chunkSize != chunkSize)
             {
-                scratchBuffer.Dispose();                
+                scratchBuffer.Dispose();
                 return;
             }
 

Packages/com.unity.render-pipelines.core/Runtime/PostProcessing/LensFlareCommonSRP.cs

@@ -830,15 +830,15 @@ static Vector3 WorldToViewport(Camera camera, bool isLocalLight, bool isCameraRe
         {
             if (isLocalLight)
             {
-                return WorldToViewportLocal(isCameraRelative, viewProjMatrix, camera.transform.position, positionWS);
+                return WorldToViewportLocal(isCameraRelative, viewProjMatrix, camera.transform.position, positionWS, !camera.orthographic);
             }
             else
             {
-                return WorldToViewportDistance(camera, positionWS);
+                return WorldToViewportDistance(camera, positionWS, !camera.orthographic);
             }
         }
 
-        static Vector3 WorldToViewportLocal(bool isCameraRelative, Matrix4x4 viewProjMatrix, Vector3 cameraPosWS, Vector3 positionWS)
+        static Vector3 WorldToViewportLocal(bool isCameraRelative, Matrix4x4 viewProjMatrix, Vector3 cameraPosWS, Vector3 positionWS, bool isPerspective)
         {
             Vector3 localPositionWS = positionWS;
             if (isCameraRelative)
@@ -847,20 +847,22 @@ static Vector3 WorldToViewportLocal(bool isCameraRelative, Matrix4x4 viewProjMat
             }
             Vector4 viewportPos4 = viewProjMatrix * localPositionWS;
             Vector3 viewportPos = new Vector3(viewportPos4.x, viewportPos4.y, 0f);
-            viewportPos /= viewportPos4.w;
+            if (isPerspective)
+                viewportPos /= viewportPos4.w;
             viewportPos.x = viewportPos.x * 0.5f + 0.5f;
             viewportPos.y = viewportPos.y * 0.5f + 0.5f;
             viewportPos.y = 1.0f - viewportPos.y;
             viewportPos.z = viewportPos4.w;
             return viewportPos;
         }
 
-        static Vector3 WorldToViewportDistance(Camera cam, Vector3 positionWS)
+        static Vector3 WorldToViewportDistance(Camera cam, Vector3 positionWS, bool isPerspective)
         {
             Vector4 camPos = cam.worldToCameraMatrix * positionWS;
             Vector4 viewportPos4 = cam.projectionMatrix * camPos;
             Vector3 viewportPos = new Vector3(viewportPos4.x, viewportPos4.y, 0f);
-            viewportPos /= viewportPos4.w;
+            if (isPerspective)
+                viewportPos /= viewportPos4.w;
             viewportPos.x = viewportPos.x * 0.5f + 0.5f;
             viewportPos.y = viewportPos.y * 0.5f + 0.5f;
             viewportPos.z = viewportPos4.w;

Packages/com.unity.render-pipelines.core/Runtime/RenderGraph/Compiler/CompilerContextData.cs

@@ -58,6 +58,7 @@ void AllocateNativeDataStructuresIfNeeded(int estimatedNumPasses)
                 // These are risky heuristics that only work because we purposely estimate a very high number of passes
                 // We need to fix this with a proper size computation
                 passData = new NativeList<PassData>(estimatedNumPasses, AllocatorManager.Persistent);
+                compactedNonCulledRasterPasses = new NativeList<PassData>(0, AllocatorManager.Persistent); // Will be resized during the compilation
                 inputData = new NativeList<PassInputData>(estimatedNumPasses * 2, AllocatorManager.Persistent);
                 outputData = new NativeList<PassOutputData>(estimatedNumPasses * 2, AllocatorManager.Persistent);
                 fragmentData = new NativeList<PassFragmentData>(estimatedNumPasses * 4, AllocatorManager.Persistent);
@@ -87,6 +88,7 @@ public void Clear()
             if (m_AreNativeListsAllocated)
             {
                 passData.Clear();
+                compactedNonCulledRasterPasses.Clear();
                 fences.Clear();
                 inputData.Clear();
                 outputData.Clear();
@@ -139,6 +141,7 @@ public ref ResourceReaderData ResourceReader(in ResourceHandle h, int i)
 
         // Data per graph level renderpass
         public NativeList<PassData> passData;
+        public NativeList<PassData> compactedNonCulledRasterPasses;
         public Dictionary<int, GraphicsFence> fences;
         public DynamicArray<Name> passNames;
 
@@ -369,6 +372,7 @@ void Cleanup()
             if (m_AreNativeListsAllocated)
             {
                 passData.Dispose();
+                compactedNonCulledRasterPasses.Dispose();
                 inputData.Dispose();
                 outputData.Dispose();
                 fragmentData.Dispose();