testss

Library/PackageCache/com.unity.render-pipelines.universal@11.0.0/Editor/ShaderGUI/Shaders/BakedLitShader.cs

@@ -0,0 +1,107 @@
+using System;
+using UnityEngine;
+using UnityEditor.Rendering.Universal;
+
+namespace UnityEditor.Rendering.Universal.ShaderGUI
+{
+    internal class BakedLitShader : BaseShaderGUI
+    {
+        // Properties
+        private BakedLitGUI.BakedLitProperties shadingModelProperties;
+
+        // collect properties from the material properties
+        public override void FindProperties(MaterialProperty[] properties)
+        {
+            base.FindProperties(properties);
+            shadingModelProperties = new BakedLitGUI.BakedLitProperties(properties);
+        }
+
+        // material changed check
+        public override void MaterialChanged(Material material)
+        {
+            if (material == null)
+                throw new ArgumentNullException("material");
+
+            SetMaterialKeywords(material);
+        }
+
+        // material main surface options
+        public override void DrawSurfaceOptions(Material material)
+        {
+            if (material == null)
+                throw new ArgumentNullException("material");
+
+            // Use default labelWidth
+            EditorGUIUtility.labelWidth = 0f;
+
+            EditorGUI.BeginChangeCheck();
+            {
+                base.DrawSurfaceOptions(material);
+            }
+            if (EditorGUI.EndChangeCheck())
+            {
+                foreach (var obj in blendModeProp.targets)
+                    MaterialChanged((Material)obj);
+            }
+        }
+
+        // material main surface inputs
+        public override void DrawSurfaceInputs(Material material)
+        {
+            base.DrawSurfaceInputs(material);
+            BakedLitGUI.Inputs(shadingModelProperties, materialEditor);
+            DrawTileOffset(materialEditor, baseMapProp);
+        }
+
+        public override void DrawAdvancedOptions(Material material)
+        {
+            EditorGUI.BeginChangeCheck();
+            base.DrawAdvancedOptions(material);
+            if (EditorGUI.EndChangeCheck())
+            {
+                foreach (var obj in blendModeProp.targets)
+                    MaterialChanged((Material)obj);
+            }
+        }
+
+        public override void AssignNewShaderToMaterial(Material material, Shader oldShader, Shader newShader)
+        {
+            if (material == null)
+                throw new ArgumentNullException("material");
+
+            // _Emission property is lost after assigning Standard shader to the material
+            // thus transfer it before assigning the new shader
+            if (material.HasProperty("_Emission"))
+            {
+                material.SetColor("_EmissionColor", material.GetColor("_Emission"));
+            }
+
+            base.AssignNewShaderToMaterial(material, oldShader, newShader);
+
+            if (oldShader == null || !oldShader.name.Contains("Legacy Shaders/"))
+            {
+                SetupMaterialBlendMode(material);
+                return;
+            }
+
+            SurfaceType surfaceType = SurfaceType.Opaque;
+            BlendMode blendMode = BlendMode.Alpha;
+            if (oldShader.name.Contains("/Transparent/Cutout/"))
+            {
+                surfaceType = SurfaceType.Opaque;
+                material.SetFloat("_AlphaClip", 1);
+            }
+            else if (oldShader.name.Contains("/Transparent/"))
+            {
+                // NOTE: legacy shaders did not provide physically based transparency
+                // therefore Fade mode
+                surfaceType = SurfaceType.Transparent;
+                blendMode = BlendMode.Alpha;
+            }
+            material.SetFloat("_Surface", (float)surfaceType);
+            material.SetFloat("_Blend", (float)blendMode);
+
+            MaterialChanged(material);
+        }
+    }
+}

Library/PackageCache/com.unity.render-pipelines.universal@11.0.0/Editor/ShaderGUI/Shaders/LitShader.cs

