[Render Pipeline Converter] BiRP to URP 2D : Adding readonly materials converter workflow.

Author: alex-vazquez-unity3d

Packages/com.unity.render-pipelines.core/Editor-PrivateShared/Tools/Converter/ReadonlyMaterialConverter/ReadonlyMaterialConverter.MaterialReferenceChanger.cs

@@ -117,6 +117,7 @@ internal bool ReassignGameObjectMaterials(GameObject go, StringBuilder errors)
                     catch (Exception ex)
                     {
                         errors.Append($"{ex.Message} while trying to reassign materials from {component}.");
+                        ok = false;
                     }
                 }
             }

Packages/com.unity.render-pipelines.universal/Editor/2D/Converter/BuiltInToURP2DReadonlyMaterialConverter.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Generic;
+using UnityEditor.Rendering.Converter;
+using UnityEngine;
+using UnityEngine.Categorization;
+using UnityEngine.Rendering;
+using UnityEngine.Rendering.Universal;
+
+namespace UnityEditor.Rendering.Universal
+{
+    [Serializable]
+    [PipelineConverter("Built-in", "Universal Render Pipeline (2D Renderer)")]
+    [ElementInfo(Name = "Material Reference Converter",
+                 Order = 100,
+                 Description = "Converts references to Built-In readonly materials to URP (2D) readonly materials.")]
+    internal class BuiltInToURP2DReadonlyMaterialConverter : ReadonlyMaterialConverter
+    {
+        public override bool isEnabled
+        {
+            get
+            {
+                if (GraphicsSettings.currentRenderPipeline is not UniversalRenderPipelineAsset urpAsset)
+                    return false;
+
+                return urpAsset.scriptableRenderer is Renderer2D;
+            }
+        }
+
+        public override string isDisabledMessage => "Converter requires URP with a Renderer 2D. Convert your project to URP to use this converter.";
+
+        protected override Dictionary<string, Func<Material>> materialMappings
+        {
+            get
+            {
+                return new()
+                {
+                    ["Default-Material"] = () => GraphicsSettings.GetRenderPipelineSettings<Renderer2DResources>().defaultMesh2DLitMaterial,
+                    ["Sprites-Default"] = () => GraphicsSettings.GetRenderPipelineSettings<Renderer2DResources>().defaultLitMaterial,
+                    ["Sprites-Mask"] = () => GraphicsSettings.GetRenderPipelineSettings<Renderer2DResources>().defaultMaskMaterial,
+                };
+            }
+        }
+    }
+}

Packages/com.unity.render-pipelines.universal/Editor/2D/Converter/BuiltInToURP2DReadonlyMaterialConverter.cs.meta

@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+using UnityEditor.Rendering.Converter;
+using UnityEngine;
+using UnityEngine.Categorization;
+using UnityEngine.Rendering;
+using UnityEngine.Rendering.Universal;
+
+namespace UnityEditor.Rendering.Universal
+{
+    [Serializable]
+    [PipelineConverter("Universal Render Pipeline (Universal Renderer)", "Universal Render Pipeline (2D Renderer)")]
+    [ElementInfo(Name = "Material Reference Converter",
+                 Order = 100,
+                 Description = "Converts references to URP Lit and Simple Lit readonly material to Mesh 2D Lit material.")]
+    internal class URP3DToURP2DReadonlyMaterialConverter : ReadonlyMaterialConverter
+    {
+        private List<(string query, string description)> m_ContextSearchQueriesAndIds;
+        private Dictionary<string, Func<Material>> m_MaterialMappings;
+
+        public override bool isEnabled
+        {
+            get
+            {
+                if (GraphicsSettings.currentRenderPipeline is not UniversalRenderPipelineAsset urpAsset)
+                    return false;
+                return urpAsset.scriptableRenderer is Renderer2D;
+            }
+        }
+
+        public override string isDisabledMessage => "Converter requires URP with a Renderer 2D. Convert your project to URP to use this converter.";
+
+        private bool m_Initialized = false;
+
+        private void InitializeIfNeeded()
+        {
+            if (m_Initialized)
+                return;
+
+            m_Initialized = true;
+
+            var urpMaterials = GraphicsSettings.GetRenderPipelineSettings<UniversalRenderPipelineEditorMaterials>();
+            var lit = urpMaterials.defaultMaterial;
+            var simpleLit = urpMaterials.simpleLitMaterial;
+
+            // -t:RenderPipelineGlobalSettings is to avoid adding the Global Settings as they reference the URP Lit and Simple Lit materials
+            // We do not want to modify them as part of this conversion, because they must keep referencing the URP 3D materials.
+            const string formattedId = "p: ref=<$object:{0},UnityEngine.Object$> -t:RenderPipelineGlobalSettings";
+
+            m_ContextSearchQueriesAndIds = new List<(string query, string description)>()
+            {
+                (string.Format(formattedId, GlobalObjectId.GetGlobalObjectIdSlow(lit)), "URP Lit is being referenced"),
+                (string.Format(formattedId, GlobalObjectId.GetGlobalObjectIdSlow(simpleLit)), "URP Simple Lit is being referenced")
+            };
+
+            Func<Material> mesh2DLitMaterial = () => GraphicsSettings.GetRenderPipelineSettings<Renderer2DResources>().defaultMesh2DLitMaterial;
+
+            m_MaterialMappings = new Dictionary<string, Func<Material>>()
+            {
+                ["Lit"] = mesh2DLitMaterial,
+                ["SimpleLit"] = mesh2DLitMaterial
+            };
+        }
+
+        protected override List<(string query, string description)> contextSearchQueriesAndIds
+        {
+            get
+            {
+                InitializeIfNeeded();
+                return m_ContextSearchQueriesAndIds;
+            }
+        }
+
+        protected override Dictionary<string, Func<Material>> materialMappings
+        {
+            get
+            {
+                InitializeIfNeeded();
+                return m_MaterialMappings;
+            }
+        }
+    }
+}

