Internal/6000.3/staging

Packages/com.unity.render-pipelines.core/Editor/Debugging/DebugState.cs

@@ -182,6 +182,35 @@ public sealed class DebugStateInt : DebugState<int> { }
     [Serializable, DebugState(typeof(DebugUI.ObjectPopupField), typeof(DebugUI.CameraSelector), typeof(DebugUI.ObjectField))]
     public sealed class DebugStateObject : DebugState<UnityEngine.Object>
     {
+        [SerializeField] string m_UserData;
+
+        /// <inheritdoc/>
+        public override void SetValue(object value, DebugUI.IValueField field)
+        {
+            // DebugStateObject is used to serialize the selected camera reference in DebugUI.CameraSelector. For SceneView Camera this doesn't work because
+            // the camera is never saved and always recreated. So we use a special string to identify this case and restore the reference later.
+            if (field is DebugUI.CameraSelector && SceneView.lastActiveSceneView != null && (Camera)value == SceneView.lastActiveSceneView.camera)
+            {
+                m_UserData = "SceneViewCamera";
+            }
+            else
+            {
+                m_UserData = null;
+            }
+            base.SetValue(value, field);
+        }
+
+        /// <inheritdoc/>
+        public override object GetValue()
+        {
+            if (value == null && m_UserData != null && m_UserData == "SceneViewCamera" && SceneView.lastActiveSceneView != null && SceneView.lastActiveSceneView.camera != null)
+            {
+                value = SceneView.lastActiveSceneView.camera;
+            }
+
+            return base.GetValue();
+        }
+
         /// <summary>
         /// Returns the hash code of the Debug Item.
         /// </summary>

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

@@ -94,7 +94,7 @@ class DefaultLightTransport : LightingBaker
 
             public override void Initialize(bool bakeProbeOcclusion, NativeArray<Vector3> probePositions)
             {
-                if (!InputExtraction.ExtractFromScene(out input))
+                if (!InputExtraction.ExtractFromScene(out input, true))
                 {
                     Debug.LogError("InputExtraction.ExtractFromScene failed.");
                     return;

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

@@ -109,7 +109,7 @@ public override void Initialize(ProbeVolumeBakingSet bakingSet, NativeArray<Vect
                 batchResult = new Vector3[k_MaxProbeCountPerBatch];
 
                 var computeBufferTarget = GraphicsBuffer.Target.CopyDestination | GraphicsBuffer.Target.CopySource
-                    | GraphicsBuffer.Target.Structured | GraphicsBuffer.Target.Raw;
+                    | GraphicsBuffer.Target.Structured;
 
                 // Create acceletation structure
                 m_AccelerationStructure = BuildAccelerationStructure(voSettings.collisionMask);

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

@@ -428,7 +428,7 @@ void ShowWarnings()
         {
             for (int i = 0; i < SceneManager.sceneCount; i++)
             {
-                var scene = SceneManager.GetSceneAt(i);
+                Scene scene = SceneManager.GetSceneAt(i);
                 if (scene.isLoaded && ProbeVolumeBakingSet.GetBakingSetForScene(scene) != activeSet)
                     scenesToUnload.Add(scene);
             }
@@ -467,7 +467,7 @@ void ShowWarnings()
                             if (scenesToUnload.All(s => !s.isDirty) || EditorSceneManager.SaveCurrentModifiedScenesIfUserWantsTo())
                             {
                                 foreach (var scene in scenesToUnload)
-                                    EditorSceneManager.CloseScene(scene, false);
+                                    EditorSceneManager.CloseScene(scene, string.IsNullOrEmpty(scene.path)); // Remove the scene from the hierarchy iff it has never been saved.
                             }
                             break;
                     }

Packages/com.unity.render-pipelines.core/Editor/Lighting/ProbeVolume/VirtualOffset/TraceVirtualOffset.urtshader

@@ -87,21 +87,22 @@ void RayGenExecute(UnifiedRT::DispatchInfo dispatchInfo)
         if (!hit.IsValid() || hit.isFrontFace)
         {
             validHits++;
-            continue;
         }
-
-        float distanceDiff = hit.hitDistance - minDist;
-        if (distanceDiff < DISTANCE_THRESHOLD)
+        else if (hit.IsValid())
         {
-            UnifiedRT::HitGeomAttributes attributes = UnifiedRT::FetchHitGeomAttributes(hit, UnifiedRT::kGeomAttribFaceNormal);
-            float dotSurface = dot(ray.direction, attributes.faceNormal);
-
-            // If new distance is smaller by at least kDistanceThreshold, or if ray is at least DOT_THRESHOLD more colinear with normal
-            if (distanceDiff < -DISTANCE_THRESHOLD || dotSurface - maxDotSurface > DOT_THRESHOLD)
+            float distanceDiff = hit.hitDistance - minDist;
+            if (distanceDiff < DISTANCE_THRESHOLD)
             {
-                outDirection = ray.direction;
-                maxDotSurface = dotSurface;
-                minDist = hit.hitDistance;
+                UnifiedRT::HitGeomAttributes attributes = UnifiedRT::FetchHitGeomAttributes(hit, UnifiedRT::kGeomAttribFaceNormal);
+                float dotSurface = dot(ray.direction, attributes.faceNormal);
+
+                // If new distance is smaller by at least kDistanceThreshold, or if ray is at least DOT_THRESHOLD more colinear with normal
+                if (distanceDiff < -DISTANCE_THRESHOLD || dotSurface - maxDotSurface > DOT_THRESHOLD)
+                {
+                    outDirection = ray.direction;
+                    maxDotSurface = dotSurface;
+                    minDist = hit.hitDistance;
+                }
             }
         }
     }

Packages/com.unity.render-pipelines.core/Editor/RenderGraph/RenderGraphTestsCore.cs

@@ -187,7 +187,7 @@ public void CleanupRenderGraph()
             m_RenderGraphTestPipeline.invalidContextForTesting = false;
             // Cleaning all Render Graph resources and data structures
             // Nothing remains, Render Graph in next test will start from scratch
-            m_RenderGraph.ForceCleanup();
+            m_RenderGraph.CleanupResourcesAndGraph();
         }
     }
 }