@@ -0,0 +1,150 @@
+using System;
+using UnityEngine;
+
+namespace UnityEditor.Rendering.Universal.ShaderGUI
+{
+    internal class LitShader : BaseShaderGUI
+    {
+        private LitGUI.LitProperties litProperties;
+        private LitDetailGUI.LitProperties litDetailProperties;
+        private SavedBool m_DetailInputsFoldout;
+
+        public override void OnOpenGUI(Material material, MaterialEditor materialEditor)
+        {
+            base.OnOpenGUI(material, materialEditor);
+            m_DetailInputsFoldout = new SavedBool($"{headerStateKey}.DetailInputsFoldout", true);
+        }
+
+        public override void DrawAdditionalFoldouts(Material material)
+        {
+            m_DetailInputsFoldout.value = EditorGUILayout.BeginFoldoutHeaderGroup(m_DetailInputsFoldout.value, LitDetailGUI.Styles.detailInputs);
+            if (m_DetailInputsFoldout.value)
+            {
+                LitDetailGUI.DoDetailArea(litDetailProperties, materialEditor);
+                EditorGUILayout.Space();
+            }
+            EditorGUILayout.EndFoldoutHeaderGroup();
+        }
+
+        // collect properties from the material properties
+        public override void FindProperties(MaterialProperty[] properties)
+        {
+            base.FindProperties(properties);
+            litProperties = new LitGUI.LitProperties(properties);
+            litDetailProperties = new LitDetailGUI.LitProperties(properties);
+        }
+
+        // material changed check
+        public override void MaterialChanged(Material material)
+        {
+            if (material == null)
+                throw new ArgumentNullException("material");
+
+            SetMaterialKeywords(material, LitGUI.SetMaterialKeywords, LitDetailGUI.SetMaterialKeywords);
+        }
+
+        // material main surface options
+        public override void DrawSurfaceOptions(Material material)
+        {
+            if (material == null)
+                throw new ArgumentNullException("material");
+
+            // Use default labelWidth
+            EditorGUIUtility.labelWidth = 0f;
+
+            // Detect any changes to the material
+            EditorGUI.BeginChangeCheck();
+            if (litProperties.workflowMode != null)
+            {
+                DoPopup(LitGUI.Styles.workflowModeText, litProperties.workflowMode, Enum.GetNames(typeof(LitGUI.WorkflowMode)));
+            }
+            if (EditorGUI.EndChangeCheck())
+            {
+                foreach (var obj in blendModeProp.targets)
+                    MaterialChanged((Material)obj);
+            }
+            base.DrawSurfaceOptions(material);
+        }
+
+        // material main surface inputs
+        public override void DrawSurfaceInputs(Material material)
+        {
+            base.DrawSurfaceInputs(material);
+            LitGUI.Inputs(litProperties, materialEditor, material);
+            DrawEmissionProperties(material, true);
+            DrawTileOffset(materialEditor, baseMapProp);
+        }
+
+        // material main advanced options
+        public override void DrawAdvancedOptions(Material material)
+        {
+            if (litProperties.reflections != null && litProperties.highlights != null)
+            {
+                EditorGUI.BeginChangeCheck();
+                materialEditor.ShaderProperty(litProperties.highlights, LitGUI.Styles.highlightsText);
+                materialEditor.ShaderProperty(litProperties.reflections, LitGUI.Styles.reflectionsText);
+                if (EditorGUI.EndChangeCheck())
+                {
+                    MaterialChanged(material);
+                }
+            }
+
+            base.DrawAdvancedOptions(material);
+        }
+
+        public override void AssignNewShaderToMaterial(Material material, Shader oldShader, Shader newShader)
+        {
+            if (material == null)
+                throw new ArgumentNullException("material");
+
+            // _Emission property is lost after assigning Standard shader to the material
+            // thus transfer it before assigning the new shader
+            if (material.HasProperty("_Emission"))
+            {
+                material.SetColor("_EmissionColor", material.GetColor("_Emission"));
+            }
+
+            base.AssignNewShaderToMaterial(material, oldShader, newShader);
+
+            if (oldShader == null || !oldShader.name.Contains("Legacy Shaders/"))
+            {
+                SetupMaterialBlendMode(material);
+                return;
+            }
+
+            SurfaceType surfaceType = SurfaceType.Opaque;
+            BlendMode blendMode = BlendMode.Alpha;
+            if (oldShader.name.Contains("/Transparent/Cutout/"))
+            {
+                surfaceType = SurfaceType.Opaque;
+                material.SetFloat("_AlphaClip", 1);
+            }
+            else if (oldShader.name.Contains("/Transparent/"))
+            {
+                // NOTE: legacy shaders did not provide physically based transparency
+                // therefore Fade mode
+                surfaceType = SurfaceType.Transparent;
+                blendMode = BlendMode.Alpha;
+            }
+            material.SetFloat("_Surface", (float)surfaceType);
+            material.SetFloat("_Blend", (float)blendMode);
+
+            if (oldShader.name.Equals("Standard (Specular setup)"))
+            {
+                material.SetFloat("_WorkflowMode", (float)LitGUI.WorkflowMode.Specular);
+                Texture texture = material.GetTexture("_SpecGlossMap");
+                if (texture != null)
+                    material.SetTexture("_MetallicSpecGlossMap", texture);
+            }
+            else
+            {
+                material.SetFloat("_WorkflowMode", (float)LitGUI.WorkflowMode.Metallic);
+                Texture texture = material.GetTexture("_MetallicGlossMap");
+                if (texture != null)
+                    material.SetTexture("_MetallicSpecGlossMap", texture);
+            }
+
+            MaterialChanged(material);
+        }
+    }
+}

