Adaug proiectul Unity

Library/PackageCache/com.unity.render-pipelines.universal@ffe395a3a1d1/Editor/2D/Converter/BuiltInPixelPerfectCameraConverter.cs

@@ -0,0 +1,172 @@
+using System;
+using System.Collections.Generic;
+using UnityEditor.Rendering.Converter;
+using UnityEngine;
+using UnityEngine.Categorization;
+
+using URPPackage = UnityEngine.Rendering.Universal;
+
+#if PIXEL_PERFECT_2D_EXISTS
+using U2DPackage = UnityEngine.U2D;
+#endif
+
+namespace UnityEditor.Rendering.Universal
+{
+    [Serializable]
+    internal class PixelPerfectCameraConverterItem : RenderPipelineConverterAssetItem
+    {
+        public PixelPerfectCameraConverterItem(string id) : base(id)
+        {
+        }
+
+        public PixelPerfectCameraConverterItem(GlobalObjectId gid, string assetPath) : base(gid, assetPath)
+        {
+        }
+
+        public new Texture2D icon => EditorGUIUtility.ObjectContent(null, typeof(UnityEngine.Camera)).image as Texture2D;
+    }
+
+    [Serializable]
+    [PipelineConverter("Built-in", "Universal Render Pipeline (2D Renderer)")]
+    [ElementInfo(Name = "Pixel Perfect Camera Converter",
+             Order = 1000,
+             Description = "This will upgrade all 2D Pixel Perfect Camera (com.unity.2d.pixelperfect) to the Universal Render Pipeline version.")]
+    internal class BuiltInPixelPerfectCameraConverter : IRenderPipelineConverter
+    {
+
+#if PIXEL_PERFECT_2D_EXISTS
+        public bool isEnabled => true;
+        public string isDisabledMessage { get; }
+
+        public static bool UpgradePixelPerfectCamera(U2DPackage.PixelPerfectCamera cam)
+        {
+            if (cam == null)
+                return false;
+
+            // Copy over serialized data
+            var urpCam = cam.gameObject.AddComponent<URPPackage.PixelPerfectCamera>();
+
+            if (urpCam == null)
+                return false;
+
+            urpCam.assetsPPU = cam.assetsPPU;
+            urpCam.refResolutionX = cam.refResolutionX;
+            urpCam.refResolutionY = cam.refResolutionY;
+
+            if (cam.upscaleRT)
+                urpCam.gridSnapping = URPPackage.PixelPerfectCamera.GridSnapping.UpscaleRenderTexture;
+            else if (cam.pixelSnapping)
+                urpCam.gridSnapping = URPPackage.PixelPerfectCamera.GridSnapping.PixelSnapping;
+
+            if (cam.cropFrameX && cam.cropFrameY)
+            {
+                if (cam.stretchFill)
+                    urpCam.cropFrame = URPPackage.PixelPerfectCamera.CropFrame.StretchFill;
+                else
+                    urpCam.cropFrame = URPPackage.PixelPerfectCamera.CropFrame.Windowbox;
+            }
+            else if (cam.cropFrameX)
+            {
+                urpCam.cropFrame = URPPackage.PixelPerfectCamera.CropFrame.Pillarbox;
+            }
+            else if (cam.cropFrameY)
+            {
+                urpCam.cropFrame = URPPackage.PixelPerfectCamera.CropFrame.Letterbox;
+            }
+            else
+            {
+                urpCam.cropFrame = URPPackage.PixelPerfectCamera.CropFrame.None;
+            }
+
+            UnityEngine.Object.DestroyImmediate(cam, true);
+
+            EditorUtility.SetDirty(urpCam);
+
+            return true;
+        }
+
+        void UpgradeGameObject(GameObject go)
+        {
+            var cam = go.GetComponentInChildren<U2DPackage.PixelPerfectCamera>();
+
+            if (cam != null)
+                UpgradePixelPerfectCamera(cam);
+        }
+
+#else
+        public bool isEnabled => false;
+        public string isDisabledMessage => "Pixel Perfect package is not installed. Please install the Pixel Perfect package to enable this converter.";
+#endif
+
+        public void Scan(Action<List<IRenderPipelineConverterItem>> onScanFinish)
+        {
+#if PIXEL_PERFECT_2D_EXISTS
+            var returnList = new List<IRenderPipelineConverterItem>();
+            void OnSearchFinish()
+            {
+                onScanFinish?.Invoke(returnList);
+            }
+
+            var processedIds = new HashSet<string>();
+
+            SearchServiceUtils.RunQueuedSearch
+            (
+                SearchServiceUtils.IndexingOptions.DeepSearch,
+                new List<(string query, string description)> { ("t:UnityEngine.U2D.PixelPerfectCamera", "Game Objects Referencing a U2D Pixel Perfect Camera") },
+                (item, description) =>
+                {
+                    // Direct conversion - works for both assets and scene objects
+                    var unityObject = item.ToObject();
+
+                    if (unityObject == null)
+                        return;
+
+                    // Ensure we're always working with GameObjects
+                    GameObject go = null;
+
+                    if (unityObject is GameObject gameObject)
+                        go = gameObject;
+                    else if (unityObject is Component component)
+                        go = component.gameObject;
+                    else
+                        return; // Not a GameObject or Component
+
+                    var gid = GlobalObjectId.GetGlobalObjectIdSlow(go);
+                    if (!processedIds.Add(gid.ToString()))
+                        return;
+
+                    int type = gid.identifierType; // 1=Asset, 2=SceneObject
+
+                    var go = unityObject as GameObject;
+                    var ppCameraItem = new PixelPerfectCameraConverterItem(gid.ToString())
+                    {
+                        name = $"{unityObject.name} ({(type == 1 ? "Prefab" : "SceneObject")})",
+                        info = type == 1 ? AssetDatabase.GetAssetPath(unityObject) : go.scene.path,
+                    };
+
+                    returnList.Add(ppCameraItem);
+                },
+                OnSearchFinish
+            );
+#else
+            throw new InvalidOperationException();
+#endif
+        }
+
+        public Status Convert(IRenderPipelineConverterItem item, out string message)
+        {
+            message = string.Empty;
+
+#if PIXEL_PERFECT_2D_EXISTS
+            if (item is PixelPerfectCameraConverterItem ppCameraItem)
+            {
+                if (ppCameraItem.type == 1) URP2DConverterUtility.UpgradePrefab(ppCameraItem.info, UpgradeGameObject);
+                else URP2DConverterUtility.UpgradeScene(ppCameraItem.info, UpgradeGameObject);
+
+                return Status.Success;
+            }
+#endif
+            return Status.Error;
+        }
+    }
+}

