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

Internal/master

Author: UnityAljosha

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

@@ -150,7 +150,11 @@ public override void PrepareForBuild(BuildPlayerContext buildPlayerContext)
                             IncludeStreamableAsset(scenario.Value.cellOptionalDataAsset, basePath, useStreamingAsset);
                         else
                             StripStreambleAsset(scenario.Value.cellOptionalDataAsset);
-                        IncludeStreamableAsset(scenario.Value.cellProbeOcclusionDataAsset, basePath, useStreamingAsset);
+
+                        if (bakingSet.bakedProbeOcclusion)
+                            IncludeStreamableAsset(scenario.Value.cellProbeOcclusionDataAsset, basePath, useStreamingAsset);
+                        else
+                            StripStreambleAsset(scenario.Value.cellProbeOcclusionDataAsset);
                     }
 
                     s_BakingSetsProcessedLastBuild.Add(bakingSet);

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

@@ -48,7 +48,6 @@ static class Styles
             public static readonly string msgEnableAll = "Some loaded Scenes are disabled by this Baking Set. These Scenes will not contribute to the generation of probe data.";
             public static readonly string msgUnloadOther = "Scene(s) not belonging to this Baking Set are currently loaded in the Hierarchy. This might result in incorrect lighting.";
             public static readonly string msgLoadForBake = "Some scene(s) in this Baking Set are not currently loaded in the Hierarchy. This might result in missing or incomplete lighting.";
-            public static readonly string msgIncorrectBakingSet = "The currently loaded scenes do not match the assigned Baking Set. To resolve this, make sure to load the scenes that correspond to the assigned Baking Set, unload any scenes that don’t belong, and verify the scene setup before generating lighting to ensure everything bakes correctly.";
 
             public const float statusLabelWidth = 80;
 
@@ -222,18 +221,6 @@ public override void OnGUI()
             Initialize();
 
             var prv = ProbeReferenceVolume.instance;
-            // The CurrentBakingSet may change when you open an additional Scene with APV
-            if (prv.currentBakingSet != activeSet)
-            {
-                if (prv.currentBakingSet == null)
-                {
-                    m_SingleSceneMode = true;
-                }
-                else
-                {
-                    OpenBakingSet(prv.currentBakingSet);
-                }
-            }
 
             // In single scene mode, user can't control active set, so we automatically create a new one
             // in case the active scene doesn't have a baking set so that we can display baking settings
@@ -372,9 +359,8 @@ void BakingGUI()
             {
                 if (newSet != null) { EditorUtility.SetDirty(newSet); newSet.singleSceneMode = false; }
                 activeSet = newSet;
-
+                
                 ProbeReferenceVolume.instance.Clear();
-                ProbeReferenceVolume.instance.SetActiveBakingSet(activeSet);
             }
 
             if (activeSet != null)
@@ -497,24 +483,6 @@ void ShowWarnings()
                 }
             }
 
-            if (activeSet == ProbeReferenceVolume.instance.currentBakingSet)
-            {
-                hasWarnings = true;
-                foreach (var sceneDataList in ProbeReferenceVolume.instance.perSceneDataList)
-                {
-                    if (sceneDataList.bakingSet == activeSet)
-                    {
-                        hasWarnings = false;
-                        break;
-                    }
-                }
-
-                if (hasWarnings)
-                {
-                    EditorGUILayout.HelpBox(Styles.msgIncorrectBakingSet, MessageType.Warning);
-                }
-            }
-
             scenesForBake.Clear();
             scenesToUnload.Clear();
             scenesToEnable.Clear();

Packages/com.unity.render-pipelines.core/Runtime/GPUDriven/.buginfo

@@ -1 +1 @@
-area: Graphics Optimization Systems
+area: GPU Resident Drawer

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

@@ -534,7 +534,7 @@ private void UpdateSelection()
                 rendererIDs[i] = renderers[i] ? renderers[i].GetInstanceID() : 0;
 
             m_Batcher.UpdateSelectedRenderers(rendererIDs);
-            
+
             rendererIDs.Dispose();
 
             Profiler.EndSample();
@@ -630,7 +630,7 @@ private void PostPostLateUpdate()
                 UpdateSelection();
                 m_IsSelectionDirty = false;
             }
