Mirror Internal/master

Packages/com.unity.render-pipelines.core/Editor-PrivateShared/Unity.RenderPipelines.Core.Editor.Shared.asmdef

@@ -2,7 +2,13 @@
     "name": "Unity.RenderPipelines.Core.Editor.Shared",
     "rootNamespace": "",
     "references": [
-        "GUID:3eae0364be2026648bf74846acb8a731"
+        "GUID:3eae0364be2026648bf74846acb8a731",
+        "GUID:716365d8000d25e4c8621aa2d34a92fa",
+        "GUID:9149a3cbb036049f68e4e5b6388b9c85",
+        "GUID:c49c619b6af2be941af9bcbca2641964",
+        "GUID:df380645f10b7bc4b97d4f5eb6303d95",
+        "GUID:4fd6538c1c56b409fb53fdf0183170ec",
+        "GUID:214c0945bb158c940aada223f3223ee8"
     ],
     "includePlatforms": [
         "Editor"

Packages/com.unity.render-pipelines.core/Editor/GPUDriven/GPUInstanceDataBufferViewer.cs

@@ -0,0 +1,77 @@
+using UnityEditor;
+
+namespace UnityEngine.Rendering
+{
+    //@ This is a simple instance data viewer class used for instance data debugging.
+    //@ This could become a user facing tool in the future. Where the user could see the instance data in the GPU.
+    //@ It could show layouts, archetypes, components and instance data.
+    internal class GPUInstanceDataBufferViewer : EditorWindow
+    {
+        [SerializeField] private Vector2 m_ScrollPos;
+
+        public static void InitializeWindow()
+        {
+            GPUInstanceDataBufferViewer wnd = GetWindow<GPUInstanceDataBufferViewer>();
+            wnd.titleContent = new GUIContent("GPU Resident Instance Data Viewer");
+        }
+
+        public void OnGUI()
+        {
+            if (!GPUResidentDrawer.IsInitialized())
+            {
+                EditorGUILayout.LabelField("GPU Resident Drawer is not enabled in Render Pipeline Asset.");
+                return;
+            }
+
+            m_ScrollPos = EditorGUILayout.BeginScrollView(m_ScrollPos);
+
+            //@ This is usefully for internal GPU Resident Drawer debugging.
+
+            ref GPUArchetypeManager archetypeMgr = ref GPUResidentDrawer.GetGPUArchetypeManager().GetRef();
+            ref DefaultGPUComponents defaultGPUComponents = ref GPUResidentDrawer.GetDefaultGPUComponents();
+            var buffer = GPUResidentDrawer.GetInstanceDataBuffer();
+            var readback = GPUResidentDrawer.ReadbackInstanceDataBuffer<uint>();
+
+            EditorGUILayout.LabelField($"Archetypes Count: {buffer.layout.archetypes.Length}");
+
+            for (int i = 0; i < buffer.layout.archetypes.Length; ++i)
+            {
+                var archetype = buffer.layout.archetypes[i];
+                var archetypeDesc = archetypeMgr.GetArchetypeDesc(archetype);
+                EditorGUILayout.LabelField($"Archetype {i}, ID: {archetype.index}");
+                EditorGUILayout.LabelField("Components:");
+                for (int j = 0; j < archetypeDesc.components.Length; ++j)
+                {
+                    var component = archetypeDesc.components[j];
+                    var componentDesc = archetypeMgr.GetComponentDesc(component);
+
+                    // Replace when Shader.PropertyIDToName API lands
+                    //var componentName = Shader.PropertyIDToName(componentDesc.propertyID);
+                    string componentName = "<unknown>";
+                    EditorGUILayout.LabelField($"Component {j} - Name: {componentName}, ID: {component.index}");
+                }
+            }
+
+            for (int archIndex = 0; archIndex < buffer.layout.archetypes.Length; ++archIndex)
+            {
+                var archetype = buffer.layout.archetypes[archIndex];
+                var archetypeDesc = archetypeMgr.GetArchetypeDesc(archetype);
+
+                EditorGUILayout.LabelField($"====== Archetype {archetype} Instance Data ======");
+
+                var count = buffer.layout.instancesCount[archIndex];
+                for (int instanceIndex = 0; instanceIndex < count; ++instanceIndex)
+                {
+                    GPUInstanceIndex gpuIndex = buffer.InstanceGPUHandleToGPUIndex(InstanceGPUHandle.Create(archetype, instanceIndex));
+                    PackedMatrix objectToWorld = readback.LoadData<PackedMatrix>(defaultGPUComponents.objectToWorld, gpuIndex);
+                    EditorGUILayout.LabelField($"Instance {instanceIndex}; GPU Index: {gpuIndex.index}; ObjectToWorld {objectToWorld}");
+                    //@ Read and display more instance data here if needed...
+                }
+            }
+
+            readback.Dispose();
+
+            EditorGUILayout.EndScrollView();
+        }
+    }
+}

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

@@ -1,36 +1,30 @@
 using System;
+using System.Collections.Generic;
 using System.Reflection;
 using System.Runtime.CompilerServices;
-using UnityEditor.LightBaking;
 
 namespace UnityEngine.Rendering
 {
     partial class AdaptiveProbeVolumes
     {
         // This class is used to (1) access the internal class UnityEditor.LightBaking.BakePipelineDriver and (2) provide a slightly higher level API.
-        private sealed class BakePipelineDriver : IDisposable
+        sealed class BakePipelineDriver : IDisposable
         {
-            // Keep in sync with the enum BakePipeline::Run::StageName
-            public enum StageName : int
-            {
-                Initialized,
-                Preprocess,
-                Bake,
-                PostProcess,
-                AdditionalBake,
-                Done
-            }
-
-            private readonly object _bakePipelineDriver;
-            private readonly Type _bakePipelineDriverType;
+            readonly object m_BakePipelineDriver;
+            readonly Type m_BakePipelineDriverType;
+            readonly Type m_StageNameType;
 
             internal BakePipelineDriver()
             {
-                _bakePipelineDriverType = Type.GetType("UnityEditor.LightBaking.BakePipelineDriver, UnityEditor");
-                bool newed = _bakePipelineDriverType != null;
-                Debug.Assert(newed, "Unexpected, could not find the type UnityEditor.LightBaking.BakePipelineDriver");
-                _bakePipelineDriver = newed ? Activator.CreateInstance(_bakePipelineDriverType) : null;
-                Debug.Assert(_bakePipelineDriver != null, "Unexpected, could not new up a BakePipelineDriver");
+                Debug.Assert(UnityEditorInternal.InternalEditorUtility.CurrentThreadIsMainThread());
+
+                m_BakePipelineDriverType = Type.GetType("UnityEditor.LightBaking.BakePipelineDriver, UnityEditor");
+                Debug.Assert(m_BakePipelineDriverType != null, "Unexpected, could not find the type UnityEditor.LightBaking.BakePipelineDriver");
+                m_StageNameType = m_BakePipelineDriverType.GetNestedType("StageName", BindingFlags.NonPublic | BindingFlags.Public);
+                Debug.Assert(m_StageNameType is { IsEnum: true }, "Unexpected, could not find the nested enum StageName on BakePipelineDriver");
+                Debug.Assert(IsStageNameEnumConsistent(m_StageNameType), "Unexpected, StageName enum is not consistent with BakePipelineDriver.StageName enum");
+                m_BakePipelineDriver = Activator.CreateInstance(m_BakePipelineDriverType, nonPublic: true);
+                Debug.Assert(m_BakePipelineDriver != null, "Unexpected, could not new up a BakePipelineDriver");
             }
 
             internal void StartBake(bool enablePatching, ref float progress, ref StageName stage)
@@ -51,36 +45,78 @@ internal bool RunInProgress()
             internal void Step(ref float progress, ref StageName stage) =>
                 Update(true, true, true, out progress, out stage);
 
-            private void SetEnableBakedLightmaps(bool enable) =>
+            void SetEnableBakedLightmaps(bool enable) =>
                 InvokeMethod(new object[] { enable }, out _);
 
-            private void SetEnablePatching(bool enable) =>
+            void SetEnablePatching(bool enable) =>
                 InvokeMethod(new object[] { enable }, out _);
 
-            private void Update(bool isOnDemandBakeInProgress, bool isOnDemandBakeAsync, bool shouldBeRunning,
+            void Update(bool isOnDemandBakeInProgress, bool isOnDemandBakeAsync, bool shouldBeRunning,
                 out float progress, out StageName stage)
             {
-                object[] parameters = { isOnDemandBakeInProgress, isOnDemandBakeAsync, shouldBeRunning, -1.0f, -1 };
+                progress = -1.0f;
+                stage = StageName.Invalid;
+                object[] parameters = { isOnDemandBakeInProgress, isOnDemandBakeAsync, shouldBeRunning, progress,
+                    Enum.ToObject(m_StageNameType, (int)stage) };
                 InvokeMethod(parameters, out _);
                 progress = (float)parameters[3];
-                stage = (StageName)parameters[4];
+                stage = (StageName)Convert.ToInt32(parameters[4]);
             }
 
             public void Dispose() =>
                 InvokeMethod(new object[] { }, out _);
 
-            private bool InvokeMethod(object[] parameters, out object result, [CallerMemberName] string methodName = "")
+            bool InvokeMethod(object[] parameters, out object result, [CallerMemberName] string methodName = "")
             {
-                MethodInfo methodInfo = _bakePipelineDriverType.GetMethod(methodName, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
+                MethodInfo methodInfo = m_BakePipelineDriverType.GetMethod(methodName, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
                 bool gotMethod = methodInfo != null;
                 Debug.Assert(gotMethod, $"Unexpected, could not find {methodName} on BakePipelineDriver");
-                if (!gotMethod)
-                {
-                    result = null;
+
+                result = methodInfo.Invoke(m_BakePipelineDriver, parameters);
+
+                return true;
+            }
+
+            // Keep this in sync with the enum in Editor\Src\GI\BakePipeline\BakePipeline.bindings.h
+            public enum StageName
+            {
+                Invalid = -1,
+                Initialized = 0,
+                Preprocess = 1,
+                PreprocessProbes = 2,
+                Bake = 3,
+                PostProcess = 4,
+                AdditionalBake = 5,
+                Done = 6
+            }
+
+            // If StageName is not kept in sync, this should return false
+            static bool IsStageNameEnumConsistent(Type otherType)
+            {
+                string[] ourNames = Enum.GetNames(typeof(StageName));
+                string[] otherNames = Enum.GetNames(otherType);
+
+                if (ourNames.Length != otherNames.Length)
                     return false;
-                }
 
-                result = methodInfo.Invoke(_bakePipelineDriver, parameters);
+                Array ourValues = Enum.GetValues(typeof(StageName));
+                Array otherValues = Enum.GetValues(otherType);
+
+                // Brute-force compare each local name against the external by lookup
+                for (int i = 0; i < ourNames.Length; i++)
+                {
+                    string name = ourNames[i];
+
+                    int otherIndex = Array.IndexOf(otherNames, name);
+                    if (otherIndex < 0)
+                        return false;
+
+                    int ourVal = Convert.ToInt32(ourValues.GetValue(i));
+                    int otherVal = Convert.ToInt32(otherValues.GetValue(otherIndex));
+
+                    if (ourVal != otherVal)
+                        return false;
+                }
 
                 return true;
             }