Library/PackageCache/com.unity.render-pipelines.universal@ffe395a3a1d1/Editor/2D/Converter/BuiltInPixelPerfectCameraConverter.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 8a5fe95d62765c0459615b3a5e71c3a1

Library/PackageCache/com.unity.render-pipelines.universal@ffe395a3a1d1/Editor/2D/Converter/BuiltInToURP2DReadonlyMaterialConverter.cs

@@ -0,0 +1,45 @@
+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)")]
+    [BatchModeConverterClassInfo("BuiltInToURP2D", "ReadonlyMaterial2D")]
+    [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 2D Renderer. 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,
+                };
+            }
+        }
+    }
+}

Library/PackageCache/com.unity.render-pipelines.universal@ffe395a3a1d1/Editor/2D/Converter/BuiltInToURP2DReadonlyMaterialConverter.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 06094ba9171a2b2449746e516915ac1e

Library/PackageCache/com.unity.render-pipelines.universal@ffe395a3a1d1/Editor/2D/Converter/BuiltInToURP2DRenderSettingsConverter.cs

@@ -0,0 +1,89 @@
+using System;
+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)")]
+    [BatchModeConverterClassInfo("BuiltInToURP2D", "RenderSettings2D")]
+    [ElementInfo(Name = "Rendering Settings",
+                 Order = int.MinValue,
+                 Description = "This converter creates Universal Render Pipeline (URP) assets and corresponding Renderer assets, configuring their settings to match the equivalent settings from the Built-in Render Pipeline.")]
+    class BuiltInToURP2DRenderSettingsConverter : RenderSettingsConverter
+    {
+        public override bool isEnabled => true;
+
+        public override string isDisabledMessage => string.Empty;
+
+        protected override RenderPipelineAsset CreateAsset(string name)
+        {
+            string path = $"Assets/{UniversalProjectSettings.projectSettingsFolderPath}/{name}.asset";
+            if (AssetDatabase.AssetPathExists(path))
+                return AssetDatabase.LoadAssetAtPath<UniversalRenderPipelineAsset>(path);
+
+            try
+            {
+                CoreUtils.EnsureFolderTreeInAssetFilePath(path);
+                var asset = ScriptableObject.CreateInstance(typeof(UniversalRenderPipelineAsset)) as UniversalRenderPipelineAsset;
+                AssetDatabase.CreateAsset(asset, path);
+                AssetDatabase.SaveAssetIfDirty(asset);
+                return asset;
+            }
+            catch (Exception ex)
+            {
+                Debug.LogError($"Unable to create asset at path {path} with exception {ex.Message}");
+                return null;
+            }
+        }
+
+        Renderer2DData CreateRenderer2DDataAsset()
+        {
+            string path = $"Assets/{UniversalProjectSettings.projectSettingsFolderPath}/Default_2D_Renderer.asset";
+            if (AssetDatabase.AssetPathExists(path))
+                return AssetDatabase.LoadAssetAtPath<Renderer2DData>(path);
+
+            CoreUtils.EnsureFolderTreeInAssetFilePath(path);
+
+            var asset = Renderer2DMenus.CreateRendererAsset(path, RendererType._2DRenderer, relativePath: false) as Renderer2DData;
+            
+            EditorUtility.SetDirty(asset);
+            AssetDatabase.SaveAssetIfDirty(asset);
+
+            return asset;
+        }
+
+        void GetRenderers(out ScriptableRendererData[] renderers, out int defaultIndex)
+        {
+            defaultIndex = 0;
+
+
+            using (ListPool<ScriptableRendererData>.Get(out var tmp))
+            {
+                tmp.Add(CreateRenderer2DDataAsset());
+
+                // In case we need multiple renderers modify the defaultIndex and add more renderers here
+                // ...
+
+                renderers = tmp.ToArray();
+            }
+
+            // Tell the asset database to regenerate the fileId, otherwise when adding the reference to the URP
+            // asset the fileId might not be computed and the reference might be lost.
+            AssetDatabase.Refresh();
+        }
+
+        protected override void SetPipelineSettings(RenderPipelineAsset asset)
+        {
+            if (asset is not UniversalRenderPipelineAsset urpAsset)
+                return;
+
+            GetRenderers(out var renderers, out var defaultIndex);
+            urpAsset.m_RendererDataList = renderers;
+            urpAsset.m_DefaultRendererIndex = defaultIndex;
+        }
+    }
+}