-            
+
             m_FrameUpdateNeeded = false;
 #endif
         }
@@ -830,14 +830,8 @@ private void ClassifyMaterials(NativeArray<int> materials, out NativeList<int> u
 
             if (materials.Length > 0)
             {
-                new ClassifyMaterialsJob
-                {
-                    materialIDs = materials.AsReadOnly(),
-                    batchMaterialHash = m_Batcher.instanceCullingBatcher.batchMaterialHash.AsReadOnly(),
-                    unsupportedMaterialIDs = unsupportedMaterials,
-                    supportedMaterialIDs = supportedMaterials,
-                    supportedPackedMaterialDatas = supportedPackedMaterialDatas
-                }.Run();
+                GPUResidentDrawerBurst.ClassifyMaterials(materials, m_Batcher.instanceCullingBatcher.batchMaterialHash.AsReadOnly(),
+                                                         ref supportedMaterials, ref unsupportedMaterials, ref supportedPackedMaterialDatas);
             }
         }
 
@@ -847,13 +841,8 @@ private NativeList<int> FindUnsupportedRenderers(NativeArray<int> unsupportedMat
 
             if (unsupportedMaterials.Length > 0)
             {
-                new FindUnsupportedRenderersJob
-                {
-                    unsupportedMaterials = unsupportedMaterials.AsReadOnly(),
-                    materialIDArrays = m_BatchersContext.sharedInstanceData.materialIDArrays,
-                    rendererGroups = m_BatchersContext.sharedInstanceData.rendererGroupIDs,
-                    unsupportedRenderers = unsupportedRenderers,
-                }.Run();
+                GPUResidentDrawerBurst.FindUnsupportedRenderers(unsupportedMaterials, m_BatchersContext.sharedInstanceData.materialIDArrays,
+                    m_BatchersContext.sharedInstanceData.rendererGroupIDs, ref unsupportedRenderers);
             }
 
             return unsupportedRenderers;
@@ -863,13 +852,8 @@ private NativeHashSet<int> GetMaterialsWithChangedPackedMaterial(NativeArray<int
         {
             NativeHashSet<int> filteredMaterials = new NativeHashSet<int>(materials.Length, allocator);
 
-            new GetMaterialsWithChangedPackedMaterialJob
-            {
-                materialIDs = materials.AsReadOnly(),
-                packedMaterialDatas = packedMaterialDatas.AsReadOnly(),
-                packedMaterialHash = batcher.instanceCullingBatcher.packedMaterialHash.AsReadOnly(),
-                filteredMaterials = filteredMaterials
-            }.Run();
+            GPUResidentDrawerBurst.GetMaterialsWithChangedPackedMaterial(materials, packedMaterialDatas,
+                batcher.instanceCullingBatcher.packedMaterialHash.AsReadOnly(), ref filteredMaterials);
 
             return filteredMaterials;
         }
@@ -892,79 +876,6 @@ private NativeList<int> FindRenderersFromMaterials(NativeArray<int> sortedExclud
             return renderers;
         }
 
-        [BurstCompile(DisableSafetyChecks = true, OptimizeFor = OptimizeFor.Performance)]
-        private struct ClassifyMaterialsJob : IJob
-        {
-            [ReadOnly] public NativeParallelHashMap<int, BatchMaterialID>.ReadOnly  batchMaterialHash;
-            [ReadOnly] public NativeArray<int>.ReadOnly  materialIDs;
-
-            public NativeList<int> supportedMaterialIDs;
-            public NativeList<int> unsupportedMaterialIDs;
-            public NativeList<GPUDrivenPackedMaterialData> supportedPackedMaterialDatas;
-
-            public void Execute()
-            {
-                var usedMaterialIDs = new NativeList<int>(4, Allocator.TempJob);
-
-                foreach (var materialID in materialIDs)
-                {
-                    if (batchMaterialHash.ContainsKey(materialID))
-                        usedMaterialIDs.Add(materialID);
-                }
-
-                if (usedMaterialIDs.IsEmpty)
-                {
-                    usedMaterialIDs.Dispose();
-                    return;
-                }
-
-                unsupportedMaterialIDs.Resize(usedMaterialIDs.Length, NativeArrayOptions.UninitializedMemory);
-                supportedMaterialIDs.Resize(usedMaterialIDs.Length, NativeArrayOptions.UninitializedMemory);
-                supportedPackedMaterialDatas.Resize(usedMaterialIDs.Length, NativeArrayOptions.UninitializedMemory);
-
-                int unsupportedMaterialCount = GPUDrivenProcessor.ClassifyMaterials(usedMaterialIDs.AsArray(), unsupportedMaterialIDs.AsArray(), supportedMaterialIDs.AsArray(), supportedPackedMaterialDatas.AsArray());
-
-                unsupportedMaterialIDs.Resize(unsupportedMaterialCount, NativeArrayOptions.ClearMemory);
-                supportedMaterialIDs.Resize(usedMaterialIDs.Length - unsupportedMaterialCount, NativeArrayOptions.ClearMemory);
-                supportedPackedMaterialDatas.Resize(supportedMaterialIDs.Length, NativeArrayOptions.ClearMemory);
-
-                usedMaterialIDs.Dispose();
-            }
-        }
-
-        [BurstCompile(DisableSafetyChecks = true, OptimizeFor = OptimizeFor.Performance)]
-        private struct FindUnsupportedRenderersJob : IJob
-        {
-            [ReadOnly] public NativeArray<int>.ReadOnly unsupportedMaterials;
-            [ReadOnly] public NativeArray<SmallIntegerArray>.ReadOnly materialIDArrays;
-            [ReadOnly] public NativeArray<int>.ReadOnly rendererGroups;
-
-            public NativeList<int> unsupportedRenderers;
-
-            public unsafe void Execute()
-            {
-                if (unsupportedMaterials.Length == 0)
-                    return;
-
-                for (int arrayIndex = 0; arrayIndex < materialIDArrays.Length; arrayIndex++)
-                {
-                    var materialIDs = materialIDArrays[arrayIndex];
-                    int rendererID = rendererGroups[arrayIndex];
-
-                    for (int i = 0; i < materialIDs.Length; i++)
-                    {
-                        int materialID = materialIDs[i];
-
-                        if (unsupportedMaterials.Contains(materialID))
-                        {
-                            unsupportedRenderers.Add(rendererID);
-                            break;
-                        }
-                    }
-                }
-            }
-        }
-
         [BurstCompile(DisableSafetyChecks = true, OptimizeFor = OptimizeFor.Performance)]
         private unsafe struct FindRenderersFromMaterialJob : IJobParallelForBatch
         {
@@ -1008,30 +919,5 @@ public void Execute(int startIndex, int count)
                 selectedRenderGroups.AddRangeNoResize(renderersToAddPtr, renderersToAdd.Length);
             }
         }
-
-        [BurstCompile(DisableSafetyChecks = true, OptimizeFor = OptimizeFor.Performance)]
-        private struct GetMaterialsWithChangedPackedMaterialJob : IJob
-        {
-            [ReadOnly] public NativeArray<int>.ReadOnly materialIDs;
-            [ReadOnly] public NativeArray<GPUDrivenPackedMaterialData>.ReadOnly packedMaterialDatas;
-            [ReadOnly] public NativeParallelHashMap<int, GPUDrivenPackedMaterialData>.ReadOnly packedMaterialHash;
-
-            [WriteOnly] public NativeHashSet<int> filteredMaterials;
-
-            public void Execute()
-            {
-                for (int index = 0; index < materialIDs.Length ; index++)
-                {
-                    var materialID = materialIDs[index];
-                    var newPackedMaterialData = packedMaterialDatas[index];
-
-                    // Has its packed material changed? If the material isn't in the packed material cache, consider the material has changed.
-                    if (packedMaterialHash.TryGetValue(materialID, out var packedMaterial) && packedMaterial.Equals(newPackedMaterialData))
-                        continue;
-
-                    filteredMaterials.Add(materialID);
-                }
-            }
-        }
     }
 }

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

