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

Internal/master

Author: claire-nicholson

.gitattributes

@@ -378,3 +378,7 @@ Editor/Resources/unity[[:space:]]editor[[:space:]]resources filter=lfs diff=lfs
 
 # buginfo tools
 /Tools/Unity.BugInfo.Coverage/bin/* filter=lfs diff=lfs merge=lfs -text
+
+# search test cases
+/Modules/QuickSearch/Tests/QuickSearch/Assets/Cases/UUM-113048/uum-113048.index filter=lfs diff=lfs merge=lfs -text
+

Packages/com.unity.render-pipelines.core/Documentation~/Examples/BlitColorAndDepth.shader

@@ -5,7 +5,7 @@ Shader "Hidden/Universal/CoreBlitColorAndDepth"
         #pragma editor_sync_compilation
         // Core.hlsl for XR dependencies
         #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
-        #include "Packages/com.unity.render-pipelines.core/Runtime/Utilities/BlitColorAndDepth.hlsl"
+        #include_with_pragmas "Packages/com.unity.render-pipelines.core/Runtime/Utilities/BlitColorAndDepth.hlsl"
     ENDHLSL
 
     SubShader

Packages/com.unity.render-pipelines.core/Documentation~/Images/videos/light-anchor-animation.mp4

@@ -1,4 +1,8 @@
-# What's new in SRP Core 17.1 / Unity 6.1
+# What's new in SRP Core 17 / Unity 6
+
+**Note:** Starting with 17.2 (Unity 6.2), refer to [What’s new in Unity](xref:um-whats-new) for the latest updates and improvements.
+
+## What's new in SRP Core 17.1 / Unity 6.1
 The following are the new features and improvements added to the SRP Core package 17.1, embedded Unity 6.1.
 
 ## Added

Packages/com.unity.render-pipelines.core/Documentation~/whats-new-17.md

@@ -0,0 +1,110 @@
+using System;
+using System.IO;
+using UnityEngine;
+
+namespace UnityEditor.RenderPipelines.Core
+{
+    internal static class AssetCreationUtil
+    {
+        /// <summary>
+        /// Prompts the user to save a new <seealso cref="Shader"/> asset created from the shader template, and creates and <seealso cref="Material"/> with it.
+        /// </summary>
+        /// <param name="name">Default material name.</param>
+        /// <param name="callback">A delegate (callback) that will be invoked with the <see cref="Material"/>.</param>
+        /// <param name="shaderTemplateAssetPath">Path of the Shader Template file.</param>
+        internal static void CreateShaderAndMaterial(string name, Action<Material> callback, string shaderTemplateAssetPath)
+        {
+            CreateShader(
+                name,
+                (shader) =>
+                {
+                    Material material = new Material(shader);
+                    var path = AssetDatabase.GetAssetPath(shader);
+                    AssetDatabase.CreateAsset(material, Path.Combine(Path.GetDirectoryName(path), Path.GetFileNameWithoutExtension(path) + ".mat"));
+                    AssetDatabase.SaveAssetIfDirty(material);
+                    AssetDatabase.Refresh(ImportAssetOptions.Default);
+                    callback?.Invoke(material);
+                },
+                shaderTemplateAssetPath);
+        }
+
+        /// <summary>
+        /// Prompts the user to save a new <seealso cref="Material"/> asset created using the <paramref name="shader"/>.
+        /// </summary>
+        /// <param name="name">Default material name.</param>
+        /// <param name="callback">A delegate (callback) that will be invoked with the <see cref="Material"/>.</param>
+        /// <param name="shader"><seealso cref="Shader"/> to create the new <seealso cref="Material"/> with.</param>
+        internal static void CreateMaterial(string name, Action<Material> callback, Shader shader)
+        {
+            if (shader == null)
+            {
+                Debug.LogError($"Null Shader reference. Cannot create Material {name}.");
+                return;
+            }
+
+            CreateAsset(
+                name,
+                (materialPath) =>
+                {
+                    Material material = new Material(shader);
+                    AssetDatabase.CreateAsset(material, materialPath);
+                    AssetDatabase.SaveAssetIfDirty(material);
+                    AssetDatabase.Refresh(ImportAssetOptions.Default);
+                    callback?.Invoke(material);
+                },
+                "mat",
+                typeof(Material)
+            );
+        }
+
+        internal static void CreateShader(string name, Action<Shader> callback, string shaderTemplateAssetPath)
+        {
+            if (!AssetDatabase.AssetPathExists(shaderTemplateAssetPath))
+            {
+                Debug.LogError($"Shader Template File missing at path: {shaderTemplateAssetPath}.");
+                return;
+            }
+
+            CreateAsset(
+                name,
+                (shaderPath) =>
+                {
+                    string fileName = Path.GetFileNameWithoutExtension(shaderPath);
+                    string templateCode = File.ReadAllText(shaderTemplateAssetPath);
+                    templateCode = templateCode.Replace("#SCRIPTNAME#", fileName);
+                    File.WriteAllText(shaderPath, templateCode);
+
+                    AssetDatabase.Refresh();
+                    AssetDatabase.ImportAsset(shaderPath);
+                    Shader shader = AssetDatabase.LoadAssetAtPath<Shader>(shaderPath);
+
+                    callback?.Invoke(shader);
+                },
+                "shader",
+                typeof(Shader)
+            );
+        }
+
+        static void CreateAsset(string name, Action<string> callback = null, string extension = "asset", Type type = null)
+        {
+            AssetCreationCallback assetCreationCallback = ScriptableObject.CreateInstance<AssetCreationCallback>();
+            assetCreationCallback.callback = callback;
+            assetCreationCallback.extension = extension;
+
+            var icon = AssetPreview.GetMiniTypeThumbnail(type);
+            ProjectWindowUtil.StartNameEditingIfProjectWindowExists(0, assetCreationCallback, name, icon, null, false);
+        }
+
+        class AssetCreationCallback : ProjectWindowCallback.EndNameEditAction
+        {
+            public Action<string> callback;
+            public string extension;
+
+            public override void Action(int instanceId, string pathName, string resourceFile)
+            {
+                string path = AssetDatabase.GenerateUniqueAssetPath(pathName + $".{extension}");
+                callback?.Invoke(path);
+            }
+        }
+    }
+}

Packages/com.unity.render-pipelines.high-definition/Editor/Upgraders.meta renamed to Packages/com.unity.render-pipelines.core/Editor-PrivateShared/AssetCallbacks.meta

@@ -3,6 +3,6 @@
 [assembly: InternalsVisibleTo("Unity.RenderPipelines.Core.Editor.Shared")]
 [assembly: InternalsVisibleTo("Unity.RenderPipelines.Core.Editor.Tests")]
 [assembly: InternalsVisibleTo("Unity.RenderPipelines.HighDefinition.Editor.Tests")]
-[assembly: InternalsVisibleTo("Unity.RenderPipelines.HighDefinition.Editor.Tests")]
+[assembly: InternalsVisibleTo("Unity.RenderPipelines.Universal.Editor.Tests")]
 [assembly: InternalsVisibleTo("Assembly-CSharp-Editor-testable")]
 

Packages/com.unity.render-pipelines.core/Editor-PrivateShared/AssetCallbacks/AssetCreationUtil.cs

@@ -1,4 +1,5 @@
-area: SRP Settings
+default:
+  area: SRP Settings
 
 graphic-tools:
   when:

Packages/com.unity.render-pipelines.core/Editor-PrivateShared/AssetCallbacks/AssetCreationUtil.cs.meta

@@ -0,0 +1,89 @@
+using System;
+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
+        {
+            // 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;
+
+            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");
+            }
+
+            internal void StartBake(bool enablePatching, ref float progress, ref StageName stage)
+            {
+                SetEnableBakedLightmaps(false); // Additional only
+                SetEnablePatching(enablePatching);
+                Update(false, true, true, out progress, out stage);
+            }
+
+            internal bool RunInProgress()
+            {
+                if (!InvokeMethod(new object[] { }, out object result))
+                    return false;
+
+                return result is true;
+            }
+
+            internal void Step(ref float progress, ref StageName stage) =>
+                Update(true, true, true, out progress, out stage);
+
+            private void SetEnableBakedLightmaps(bool enable) =>
+                InvokeMethod(new object[] { enable }, out _);
+
+            private void SetEnablePatching(bool enable) =>
+                InvokeMethod(new object[] { enable }, out _);
+
+            private void Update(bool isOnDemandBakeInProgress, bool isOnDemandBakeAsync, bool shouldBeRunning,
+                out float progress, out StageName stage)
+            {
+                object[] parameters = { isOnDemandBakeInProgress, isOnDemandBakeAsync, shouldBeRunning, -1.0f, -1 };
+                InvokeMethod(parameters, out _);
+                progress = (float)parameters[3];
+                stage = (StageName)parameters[4];
+            }
+
+            public void Dispose() =>
+                InvokeMethod(new object[] { }, out _);
+
+            private bool InvokeMethod(object[] parameters, out object result, [CallerMemberName] string methodName = "")
+            {
+                MethodInfo methodInfo = _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;
+                    return false;
+                }
+
+                result = methodInfo.Invoke(_bakePipelineDriver, parameters);
+
+                return true;
+            }
+        }
+    }
+}