Library/PackageCache/com.unity.render-pipelines.universal@ffe395a3a1d1/Editor/2D/Converter/BuiltInToURP2DRenderSettingsConverter.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: a56824d790f2d894b87761a6d3c6f176

Library/PackageCache/com.unity.render-pipelines.universal@ffe395a3a1d1/Editor/2D/Converter/BuiltInToURP2DShaderConverter.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Collections.Generic;
+using UnityEditor.Rendering.Converter;
+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 Shader Converter",
+                 Order = 100,
+                 Description = "Converts references to Built-In shaders to URP (2D) shaders.")]
+    internal sealed class BuiltInToURP2DShaderConverter : RenderPipelineConverterMaterialUpgrader
+    {
+        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 2D Renderer. Convert your project to URP to use this converter.";
+
+
+        protected override List<MaterialUpgrader> upgraders
+        {
+            get
+            {
+                var allURPUpgraders = MaterialUpgrader.FetchAllUpgradersForPipeline(typeof(UniversalRenderPipelineAsset));
+
+                var builtInToURPUpgraders = new List<MaterialUpgrader>();
+                foreach (var upgrader in allURPUpgraders)
+                {
+                    if (upgrader is IBuiltInToURP2dMaterialUpgrader)
+                        builtInToURPUpgraders.Add(upgrader);
+                }
+
+                return builtInToURPUpgraders;
+            }
+        }
+    }
+}

Library/PackageCache/com.unity.render-pipelines.universal@ffe395a3a1d1/Editor/2D/Converter/BuiltInToURP2DShaderConverter.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 7c198b1ecf647d44bb399198e12d2bfa

Library/PackageCache/com.unity.render-pipelines.universal@ffe395a3a1d1/Editor/2D/Converter/MaterialUpgraderDefinitions.cs