Library/PackageCache/com.unity.render-pipelines.universal@11.0.0/Editor/ShaderGUI/Shaders/ParticlesLitShader.cs

@@ -0,0 +1,88 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace UnityEditor.Rendering.Universal.ShaderGUI
+{
+    internal class ParticlesLitShader : BaseShaderGUI
+    {
+        // Properties
+        private LitGUI.LitProperties litProperties;
+        private ParticleGUI.ParticleProperties particleProps;
+
+        // List of renderers using this material in the scene, used for validating vertex streams
+        List<ParticleSystemRenderer> m_RenderersUsingThisMaterial = new List<ParticleSystemRenderer>();
+
+        public override void FindProperties(MaterialProperty[] properties)
+        {
+            base.FindProperties(properties);
+            litProperties = new LitGUI.LitProperties(properties);
+            particleProps = new ParticleGUI.ParticleProperties(properties);
+        }
+
+        public override void MaterialChanged(Material material)
+        {
+            if (material == null)
+                throw new ArgumentNullException("material");
+
+            SetMaterialKeywords(material, LitGUI.SetMaterialKeywords, ParticleGUI.SetMaterialKeywords);
+        }
+
+        public override void DrawSurfaceOptions(Material material)
+        {
+            // Detect any changes to the material
+            EditorGUI.BeginChangeCheck();
+            {
+                base.DrawSurfaceOptions(material);
+                DoPopup(ParticleGUI.Styles.colorMode, particleProps.colorMode, Enum.GetNames(typeof(ParticleGUI.ColorMode)));
+            }
+            if (EditorGUI.EndChangeCheck())
+            {
+                foreach (var obj in blendModeProp.targets)
+                    MaterialChanged((Material)obj);
+            }
+        }
+
+        public override void DrawSurfaceInputs(Material material)
+        {
+            base.DrawSurfaceInputs(material);
+            LitGUI.Inputs(litProperties, materialEditor, material);
+            DrawEmissionProperties(material, true);
+        }
+
+        public override void DrawAdvancedOptions(Material material)
+        {
+            EditorGUI.BeginChangeCheck();
+            {
+                materialEditor.ShaderProperty(particleProps.flipbookMode, ParticleGUI.Styles.flipbookMode);
+                ParticleGUI.FadingOptions(material, materialEditor, particleProps);
+                ParticleGUI.DoVertexStreamsArea(material, m_RenderersUsingThisMaterial, true);
+
+                if (EditorGUI.EndChangeCheck())
+                {
+                    MaterialChanged(material);
+                }
+            }
+
+            DrawQueueOffsetField();
+        }
+
+        public override void OnOpenGUI(Material material, MaterialEditor materialEditor)
+        {
+            CacheRenderersUsingThisMaterial(material);
+            base.OnOpenGUI(material, materialEditor);
+        }
+
+        void CacheRenderersUsingThisMaterial(Material material)
+        {
+            m_RenderersUsingThisMaterial.Clear();
+
+            ParticleSystemRenderer[] renderers = UnityEngine.Object.FindObjectsOfType(typeof(ParticleSystemRenderer)) as ParticleSystemRenderer[];
+            foreach (ParticleSystemRenderer renderer in renderers)
+            {
+                if (renderer.sharedMaterial == material)
+                    m_RenderersUsingThisMaterial.Add(renderer);
+            }
+        }
+    }
+} // namespace UnityEditor

Library/PackageCache/com.unity.render-pipelines.universal@11.0.0/Editor/ShaderGUI/Shaders/ParticlesSimpleLitShader.cs