@@ -0,0 +1,80 @@
+using Unity.Collections;
+using UnityEngine.Rendering;
+using Unity.Burst;
+
+namespace UnityEngine.Rendering
+{
+    [BurstCompile]
+    internal static class GPUResidentDrawerBurst
+    {
+        [BurstCompile(DisableSafetyChecks = true, OptimizeFor = OptimizeFor.Performance)]
+        public static void ClassifyMaterials(in NativeArray<int> materialIDs, in NativeParallelHashMap<int, BatchMaterialID>.ReadOnly batchMaterialHash,
+                                             ref NativeList<int> supportedMaterialIDs, ref NativeList<int> unsupportedMaterialIDs, ref NativeList<GPUDrivenPackedMaterialData> supportedPackedMaterialDatas)
+        {
+            var usedMaterialIDs = new NativeList<int>(4, Allocator.Temp);
+
+            foreach (var materialID in materialIDs)
+            {
+                if (batchMaterialHash.ContainsKey(materialID))
+                    usedMaterialIDs.Add(materialID);
+            }
+
+            if (usedMaterialIDs.IsEmpty)
+            {
+                usedMaterialIDs.Dispose();
+                return;
+            }
+
+            unsupportedMaterialIDs.Resize(usedMaterialIDs.Length, NativeArrayOptions.UninitializedMemory);
+            supportedMaterialIDs.Resize(usedMaterialIDs.Length, NativeArrayOptions.UninitializedMemory);
+            supportedPackedMaterialDatas.Resize(usedMaterialIDs.Length, NativeArrayOptions.UninitializedMemory);
+
+            int unsupportedMaterialCount = GPUDrivenProcessor.ClassifyMaterials(usedMaterialIDs.AsArray(), unsupportedMaterialIDs.AsArray(), supportedMaterialIDs.AsArray(), supportedPackedMaterialDatas.AsArray());
+
+            unsupportedMaterialIDs.Resize(unsupportedMaterialCount, NativeArrayOptions.ClearMemory);
+            supportedMaterialIDs.Resize(usedMaterialIDs.Length - unsupportedMaterialCount, NativeArrayOptions.ClearMemory);
+            supportedPackedMaterialDatas.Resize(supportedMaterialIDs.Length, NativeArrayOptions.ClearMemory);
+
+            usedMaterialIDs.Dispose();
+        }
+
+        [BurstCompile(DisableSafetyChecks = true, OptimizeFor = OptimizeFor.Performance)]
+        public static void FindUnsupportedRenderers(in NativeArray<int> unsupportedMaterials, in NativeArray<SmallIntegerArray>.ReadOnly materialIDArrays, in NativeArray<int>.ReadOnly rendererGroups,
+                                                    ref NativeList<int> unsupportedRenderers)
+        {
+            for (int arrayIndex = 0; arrayIndex < materialIDArrays.Length; arrayIndex++)
+            {
+                var materialIDs = materialIDArrays[arrayIndex];
+                int rendererID = rendererGroups[arrayIndex];
+
+                for (int i = 0; i < materialIDs.Length; i++)
+                {
+                    int materialID = materialIDs[i];
+
+                    if (unsupportedMaterials.Contains(materialID))
+                    {
+                        unsupportedRenderers.Add(rendererID);
+                        break;
+                    }
+                }
+            }
+        }
+
+        [BurstCompile(DisableSafetyChecks = true, OptimizeFor = OptimizeFor.Performance)]
+        public static void GetMaterialsWithChangedPackedMaterial(in NativeArray<int> materialIDs, in NativeArray<GPUDrivenPackedMaterialData> packedMaterialDatas,
+            in NativeParallelHashMap<int, GPUDrivenPackedMaterialData>.ReadOnly packedMaterialHash, ref NativeHashSet<int> filteredMaterials)
+        {
+            for (int index = 0; index < materialIDs.Length ; index++)
+            {
+                var materialID = materialIDs[index];
+                var newPackedMaterialData = packedMaterialDatas[index];
+
+                // Has its packed material changed? If the material isn't in the packed material cache, consider the material has changed.
+                if (packedMaterialHash.TryGetValue(materialID, out var packedMaterial) && packedMaterial.Equals(newPackedMaterialData))
+                    continue;
+
+                filteredMaterials.Add(materialID);
+            }
+        }
+    }
+}