@@ -0,0 +1,82 @@
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Rendering;
+using UnityEngine.Rendering.Universal;
+
+namespace UnityEditor.Rendering.Universal
+{
+    internal interface IBuiltInToURP2dMaterialUpgrader
+    {
+    }
+
+    [SupportedOnRenderPipeline(typeof(UniversalRenderPipelineAsset))]
+    class BuiltInToURP2DMaterialUpgraderProvider : IMaterialUpgradersProvider
+    {
+        public IEnumerable<MaterialUpgrader> GetUpgraders()
+        {
+            yield return new SpritesDefaultUpgrader("Sprites-Default");
+            yield return new SpritesDefaultUpgrader("Sprites-Mask");
+            yield return new DefaultMaterialUpgrader();
+        }
+    }
+
+    class DefaultMaterialUpgrader : MaterialUpgrader, IBuiltInToURP2dMaterialUpgrader
+    {
+        public DefaultMaterialUpgrader()
+        {
+            RenameShader("Standard", "Universal Render Pipeline/2D/Mesh2D-Lit-Default");
+        }
+    }
+
+    class SpritesDefaultUpgrader : MaterialUpgrader, IBuiltInToURP2dMaterialUpgrader
+    {
+        public SpritesDefaultUpgrader(string shaderName)
+        {
+            if (shaderName.Equals("Sprites-Default"))
+            {
+                Shader newShader = null;
+                Renderer2DData data = Light2DEditorUtility.GetRenderer2DData();
+                if (data != null)
+                    newShader = data.GetDefaultMaterial(UnityEngine.Rendering.Universal.DefaultMaterialType.Sprite).shader;
+                else
+                    newShader = Shader.Find("Universal Render Pipeline/2D/Sprite-Lit-Default");
+
+                RenameShader("Sprites/Diffuse", newShader.name);
+            }
+            else if (shaderName.Equals("Sprites-Mask"))
+            {
+                RenameShader("Sprites/Mask", "Universal Render Pipeline/2D/Sprite-Mask");
+            }
+        }
+    }
+
+    internal interface IURP3DToURP2dMaterialUpgrader
+    {
+    }
+
+    [SupportedOnRenderPipeline(typeof(UniversalRenderPipelineAsset))]
+    class URP3DToURP2DMaterialUpgraderProvider : IMaterialUpgradersProvider
+    {
+        public IEnumerable<MaterialUpgrader> GetUpgraders()
+        {
+            yield return new LitMaterialUpgrader();
+            yield return new SimpleLitMaterialUpgrader();
+        }
+    }
+
+    class LitMaterialUpgrader : MaterialUpgrader, IURP3DToURP2dMaterialUpgrader
+    {
+        public LitMaterialUpgrader()
+        {
+            RenameShader("Universal Render Pipeline/Lit", "Universal Render Pipeline/2D/Mesh2D-Lit-Default");
+        }
+    }
+
+    class SimpleLitMaterialUpgrader : MaterialUpgrader, IURP3DToURP2dMaterialUpgrader
+    {
+        public SimpleLitMaterialUpgrader()
+        {
+            RenameShader("Universal Render Pipeline/Simple Lit", "Universal Render Pipeline/2D/Mesh2D-Lit-Default");
+        }
+    }
+}

Library/PackageCache/com.unity.render-pipelines.universal@ffe395a3a1d1/Editor/2D/Converter/MaterialUpgraderDefinitions.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: eda0e8a03dd031e41974f62cc8cc0608

Library/PackageCache/com.unity.render-pipelines.universal@ffe395a3a1d1/Editor/2D/Converter/ParametricToFreeformLightUpgrader.cs