@@ -0,0 +1,89 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace UnityEditor.Rendering.Universal.ShaderGUI
+{
+    internal class ParticlesSimpleLitShader : BaseShaderGUI
+    {
+        // Properties
+        private SimpleLitGUI.SimpleLitProperties shadingModelProperties;
+        private ParticleGUI.ParticleProperties particleProps;
+
+        // List of renderers using this material in the scene, used for validating vertex streams
+        List<ParticleSystemRenderer> m_RenderersUsingThisMaterial = new List<ParticleSystemRenderer>();
+
+        public override void FindProperties(MaterialProperty[] properties)
+        {
+            base.FindProperties(properties);
+            shadingModelProperties = new SimpleLitGUI.SimpleLitProperties(properties);
+            particleProps = new ParticleGUI.ParticleProperties(properties);
+        }
+
+        public override void MaterialChanged(Material material)
+        {
+            if (material == null)
+                throw new ArgumentNullException("material");
+
+            SetMaterialKeywords(material, SimpleLitGUI.SetMaterialKeywords, ParticleGUI.SetMaterialKeywords);
+        }
+
+        public override void DrawSurfaceOptions(Material material)
+        {
+            // Detect any changes to the material
+            EditorGUI.BeginChangeCheck();
+            {
+                base.DrawSurfaceOptions(material);
+                DoPopup(ParticleGUI.Styles.colorMode, particleProps.colorMode, Enum.GetNames(typeof(ParticleGUI.ColorMode)));
+            }
+            if (EditorGUI.EndChangeCheck())
+            {
+                foreach (var obj in blendModeProp.targets)
+                    MaterialChanged((Material)obj);
+            }
+        }
+
+        public override void DrawSurfaceInputs(Material material)
+        {
+            base.DrawSurfaceInputs(material);
+            SimpleLitGUI.Inputs(shadingModelProperties, materialEditor, material);
+            DrawEmissionProperties(material, true);
+        }
+
+        public override void DrawAdvancedOptions(Material material)
+        {
+            SimpleLitGUI.Advanced(shadingModelProperties);
+            EditorGUI.BeginChangeCheck();
+            {
+                materialEditor.ShaderProperty(particleProps.flipbookMode, ParticleGUI.Styles.flipbookMode);
+                ParticleGUI.FadingOptions(material, materialEditor, particleProps);
+                ParticleGUI.DoVertexStreamsArea(material, m_RenderersUsingThisMaterial, true);
+
+                if (EditorGUI.EndChangeCheck())
+                {
+                    MaterialChanged(material);
+                }
+            }
+
+            DrawQueueOffsetField();
+        }
+
+        public override void OnOpenGUI(Material material, MaterialEditor materialEditor)
+        {
+            CacheRenderersUsingThisMaterial(material);
+            base.OnOpenGUI(material, materialEditor);
+        }
+
+        void CacheRenderersUsingThisMaterial(Material material)
+        {
+            m_RenderersUsingThisMaterial.Clear();
+
+            ParticleSystemRenderer[] renderers = UnityEngine.Object.FindObjectsOfType(typeof(ParticleSystemRenderer)) as ParticleSystemRenderer[];
+            foreach (ParticleSystemRenderer renderer in renderers)
+            {
+                if (renderer.sharedMaterial == material)
+                    m_RenderersUsingThisMaterial.Add(renderer);
+            }
+        }
+    }
+} // namespace UnityEditor

Library/PackageCache/com.unity.render-pipelines.universal@11.0.0/Editor/ShaderGUI/Shaders/ParticlesUnlitShader.cs