Packages/com.unity.render-pipelines.core/Editor/Upscaling/DLSSOptionsEditor.cs

@@ -0,0 +1,167 @@
+#if UNITY_EDITOR
+#if ENABLE_UPSCALER_FRAMEWORK && ENABLE_NVIDIA && ENABLE_NVIDIA_MODULE
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.NVIDIA;
+
+[CustomEditor(typeof(DLSSOptions))]
+public class DLSSOptionsEditor : Editor
+{
+    // Declare variables to hold each property
+    private SerializedProperty m_QualityMode;
+    private SerializedProperty m_FixedResolution;
+    private SerializedProperty m_PresetQuality;
+    private SerializedProperty m_PresetBalanced;
+    private SerializedProperty m_PresetPerformance;
+    private SerializedProperty m_PresetUltraPerformance;
+    private SerializedProperty m_PresetDLAA;
+    private void OnEnable()
+    {
+        // Find each property by its exact field name in DLSSOptions.cs
+        m_QualityMode = serializedObject.FindProperty("DLSSQualityMode");
+        m_FixedResolution = serializedObject.FindProperty("FixedResolutionMode");
+        m_PresetQuality = serializedObject.FindProperty("DLSSRenderPresetQuality");
+        m_PresetBalanced = serializedObject.FindProperty("DLSSRenderPresetBalanced");
+        m_PresetPerformance = serializedObject.FindProperty("DLSSRenderPresetPerformance");
+        m_PresetUltraPerformance = serializedObject.FindProperty("DLSSRenderPresetUltraPerformance");
+        m_PresetDLAA = serializedObject.FindProperty("DLSSRenderPresetDLAA");
+    }
+
+    #region STYLES
+    private static readonly string[] DLSSPerfQualityLabels =
+    {   // should follow enum value ordering in DLSSQuality enum
+        DLSSQuality.MaximumPerformance.ToString(),
+        DLSSQuality.Balanced.ToString(),
+        DLSSQuality.MaximumQuality.ToString(),
+        DLSSQuality.UltraPerformance.ToString(),
+        DLSSQuality.DLAA.ToString()
+    };
+    private static string[][] DLSSPresetOptionsForEachPerfQuality = PopulateDLSSQualityPresetLabels();
+    private static string[][] PopulateDLSSQualityPresetLabels()
+    {
+        int CountBits(uint bitMask) // System.Numerics.BitOperations not available
+        {
+            int count = 0;
+            while (bitMask > 0)
+            {
+                count += (bitMask & 1) > 0 ? 1 : 0;
+                bitMask >>= 1;
+            }
+            return count;
+        }
+
+        System.Array perfQualities = System.Enum.GetValues(typeof(DLSSQuality));
+        string[][] labels = new string[perfQualities.Length][];
+        foreach (DLSSQuality quality in perfQualities)
+        {
+            uint presetBitmask = GraphicsDevice.GetAvailableDLSSPresetsForQuality(quality);
+            int numPresets = CountBits(presetBitmask) + 1; // +1 for default option which is available to all quality enums
+            labels[(int)quality] = new string[numPresets];
+
+            int iWrite = 0;
+            System.Array presets = System.Enum.GetValues(typeof(DLSSPreset));
+            foreach (DLSSPreset preset in presets)
+            {
+                if (preset == DLSSPreset.Preset_Default)
+                {
+                    labels[(int)quality][iWrite++] = "Default Preset";
+                    continue;
+                }
+
+                if ((presetBitmask & (uint)preset) != 0)
+                {
+                    string presetName = preset.ToString().Replace('_', ' ');
+                    labels[(int)quality][iWrite++] = presetName + " - " + GraphicsDevice.GetDLSSPresetExplanation(preset);
+                }
+            }
+        }
+        return labels;
+    }
+
+    private static readonly GUIContent renderPresetsLabel = new GUIContent("Render Presets", "Selects an internal DLSS tuning profile. Presets adjust reconstruction behavior, trading off between sharpness, stability, and performance. Different presets may work better depending on scene content and motion.");
+    #endregion
+
+
+    // DLSSOptions contain DLSS presets for each quality mode.
+    // The presets available for each quality mode may be different from one another and change over time between DLSS releases.
+    // E.g.     DLAAPreset = { F, J, K }
+    //      BalancedPreset = { J, K }
+    // Instead of letting Unity default-render the GUI, we write our own inspector logic to enforce the preset value requirements.
+    void DrawPresetDropdown(ref SerializedProperty presetProp, DLSSQuality perfQuality)
+    {
+        // each DLSSQuality has a different set of DLSSPresets, represented by a bitmask.
+        uint presetBitmask = GraphicsDevice.GetAvailableDLSSPresetsForQuality(perfQuality);
+        bool propHasInvalidPresetValue = presetProp.uintValue != 0 && (presetBitmask & presetProp.uintValue) == 0;
+        if (propHasInvalidPresetValue)
+        {
+            Debug.LogWarningFormat("DLSS Preset {0} not found for quality setting {1}, resetting to default value.",
+                ((DLSSPreset)presetProp.uintValue).ToString(),
+                perfQuality.ToString()
+            );
+            presetProp.uintValue = 0;
+        }
+
+        // We don't want to deal with List<DLSSPreset> & using bitmasks,
+        // so we need some bit ops to convert between GUI index <--> Preset value
+        int FindPresetGUIIndex(uint presetBitmask, uint presetValue)
+        {
+            int i = 0;
+            while (presetValue > 0)
+            {
+                i += (presetBitmask & 1) > 0 ? 1 : 0;
+                presetBitmask >>= 1;
+                presetValue >>= 1;
+            }
+            return i; // includes 0=default, goes like 1=preset_A, 2=preset_B ...
+        }
+        uint GUIIndexToPresetValue(uint presetBitmask, uint index)
+        {
+            // e.g. bitset: 100101 --> 3 bits set, supports 4 presets (0=default, +3 other presets).
+            //                   ^ i = 1 -> Preset A = 1
+            //                 ^   i = 2 -> Preset C = 4
+            //              ^      i = 3 -> Preset F = 32
+            uint val = 0;
+            while (index > 0 && presetBitmask > 0)
+            {
+                if ((presetBitmask & 1) != 0)
+                    --index;
+                presetBitmask >>= 1;
+                val = val == 0 ? 1 : (val << 1);
+            }
+            if (index != 0)
+            {
+                Debug.LogWarningFormat("DLSSPreset (index={0}) not found in the supported preset list (mask={1}), setting to default value.", index, presetBitmask);
+                return 0;
+            }
+            // Debug.LogFormat("Setting preset {0} : {1}", ((DLSSPreset)val).ToString(), val);
+            return val;
+        }
+
+        int presetIndex = FindPresetGUIIndex(presetBitmask, presetProp.uintValue);
+        int iNew = EditorGUILayout.Popup(DLSSPerfQualityLabels[(int)perfQuality], presetIndex, DLSSPresetOptionsForEachPerfQuality[(int)perfQuality]);
+        if (iNew != presetIndex)
+            presetProp.uintValue = GUIIndexToPresetValue(presetBitmask, (uint)iNew);
+    }
+    public override void OnInspectorGUI()
+    {
+        serializedObject.Update();
+
+        EditorGUILayout.PropertyField(m_QualityMode);
+        EditorGUILayout.PropertyField(m_FixedResolution);
+
+        EditorGUILayout.LabelField(renderPresetsLabel, EditorStyles.boldLabel);
+        ++EditorGUI.indentLevel;
+
+        DrawPresetDropdown(ref m_PresetQuality, DLSSQuality.MaximumQuality);
+        DrawPresetDropdown(ref m_PresetBalanced, DLSSQuality.Balanced);
+        DrawPresetDropdown(ref m_PresetPerformance, DLSSQuality.MaximumPerformance);
+        DrawPresetDropdown(ref m_PresetUltraPerformance, DLSSQuality.UltraPerformance);
+        DrawPresetDropdown(ref m_PresetDLAA, DLSSQuality.DLAA);
+
+        --EditorGUI.indentLevel;
+
+        serializedObject.ApplyModifiedProperties();
+    }
+}
+#endif
+#endif

