feat: assign material props when changing a material to use Toon3Das2D from Toon (#656)

* add MaterialPropertyValue class
* add ToonMaterialUtility
* update ToonEditorConstants
* use string constants with slashes

Author: sindharta

com.unity.toonshader/Editor/Scripts/GUI/UnityToon3Das2DGUI.cs

@@ -1,10 +1,10 @@
 using System.Collections.Generic;
 using Unity.Rendering.Toon;
 using UnityEngine;
+using UnityEngine.Rendering;
 
 namespace UnityEditor.Rendering.Toon {
 internal class UnityToon3Das2DGUI : UnityEditor.ShaderGUI {
-    private Material m_lastMaterial;
 
     public override void OnGUI(MaterialEditor mEditor, MaterialProperty[] props) {
 
@@ -274,6 +274,87 @@ MaterialPropertyInfo MaterialNameToPropertyInfo(MaterialName m, MaterialProperty
 
 //----------------------------------------------------------------------------------------------------------------------
 
+    //key: Toon3Das2D prop. value: Toon3D prop
+    static readonly Dictionary<string, string> TOON_3D_AS_2D_TO_3D_MAP = new Dictionary<string, string> {
+
+        // Shading thresholds
+        { ToonConstants.SHADER_PROP_BASE_TO_1ST_SHADE_START, "_BaseColor_Step" },
+        { ToonConstants.SHADER_PROP_BASE_TO_1ST_SHADE_FEATHER, "_BaseShade_Feather" },
+        { ToonConstants.SHADER_PROP_1ST_TO_2ND_SHADE_START, "_1st_ShadeColor_Step" },
+        { ToonConstants.SHADER_PROP_1ST_TO_2ND_SHADE_FEATHER, "_1st_ShadeColor_Feather" },
+
+        // Highlight
+        { ToonConstants.SHADER_PROP_HIGHLIGHT_COLOR, "_HighColor" },
+        { ToonConstants.SHADER_PROP_HIGHLIGHT_TEX, "_HighColor_Tex" },
+
+        // Outline
+        { ToonConstants.SHADER_PROP_OUTLINE_MODE, "_OUTLINE" },
+        { ToonConstants.SHADER_PROP_OUTLINE_WIDTH, "_Outline_Width" },
+        { ToonConstants.SHADER_PROP_OUTLINE_WIDTH_MAP, "_Outline_Sampler" },
+        { ToonConstants.SHADER_PROP_OUTLINE_COLOR, "_Outline_Color" },
+        { ToonConstants.SHADER_PROP_OUTLINE_BASE_COLOR_BLEND, "_Is_BlendBaseColor" },
+        { ToonConstants.SHADER_PROP_OUTLINE_LIGHT_COLOR_BLEND, "_Is_LightColor_Outline" },
+        { ToonConstants.SHADER_PROP_OUTLINE_OFFSET_Z, "_Offset_Z" },
+        { ToonConstants.SHADER_PROP_OUTLINE_NEAR, "_Nearest_Distance" },
+        { ToonConstants.SHADER_PROP_OUTLINE_FAR, "_Farthest_Distance" },
+
+        // Outline normal options (closest equivalents)
+        { ToonConstants.SHADER_PROP_OUTLINE_USE_NORMAL_MAP, "_Is_BakedNormal" },
+        { ToonConstants.SHADER_PROP_OUTLINE_NORMAL_MAP, "_BakedNormal" },
+    };
+ 
+
+    
+//----------------------------------------------------------------------------------------------------------------------    
+    public override void AssignNewShaderToMaterial(
+        Material mat,
+        Shader oldShader,
+        Shader newShader) 
+    {
+        
+        string oldShaderPath = AssetDatabase.GetAssetPath(oldShader);
+        if (!oldShaderPath.StartsWith(ToonEditorConstants.PACKAGE_PATH)) {
+            base.AssignNewShaderToMaterial(mat, oldShader, newShader);
+            return;
+        }
+
+        //Upgrade from Toon 3D
+        bool upgradeFromToon3D = oldShader.name.EndsWith("Toon") || oldShader.name.EndsWith("Toon(Tessellation)"); 
+        if (!upgradeFromToon3D) {
+            base.AssignNewShaderToMaterial(mat, oldShader, newShader);
+            return;
+        }
+        Dictionary<string, MaterialPropertyValue> captured = ToonMaterialUtility.CaptureMaterialValues(mat);
+        
+        base.AssignNewShaderToMaterial(mat, oldShader, newShader);
+        
+        //Assign captured values
+        foreach (KeyValuePair<string, string> kv in TOON_3D_AS_2D_TO_3D_MAP) {
+            string targetName = kv.Key; 
+            string srcName = kv.Value;  
+
+            // Ensure target exists in new material and we captured the source
+            if (!mat.HasProperty(targetName) || !captured.TryGetValue(srcName, out MaterialPropertyValue srcVal)) {
+                continue;
+            }
+
+            // Ensure types match between new target and captured source
+            int targetIndex = newShader.FindPropertyIndex(targetName);
+            if (targetIndex < 0) {
+                continue;
+            }
+            ShaderPropertyType targetType = newShader.GetPropertyType(targetIndex);
+            if (targetType != srcVal.type) {
+                continue;
+            }
+
+            srcVal.ApplyToMaterial(mat, targetName);
+        }
+        
+    }
+    
+
+
     private readonly Dictionary<string, MaterialPropertyUIElement> m_materialPropertyUIElements = new Dictionary<string, MaterialPropertyUIElement>();
 
     private ToonMaterialState m_materialState;
@@ -534,6 +615,9 @@ static readonly GUIContent LIGHTING_FOLDOUT
     bool m_normalMapFoldout = false;
     bool m_outlineFoldout = false;
     bool m_lightingFoldout = false;
+    
+    private Material m_lastMaterial;
+    
 
     struct ToonMaterialState {
         internal bool useOutline;

com.unity.toonshader/Editor/Scripts/ToonEditorConstants.cs

@@ -1,9 +1,15 @@
 
+using System.IO;
+using Unity.Rendering.Toon;
+
 namespace UnityEditor.Rendering.Toon {
 
 internal static class ToonEditorConstants {
 
     internal const int CUR_MATERIAL_VERSION = (int) ToonMaterialVersion.Initial;
+    
+    internal static readonly string PACKAGE_PATH = Path.Combine("Packages", ToonConstants.PACKAGE_NAME).Replace('\\','/');
+
 }
 
 } //end namespace

com.unity.toonshader/Runtime/Scripts/MaterialPropertyValue.cs

@@ -0,0 +1,69 @@
+using UnityEngine;
+using UnityEngine.Rendering;
+
+namespace Unity.Rendering.Toon {
+
+[System.Serializable]
+internal class MaterialPropertyValue {
+    internal static MaterialPropertyValue FromMaterial(Material mat, int propIndex) {
+        MaterialPropertyValue value = new MaterialPropertyValue();
+        Shader shader = mat.shader;
+        string name = shader.GetPropertyName(propIndex);
+        ShaderPropertyType type = shader.GetPropertyType(propIndex);
+        value.type = type;
+
+        switch (type) {
+            case ShaderPropertyType.Color:
+                value.color = mat.GetColor(name);
+                break;
+            case ShaderPropertyType.Vector:
+                value.vector = mat.GetVector(name);
+                break;
+            case ShaderPropertyType.Float:
+            case ShaderPropertyType.Range:
+                value.floatValue = mat.GetFloat(name);
+                break;
+            case ShaderPropertyType.Texture:
+                value.texture = mat.GetTexture(name);
+                value.texOffset = mat.GetTextureOffset(name);
+                value.texScale = mat.GetTextureScale(name);
+                break;
+        }
+
+        return value;
+    }
+    
+    internal void ApplyToMaterial(Material mat, string targetName) {
+        switch (type) {
+            case ShaderPropertyType.Color:
+                mat.SetColor(targetName, color);
+                break;
+            case ShaderPropertyType.Vector:
+                mat.SetVector(targetName, vector);
+                break;
+            case ShaderPropertyType.Float:
+            case ShaderPropertyType.Range:
+                mat.SetFloat(targetName, floatValue);
+                break;
+            case ShaderPropertyType.Texture:
+                mat.SetTexture(targetName, texture);
+                mat.SetTextureOffset(targetName, texOffset);
+                mat.SetTextureScale(targetName, texScale);
+                break;
+        }
+    }
+    
+//----------------------------------------------------------------------------------------------------------------------    
+    
+    internal ShaderPropertyType type;
+    internal Color color;
+    internal Vector4 vector;
+    internal float floatValue;
+    internal Texture texture;
+    internal Vector2 texOffset;
+    internal Vector2 texScale;
+    
+
+}
+
+} //end namespace

com.unity.toonshader/Runtime/Scripts/MaterialPropertyValue.cs.meta

@@ -0,0 +1,25 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Unity.Rendering.Toon {
+
+internal static class ToonMaterialUtility {
+    internal static Dictionary<string, MaterialPropertyValue> CaptureMaterialValues(Material mat) {
+        
+        Dictionary<string, MaterialPropertyValue> store = new Dictionary<string, MaterialPropertyValue>();
+        Shader shader = mat.shader;
+        int count = shader.GetPropertyCount();
+        for (int i = 0; i < count; i++) {
+            string name = shader.GetPropertyName(i);
+            
+            if (!mat.HasProperty(name)) 
+                continue;
+            MaterialPropertyValue value = MaterialPropertyValue.FromMaterial(mat, i);
+            store[name] = value;
+        }
+        return store;
+    }
+
+}
+
+}