@@ -0,0 +1,88 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace UnityEditor.Rendering.Universal.ShaderGUI
+{
+    internal class ParticlesUnlitShader : BaseShaderGUI
+    {
+        // Properties
+        private BakedLitGUI.BakedLitProperties shadingModelProperties;
+        private ParticleGUI.ParticleProperties particleProps;
+
+        // List of renderers using this material in the scene, used for validating vertex streams
+        List<ParticleSystemRenderer> m_RenderersUsingThisMaterial = new List<ParticleSystemRenderer>();
+
+        public override void FindProperties(MaterialProperty[] properties)
+        {
+            base.FindProperties(properties);
+            shadingModelProperties = new BakedLitGUI.BakedLitProperties(properties);
+            particleProps = new ParticleGUI.ParticleProperties(properties);
+        }
+
+        public override void MaterialChanged(Material material)
+        {
+            if (material == null)
+                throw new ArgumentNullException("material");
+
+            SetMaterialKeywords(material, null, ParticleGUI.SetMaterialKeywords);
+        }
+
+        public override void DrawSurfaceOptions(Material material)
+        {
+            // Detect any changes to the material
+            EditorGUI.BeginChangeCheck();
+            {
+                base.DrawSurfaceOptions(material);
+                DoPopup(ParticleGUI.Styles.colorMode, particleProps.colorMode, Enum.GetNames(typeof(ParticleGUI.ColorMode)));
+            }
+            if (EditorGUI.EndChangeCheck())
+            {
+                foreach (var obj in blendModeProp.targets)
+                    MaterialChanged((Material)obj);
+            }
+        }
+
+        public override void DrawSurfaceInputs(Material material)
+        {
+            base.DrawSurfaceInputs(material);
+            BakedLitGUI.Inputs(shadingModelProperties, materialEditor);
+            DrawEmissionProperties(material, true);
+        }
+
+        public override void DrawAdvancedOptions(Material material)
+        {
+            EditorGUI.BeginChangeCheck();
+            {
+                materialEditor.ShaderProperty(particleProps.flipbookMode, ParticleGUI.Styles.flipbookMode);
+                ParticleGUI.FadingOptions(material, materialEditor, particleProps);
+                ParticleGUI.DoVertexStreamsArea(material, m_RenderersUsingThisMaterial);
+
+                if (EditorGUI.EndChangeCheck())
+                {
+                    MaterialChanged(material);
+                }
+            }
+
+            DrawQueueOffsetField();
+        }
+
+        public override void OnOpenGUI(Material material, MaterialEditor materialEditor)
+        {
+            CacheRenderersUsingThisMaterial(material);
+            base.OnOpenGUI(material, materialEditor);
+        }
+
+        void CacheRenderersUsingThisMaterial(Material material)
+        {
+            m_RenderersUsingThisMaterial.Clear();
+
+            ParticleSystemRenderer[] renderers = UnityEngine.Object.FindObjectsOfType(typeof(ParticleSystemRenderer)) as ParticleSystemRenderer[];
+            foreach (ParticleSystemRenderer renderer in renderers)
+            {
+                if (renderer.sharedMaterial == material)
+                    m_RenderersUsingThisMaterial.Add(renderer);
+            }
+        }
+    }
+} // namespace UnityEditor

Library/PackageCache/com.unity.render-pipelines.universal@11.0.0/Editor/ShaderGUI/Shaders/SimpleLitShader.cs

@@ -0,0 +1,103 @@
+using System;
+using UnityEngine;
+
+namespace UnityEditor.Rendering.Universal.ShaderGUI
+{
+    internal class SimpleLitShader : BaseShaderGUI
+    {
+        // Properties
+        private SimpleLitGUI.SimpleLitProperties shadingModelProperties;
+
+        // collect properties from the material properties
+        public override void FindProperties(MaterialProperty[] properties)
+        {
+            base.FindProperties(properties);
+            shadingModelProperties = new SimpleLitGUI.SimpleLitProperties(properties);
+        }
+
+        // material changed check
+        public override void MaterialChanged(Material material)
+        {
+            if (material == null)
+                throw new ArgumentNullException("material");
+
+            SetMaterialKeywords(material, SimpleLitGUI.SetMaterialKeywords);
+        }
+
+        // material main surface options
+        public override void DrawSurfaceOptions(Material material)
+        {
+            if (material == null)
+                throw new ArgumentNullException("material");
+
+            // Use default labelWidth
+            EditorGUIUtility.labelWidth = 0f;
+
+            // Detect any changes to the material
+            EditorGUI.BeginChangeCheck();
+            {
+                base.DrawSurfaceOptions(material);
+            }
+            if (EditorGUI.EndChangeCheck())
+            {
+                foreach (var obj in blendModeProp.targets)
+                    MaterialChanged((Material)obj);
+            }
+        }
+
+        // material main surface inputs
+        public override void DrawSurfaceInputs(Material material)
+        {
+            base.DrawSurfaceInputs(material);
+            SimpleLitGUI.Inputs(shadingModelProperties, materialEditor, material);
+            DrawEmissionProperties(material, true);
+            DrawTileOffset(materialEditor, baseMapProp);
+        }
+
+        public override void DrawAdvancedOptions(Material material)
+        {
+            SimpleLitGUI.Advanced(shadingModelProperties);
+            base.DrawAdvancedOptions(material);
+        }
+
+        public override void AssignNewShaderToMaterial(Material material, Shader oldShader, Shader newShader)
+        {
+            if (material == null)
+                throw new ArgumentNullException("material");
+
+            // _Emission property is lost after assigning Standard shader to the material
+            // thus transfer it before assigning the new shader
+            if (material.HasProperty("_Emission"))
+            {
+                material.SetColor("_EmissionColor", material.GetColor("_Emission"));
+            }
+
+            base.AssignNewShaderToMaterial(material, oldShader, newShader);
+
+            if (oldShader == null || !oldShader.name.Contains("Legacy Shaders/"))
+            {
+                SetupMaterialBlendMode(material);
+                return;
+            }
+
+            SurfaceType surfaceType = SurfaceType.Opaque;
+            BlendMode blendMode = BlendMode.Alpha;
+            if (oldShader.name.Contains("/Transparent/Cutout/"))
+            {
+                surfaceType = SurfaceType.Opaque;
+                material.SetFloat("_AlphaClip", 1);
+            }
+            else if (oldShader.name.Contains("/Transparent/"))
+            {
+                // NOTE: legacy shaders did not provide physically based transparency
+                // therefore Fade mode
+                surfaceType = SurfaceType.Transparent;
+                blendMode = BlendMode.Alpha;
+            }
+            material.SetFloat("_Surface", (float)surfaceType);
+            material.SetFloat("_Blend", (float)blendMode);
+
+            MaterialChanged(material);
+        }
+    }
+}