Packages/com.unity.render-pipelines.core/Editor/Upscaling/UpscalerOptionsEditor.cs

@@ -0,0 +1,20 @@
+#if ENABLE_UPSCALER_FRAMEWORK
+#if UNITY_EDITOR
+using UnityEditor;
+
+/// <summary>
+/// This custom editor ensures that when drawing any UpscalerOptions object,
+/// the default "Script" field is not shown. Applies to all derived options.
+/// </summary>
+[CustomEditor(typeof(UnityEngine.Rendering.UpscalerOptions), true)]
+public class UpscalerOptionsEditor : Editor
+{
+    public override void OnInspectorGUI()
+    {
+        // DrawDefaultInspector renders all serialized fields except for the "Script" field
+        // and any fields marked with [HideInInspector].
+        DrawDefaultInspector();
+    }
+}
+#endif
+#endif

Packages/com.unity.render-pipelines.core/Editor/Upscaling/UpscalerOptionsEditorCache.cs

@@ -0,0 +1,52 @@
+#if ENABLE_UPSCALER_FRAMEWORK
+#if UNITY_EDITOR
+using System.Collections.Generic;
+using UnityEditor;
+
+namespace UnityEngine.Rendering
+{
+#nullable enable
+    /// <summary>
+    /// Manages the lifecycle of cached editors for UpscalerOptions ScriptableObjects.
+    /// </summary>
+    public class UpscalerOptionsEditorCache
+    {
+        private readonly Dictionary<ScriptableObject, Editor> m_EditorCache = new Dictionary<ScriptableObject, Editor>();
+
+        /// <summary>
+        /// Gets a cached editor for the given @options. If the editor is not
+        /// found in the cache, a new editor is created and then cached.
+        /// </summary>
+        public Editor? GetOrCreateEditor(ScriptableObject options)
+        {
+            if (options == null)
+                return null;
+
+            if (!m_EditorCache.TryGetValue(options, out var editor) || editor == null)
+            {
+                editor = Editor.CreateEditor(options);
+                m_EditorCache[options] = editor;
+            }
+
+            return editor;
+        }
+
+        /// <summary>
+        /// Destroys all cached editor instances.
+        /// Call this from the parent editor's OnDisable method.
+        /// </summary>
+        public void Cleanup()
+        {
+            foreach (var editor in m_EditorCache.Values)
+            {
+                if (editor != null)
+                    Object.DestroyImmediate(editor);
+            }
+            m_EditorCache.Clear();
+        }
+    }
+
+#nullable disable
+}
+#endif
+#endif // ENABLE_UPSCALER_FRAMEWORK

Packages/com.unity.render-pipelines.core/Editor/Volume/VolumeComponentListEditor.cs

@@ -202,7 +202,8 @@ void RefreshEditors()
             // Recreate editors for existing settings, if any
             var components = asset.components;
             for (int i = 0; i < components.Count; i++)
-                CreateEditor(components[i], m_ComponentsProperty.GetArrayElementAtIndex(i));
+                if (components[i] != null) //can happens if a component type is removed and opening old serialized data
+                    CreateEditor(components[i], m_ComponentsProperty.GetArrayElementAtIndex(i));
 
             m_CurrentHashCode = asset.GetComponentListHashCode();