Packages/com.unity.render-pipelines.universal/Editor/2D/Converter/URP3DToURP2DReadonlyMaterialConverter.cs

@@ -101,7 +101,7 @@ public enum ConverterId
         /// <summary>
         /// Use this for 2D material conversion
         /// </summary>
-        [BatchModeConverterInfo(ConverterContainerId.BuiltInToURP2D, typeof(BuiltInToURP2DMaterialUpgrader))]
+        [BatchModeConverterInfo(ConverterContainerId.BuiltInToURP2D, typeof(BuiltInToURP2DReadonlyMaterialConverter))]
         ReadonlyMaterial2D,
 
         /// <summary>

Packages/com.unity.render-pipelines.universal/Editor/2D/Converter/URP3DToURP2DReadonlyMaterialConverter.cs.meta

@@ -12,11 +12,20 @@ namespace UnityEditor.Rendering.Universal
     [PipelineConverter("Built-in", "Universal Render Pipeline (Universal Renderer)")]
     [ElementInfo(Name = "Material Reference Converter",
                  Order = 100,
-                 Description = "Converts references to Built-In readonly materials to URP readonly materials. This will create temporarily a .index file and that can take a long time.")]
+                 Description = "Converts references to Built-In readonly materials to URP readonly materials.")]
     internal class BuiltInToURP3DReadonlyMaterialConverter : ReadonlyMaterialConverter
     {
-        public override bool isEnabled => GraphicsSettings.currentRenderPipeline is UniversalRenderPipelineAsset;
-        public override string isDisabledMessage => "Converter requires URP. Convert your project to URP to use this converter.";
+        public override bool isEnabled
+        {
+            get
+            {
+                if (GraphicsSettings.currentRenderPipeline is not UniversalRenderPipelineAsset urpAsset)
+                    return false;
+
+                return urpAsset.scriptableRenderer is UniversalRenderer;
+            }
+        }
+        public override string isDisabledMessage => "Converter requires URP with an Universal Renderer. Convert your project to URP to use this converter.";
 
         protected override Dictionary<string, Func<Material>> materialMappings
         {

Packages/com.unity.render-pipelines.universal/Editor/Converter/Converters.cs

@@ -20,6 +20,16 @@ public virtual Material defaultMaterial
             set => this.SetValueAndNotify(ref m_DefaultMaterial, value);
         }
 
+        [SerializeField]
+        [ResourcePath("Runtime/Materials/SimpleLit.mat")]
+        private Material m_SimpleLitMaterial;
+
+        public virtual Material simpleLitMaterial
+        {
+            get => m_SimpleLitMaterial;
+            set => this.SetValueAndNotify(ref m_SimpleLitMaterial, value);
+        }
+
         // This is the URP default material for new particle systems, is the closest match to the built-in shader.
         [SerializeField]
         [ResourcePath("Runtime/Materials/ParticlesUnlit.mat")]

Packages/com.unity.render-pipelines.universal/Editor/Tools/Converters/BuiltInToURP3DReadonlyMaterialConverter.cs

@@ -112,7 +112,7 @@ public static IEnumerable<TestCaseData> TestCases()
                 ConverterFilter.Exclusive,
                  new List<Type>
                  {
-                    typeof(BuiltInToURP2DMaterialUpgrader),
+                    typeof(BuiltInToURP2DReadonlyMaterialConverter),
                  }
             ).SetName("BuiltInToURP2D - When Using Exclusive filter with no converters. The filter returns everything");