@@ -0,0 +1,181 @@
+using System;
+using System.Collections.Generic;
+using UnityEditor.Rendering.Converter;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+using UnityEngine.Categorization;
+using UnityEngine.Rendering;
+using UnityEngine.Rendering.Universal;
+
+namespace UnityEditor.Rendering.Universal
+{
+    [Serializable]
+    internal class ParametricToFreeformLightUpgraderItem : RenderPipelineConverterAssetItem
+    {
+        public int type { get; set; }
+
+        public ParametricToFreeformLightUpgraderItem(string id) : base(id)
+        {
+        }
+
+        public ParametricToFreeformLightUpgraderItem(GlobalObjectId gid, string assetPath) : base(gid, assetPath)
+        {
+        }
+
+        public new Texture2D icon => EditorGUIUtility.ObjectContent(null, typeof(UnityEngine.Rendering.Universal.Light2D)).image as Texture2D;
+    }
+
+    [Serializable]
+    [PipelineTools]
+    [BatchModeConverterClassInfo("UpgradeURP2DAssets", "ParametricToFreeformLight")]
+    [ElementInfo(Name = "Parametric to Freeform Light Upgrade",
+             Order = 100,
+             Description = "This will upgrade all parametric lights to freeform lights.")]
+    internal sealed class ParametricToFreeformLightUpgrader : IRenderPipelineConverter
+    {
+        public bool isEnabled
+        {
+            get
+            {
+                var urpAsset = GraphicsSettings.currentRenderPipeline as UniversalRenderPipelineAsset;
+                if (urpAsset == null)
+                    return false;
+
+                var renderer = urpAsset.scriptableRenderer as Renderer2D;
+                if (renderer == null)
+                    return false;
+
+                return true;
+            }
+        }
+        public string isDisabledMessage => "The current Render Pipeline is not URP or the current Renderer is not 2D";
+
+        public void Scan(Action<List<IRenderPipelineConverterItem>> onScanFinish)
+        {
+            var returnList = new List<IRenderPipelineConverterItem>();
+            void OnSearchFinish()
+            {
+                onScanFinish?.Invoke(returnList);
+            }
+
+            var processedIds = new HashSet<string>();
+
+            SearchServiceUtils.RunQueuedSearch
+            (
+                SearchServiceUtils.IndexingOptions.DeepSearch,
+                new List<(string, string)>()
+                {
+                    ("t:UnityEngine.Rendering.Universal.Light2D", "Light 2D"),
+                },
+                (item, description) =>
+                {
+                    // Direct conversion - works for both assets and scene objects
+                    var unityObject = item.ToObject();
+
+                    if (unityObject == null)
+                        return;
+
+                    // Ensure we're always working with GameObjects
+                    GameObject go = null;
+
+                    if (unityObject is GameObject gameObject)
+                        go = gameObject;
+                    else if (unityObject is Component component)
+                        go = component.gameObject;
+                    else
+                        return; // Not a GameObject or Component
+
+                    var gid = GlobalObjectId.GetGlobalObjectIdSlow(go);
+                    if (!processedIds.Add(gid.ToString()))
+                        return;
+
+                    int type = gid.identifierType; // 1=Asset, 2=SceneObject
+
+                    var isPrefab = type == 1;
+                    var lightUpgraderItem = new ParametricToFreeformLightUpgraderItem(gid.ToString())
+                    {
+                        info = isPrefab
+                            ? $"Prefab: {AssetDatabase.GetAssetPath(unityObject)}"
+                            : $"Scene: {go.scene.path}",
+                        type = type
+                    };
+
+
+                    returnList.Add(lightUpgraderItem);
+                },
+                OnSearchFinish
+            );
+        }
+
+        const float k_EnscribedSquareDiagonalLength = 0.70710678118654752440084436210485f;
+
+        public static void UpgradeParametricLight(Light2D light)
+        {
+            if (light.lightType == (Light2D.LightType)Light2D.DeprecatedLightType.Parametric)
+            {
+                light.lightType = Light2D.LightType.Freeform;
+
+                // Parametric radius has to be > 0 in order mesh tessellation to be valid
+                if (light.shapeLightParametricRadius == 0)
+                    light.shapeLightParametricRadius = 0.01f;
+
+                float radius = light.shapeLightParametricRadius;
+                float angle = light.shapeLightParametricAngleOffset;
+                int sides = light.shapeLightParametricSides;
+
+                var angleOffset = Mathf.PI / 2.0f + Mathf.Deg2Rad * angle;
+                if (sides < 3)
+                {
+                    radius = k_EnscribedSquareDiagonalLength * radius;
+                    sides = 4;
+                }
+
+                if (sides == 4)
+                {
+                    angleOffset = Mathf.PI / 4.0f + Mathf.Deg2Rad * angle;
+                }
+
+                var radiansPerSide = 2 * Mathf.PI / sides;
+                var min = new Vector3(float.MaxValue, float.MaxValue, 0);
+                var max = new Vector3(float.MinValue, float.MinValue, 0);
+
+
+                Vector3[] shapePath = new Vector3[sides];
+                for (var i = 0; i < sides; i++)
+                {
+                    var endAngle = (i + 1) * radiansPerSide;
+                    var extrudeDir = new Vector3(Mathf.Cos(endAngle + angleOffset), Mathf.Sin(endAngle + angleOffset), 0);
+                    var endPoint = radius * extrudeDir;
+
+                    shapePath[i] = endPoint;
+                }
+
+                light.shapePath = shapePath;
+                light.UpdateMesh();
+                EditorSceneManager.MarkSceneDirty(light.gameObject.scene);
+            }
+        }
+
+        void UpgradeGameObject(GameObject go)
+        {
+            Light2D[] lights = go.GetComponentsInChildren<Light2D>();
+            foreach (Light2D light in lights)
+            {
+                if (light.lightType == Light2D.LightType.Parametric && !PrefabUtility.IsPartOfPrefabInstance(light))
+                    UpgradeParametricLight(light);
+            }
+        }
+
+        public Status Convert(IRenderPipelineConverterItem item, out string message)
+        {
+            if (item is ParametricToFreeformLightUpgraderItem lightItem)
+            {
+                if (lightItem.type == 1) URP2DConverterUtility.UpgradePrefab(lightItem.assetPath, UpgradeGameObject);
+                else URP2DConverterUtility.UpgradeScene(lightItem.assetPath, UpgradeGameObject);
+            }
+
+            message = string.Empty;
+            return Status.Success;
+        }
+    }
+}