Library/PackageCache/com.unity.render-pipelines.universal@11.0.0/Editor/ShaderGUI/Shaders/UnlitShader.cs

@@ -0,0 +1,85 @@
+using System;
+using UnityEngine;
+
+namespace UnityEditor.Rendering.Universal.ShaderGUI
+{
+    internal class UnlitShader : BaseShaderGUI
+    {
+        // material changed check
+        public override void MaterialChanged(Material material)
+        {
+            if (material == null)
+                throw new ArgumentNullException("material");
+
+            SetMaterialKeywords(material);
+        }
+
+        // material main surface options
+        public override void DrawSurfaceOptions(Material material)
+        {
+            if (material == null)
+                throw new ArgumentNullException("material");
+
+            // Use default labelWidth
+            EditorGUIUtility.labelWidth = 0f;
+
+            // Detect any changes to the material
+            EditorGUI.BeginChangeCheck();
+            {
+                base.DrawSurfaceOptions(material);
+            }
+            if (EditorGUI.EndChangeCheck())
+            {
+                foreach (var obj in blendModeProp.targets)
+                    MaterialChanged((Material)obj);
+            }
+        }
+
+        // material main surface inputs
+        public override void DrawSurfaceInputs(Material material)
+        {
+            base.DrawSurfaceInputs(material);
+            DrawTileOffset(materialEditor, baseMapProp);
+        }
+
+        public override void AssignNewShaderToMaterial(Material material, Shader oldShader, Shader newShader)
+        {
+            if (material == null)
+                throw new ArgumentNullException("material");
+
+            // _Emission property is lost after assigning Standard shader to the material
+            // thus transfer it before assigning the new shader
+            if (material.HasProperty("_Emission"))
+            {
+                material.SetColor("_EmissionColor", material.GetColor("_Emission"));
+            }
+
+            base.AssignNewShaderToMaterial(material, oldShader, newShader);
+
+            if (oldShader == null || !oldShader.name.Contains("Legacy Shaders/"))
+            {
+                SetupMaterialBlendMode(material);
+                return;
+            }
+
+            SurfaceType surfaceType = SurfaceType.Opaque;
+            BlendMode blendMode = BlendMode.Alpha;
+            if (oldShader.name.Contains("/Transparent/Cutout/"))
+            {
+                surfaceType = SurfaceType.Opaque;
+                material.SetFloat("_AlphaClip", 1);
+            }
+            else if (oldShader.name.Contains("/Transparent/"))
+            {
+                // NOTE: legacy shaders did not provide physically based transparency
+                // therefore Fade mode
+                surfaceType = SurfaceType.Transparent;
+                blendMode = BlendMode.Alpha;
+            }
+            material.SetFloat("_Surface", (float)surfaceType);
+            material.SetFloat("_Blend", (float)blendMode);
+
+            MaterialChanged(material);
+        }
+    }
+}