Library/PackageCache/com.unity.render-pipelines.universal@ffe395a3a1d1/Editor/2D/Converter/ParametricToFreeformLightUpgrader.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5f5877a9138882a4095ba0e997d19644
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.render-pipelines.universal@ffe395a3a1d1/Editor/2D/Converter/PhotoshopAssetsUpgrader.cs

@@ -0,0 +1,80 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using UnityEditor.Rendering.Converter;
+using UnityEngine.Categorization;
+using UnityEngine.Rendering.Universal;
+using UnityEngine.Rendering;
+
+namespace UnityEditor.Rendering.Universal
+{
+    [Serializable]
+    [PipelineTools]
+    [ElementInfo(Name = "Photoshop Assets Upgrader",
+             Order = 400,
+             Description = "This converter reimports the assets with extension .psd and .psb.")]
+    internal sealed class PhotoshopAssetsUpgrader : IRenderPipelineConverter
+    {
+        public bool isEnabled
+        {
+            get
+            {
+                var urpAsset = GraphicsSettings.currentRenderPipeline as UniversalRenderPipelineAsset;
+                if (urpAsset == null)
+                    return false;
+
+                var renderer = urpAsset.scriptableRenderer as Renderer2D;
+                if (renderer == null)
+                    return false;
+
+                return true;
+            }
+        }
+        public string isDisabledMessage => "The current Render Pipeline is not URP or the current Renderer is not 2D";
+
+        public void Scan(Action<List<IRenderPipelineConverterItem>> onScanFinish)
+        {
+            var returnList = new List<IRenderPipelineConverterItem>();
+            void OnSearchFinish()
+            {
+                onScanFinish?.Invoke(returnList);
+            }
+
+            SearchServiceUtils.RunQueuedSearch
+            (
+                SearchServiceUtils.IndexingOptions.DeepSearch,
+                new List<(string, string)>()
+                {
+                    ("p: ext:psd", "PSD"),
+                    ("p: ext:psb", "PSB")
+                },
+                (item, description) =>
+                {
+                    var assetItem = new RenderPipelineConverterAssetItem(item.id)
+                    {
+                        info = description
+                    };
+                    returnList.Add(assetItem);
+                },
+                OnSearchFinish
+            );
+        }
+
+        public Status Convert(IRenderPipelineConverterItem item, out string message)
+        {
+            var assetItem = item as RenderPipelineConverterAssetItem;
+
+            var obj = assetItem.LoadObject();
+
+            if (obj == null)
+            {
+                message = $"Failed to load {assetItem.name} Global ID {assetItem.guid} Asset Path {assetItem.assetPath}";
+                return Status.Error;
+            }
+            
+            URP2DConverterUtility.UpgradePSB(assetItem.assetPath);
+            message = string.Empty;
+            return Status.Success;
+        }
+    }
+}

Library/PackageCache/com.unity.render-pipelines.universal@ffe395a3a1d1/Editor/2D/Converter/PhotoshopAssetsUpgrader.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 7ff48272166a7b6439b6945d39d51766

Library/PackageCache/com.unity.render-pipelines.universal@ffe395a3a1d1/Editor/2D/Converter/URP2DConverterUtility.cs

@@ -0,0 +1,185 @@
+using System;
+using UnityEngine;
+using UnityEditor;
+using System.IO;
+using UnityEditor.SceneManagement;
+using UnityEngine.SceneManagement;
+using static UnityEditor.Rendering.AnimationClipUpgrader;
+
+internal static class URP2DConverterUtility
+{
+
+    private static class Styles
+    {
+        public static readonly GUIContent failedToInstallPackageTitle = EditorGUIUtility.TrTextContent("Installation Failed");
+        public static readonly GUIContent failedToInstallPackageContent = EditorGUIUtility.TrTextContent("Failed to install {0} package.\nErrorCode: {1}\nMessage: {2}");
+        public static readonly GUIContent okText = EditorGUIUtility.TrTextContent("OK");
+    }
+
+    public static bool InstallPackage(string package)
+    {
+        var addRequest = UnityEditor.PackageManager.Client.Add(package);
+        while (!addRequest.IsCompleted)
+            System.Threading.Thread.Sleep(10);
+
+        if (addRequest.Status == UnityEditor.PackageManager.StatusCode.Failure)
+        {
+            var message = System.String.Format(Styles.failedToInstallPackageContent.text, package, addRequest.Error.errorCode, addRequest.Error.message);
+            EditorUtility.DisplayDialog(Styles.failedToInstallPackageTitle.text, message, Styles.okText.text);
+        }
+        UnityEditorInternal.InternalEditorUtility.RepaintAllViews();
+        return addRequest.Status == UnityEditor.PackageManager.StatusCode.Success;
+    }
+
+    public static bool IsPSB(string path)
+    {
+        if (string.IsNullOrEmpty(path))
+            throw new ArgumentNullException(nameof(path));
+
+        if (path.StartsWith("Packages"))
+            return false;
+
+        return path.EndsWith(".psb") || path.EndsWith(".psd");
+    }
+
+
+    public static bool IsMaterialPath(string path, string[] ids)
+    {
+        if (string.IsNullOrEmpty(path))
+            throw new ArgumentNullException(nameof(path));
+
+        if (path.StartsWith("Packages"))
+            return false;
+
+        if (path.EndsWith(".mat"))
+        {
+            return URP2DConverterUtility.DoesFileContainString(path, ids);
+        }
+            
+
+        return false;
+    }
+
+    public static bool IsPrefabOrScenePath(string path, string[] ids)
+    {
+        if (string.IsNullOrEmpty(path))
+            throw new ArgumentNullException(nameof(path));
+
+        if (path.StartsWith("Packages"))
+            return false;
+
+        if (path.EndsWith(".prefab", StringComparison.OrdinalIgnoreCase) || path.EndsWith(".unity", StringComparison.OrdinalIgnoreCase))
+            return URP2DConverterUtility.DoesFileContainString(path, ids);
+
+        return false;
+    }
+
+    public static bool IsPrefabOrScenePath(string path, string id)
+    {
+        return IsPrefabOrScenePath(path, new string[] { id });
+    }
+
+    public static bool DoesFileContainString(string path, string[] strs)
+    {
+        if (strs != null && strs.Length > 0)
+        {
+            using (StreamReader file = File.OpenText(path))
+            {
+                string line;
+                while ((line = file.ReadLine()) != null)
+                {
+                    for (int i = 0; i < strs.Length; i++)
+                    {
+                        if (line.Contains(strs[i]))
+                            return true;
+                    }
+                }
+            }
+        }
+
+        return false;
+    }
+
+    public static string UpgradePSB(string path)
+    {
+        AssetDatabase.ImportAsset(path, ImportAssetOptions.ForceSynchronousImport | ImportAssetOptions.ForceUpdate);
+        return string.Empty;
+    }
+
+    public static string UpgradePrefab(string path, Action<GameObject> objectUpgrader)
+    {
+        UnityEngine.Object[] objects = AssetDatabase.LoadAllAssetsAtPath(path);
+
+        int firstIndex = 0;
+        for (int i = 0; i < objects.Length; i++)
+        {
+            if (objects[i] as GameObject)
+            {
+                firstIndex = i;
+                break;
+            }
+        }
+
+        // There should be no need to check this as we have already determined that there is something that needs upgrading
+        if (!PrefabUtility.IsPartOfImmutablePrefab(objects[firstIndex]))
+        {
+            for (int objIndex = 0; objIndex < objects.Length; objIndex++)
+            {
+                GameObject go = objects[objIndex] as GameObject;
+                if (go != null)
+                {
+                    objectUpgrader(go);
+                }
+            }
+
+            GameObject asset = objects[firstIndex] as GameObject;
+            PrefabUtility.SavePrefabAsset(asset.transform.root.gameObject);
+
+            return string.Empty;
+        }
+
+        return "Unable to modify an immutable prefab";
+    }
+
+    public static void UpgradeScene(string path, Action<GameObject> objectUpgrader)
+    {
+        Scene scene = new Scene();
+        bool openedByUser = false;
+        for (int i = 0; i < SceneManager.sceneCount && !openedByUser; i++)
+        {
+            scene = SceneManager.GetSceneAt(i);
+            if (path == scene.path)
+                openedByUser = true;
+        }
+
+        if (!openedByUser)
+            scene = EditorSceneManager.OpenScene(path, OpenSceneMode.Additive);
+
+        GameObject[] gameObjects = scene.GetRootGameObjects();
+        foreach (GameObject go in gameObjects)
+            objectUpgrader(go);
+
+        EditorSceneManager.SaveScene(scene);
+        if (!openedByUser)
+            EditorSceneManager.CloseScene(scene, true);
+    }
+
+    public static void UpgradeMaterial(string path, Action<Material> materialUpgrader)
+    {
+        Material material = AssetDatabase.LoadAssetAtPath<Material>(path);
+        materialUpgrader(material);
+
+        GUID guid = AssetDatabase.GUIDFromAssetPath(path);
+        AssetDatabase.SaveAssetIfDirty(guid);
+    }
+
+    public static string GetObjectIDString(UnityEngine.Object obj)
+    {
+        string guid;
+        long localId;
+        if (AssetDatabase.TryGetGUIDAndLocalFileIdentifier(obj.GetEntityId(), out guid, out localId))
+            return "fileID: " + localId + ", guid: " + guid;
+
+        return null;
+    }
+}

Library/PackageCache/com.unity.render-pipelines.universal@ffe395a3a1d1/Editor/2D/Converter/URP2DConverterUtility.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4d81aa6b4f52f5a46a02e0957a23f550
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.render-pipelines.universal@ffe395a3a1d1/Editor/2D/Converter/URP3DToURP2DReadonlyMaterialConverter.cs

@@ -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 2D Renderer. 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;
+            }
+        }
+    }
+}

Library/PackageCache/com.unity.render-pipelines.universal@ffe395a3a1d1/Editor/2D/Converter/URP3DToURP2DReadonlyMaterialConverter.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 5baecaac191c29b4588b13e6c63bc1b0

Library/PackageCache/com.unity.render-pipelines.universal@ffe395a3a1d1/Editor/2D/Converter/URP3DToURP2DShaderConverter.cs

@@ -0,0 +1,49 @@
+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 Shader Converter",
+                 Order = 100,
+                 Description = "Converts references to URP Lit and Simple Lit shaders to Mesh 2D Lit shader.")]
+    internal sealed class URP3DToURP2DShaderConverter : RenderPipelineConverterMaterialUpgrader
+    {
+
+        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 2D Renderer. Convert your project to URP to use this converter.";
+
+        protected override List<MaterialUpgrader> upgraders
+        {
+            get
+            {
+                var allURPUpgraders = MaterialUpgrader.FetchAllUpgradersForPipeline(typeof(UniversalRenderPipelineAsset));
+
+                var builtInToURPUpgraders = new List<MaterialUpgrader>();
+                foreach (var upgrader in allURPUpgraders)
+                {
+                    if (upgrader is IURP3DToURP2dMaterialUpgrader)
+                        builtInToURPUpgraders.Add(upgrader);
+                }
+
+                return builtInToURPUpgraders;
+            }
+        }
+    }
+}

Library/PackageCache/com.unity.render-pipelines.universal@ffe395a3a1d1/Editor/2D/Converter/URP3DToURP2DShaderConverter.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: aa2366bbec4f77041b59b590de916a32