Main/Assets/Editor/External/ModelEditor/ModelShaderInfo.cs

using Thousandto.Core.Asset;
using System;
using System.IO;
using UnityEditor;
using UnityEngine;

namespace Thousandto.Editor.ModelEditor
{
    public abstract class ModelShaderInfoBase
    {
        public abstract void Parse(string paramStr);
        public new abstract string ToString();
        public abstract bool OnGUI();
        public abstract string ShaderName { get; }
        public abstract void SetUpShader(Material mat);
        protected string ParseText(int index, string[] paramsArray, string defaultValue)
        {
            if (paramsArray != null && index >= 0 && index < paramsArray.Length)
            {
                return paramsArray[index];
            }
            return defaultValue;
        }
        protected float ParseFloat(int index, string[] paramsArray, float defaultValue)
        {
            if (paramsArray != null && index >= 0 && index < paramsArray.Length && !string.IsNullOrEmpty(paramsArray[index]))
            {
                float result = defaultValue;
                float.TryParse(paramsArray[index], out result);
                return result;
            }
            return defaultValue;
        }
        protected int ParseInt(int index, string[] paramsArray, int defaultValue)
        {
            if (paramsArray != null && index >= 0 && index < paramsArray.Length && !string.IsNullOrEmpty(paramsArray[index]))
            {
                int result = defaultValue;
                int.TryParse(paramsArray[index], out result);
                return result;
            }
            return defaultValue;
        }
        protected Color ParseColor(int index, string[] paramsArray, Color defaultValue)
        {
            if (paramsArray != null && index >= 0 && index < paramsArray.Length && !string.IsNullOrEmpty(paramsArray[index]))
            {
                Color result = defaultValue;
                int r, g, b, a;
                var colorArray = paramsArray[index].Split('_');
                if (colorArray.Length >= 3 && int.TryParse(colorArray[0], out r) && int.TryParse(colorArray[1], out g) && int.TryParse(colorArray[2], out b))
                {
                    result.r = r / 255f;
                    result.g = g / 255f;
                    result.b = b / 255f;
                }
                if (colorArray.Length >= 4 && int.TryParse(colorArray[3], out a))
                {
                    result.a = a / 255f;
                }
                return result;
            }
            return defaultValue;
        }

        protected string ToString(Color color)
        {
            return string.Format("{0}_{1}_{2}_{3}", (int)(color.r * 255), (int)(color.g * 255), (int)(color.b * 255), (int)(color.a * 255));
        }
    }

    //默认
    public class NormalShaderInfo : ModelShaderInfoBase
    {
        public override string ShaderName
        {
            get
            {
                return "Ares/Entity/LocalPlayer";
            }
        }

        public override bool OnGUI()
        {
            return false;
        }

        public override void Parse(string paramStr)
        {
        }

        public override void SetUpShader(Material mat)
        {
            mat.SetTexture(ShaderPropertyNameDefine.CN_SPN_FLOWTEX, null);
        }

        public override string ToString()
        {
            return string.Empty;
        }
    }

    //流光
    public class FlowShaderInfo : ModelShaderInfoBase
    {
        public string TexTure = string.Empty;  //, ShaderPropertyNameDefine.CN_SPN_FLOWTEX         //纹理
        public Color Color = Color.white; // , ShaderPropertyNameDefine.CN_SPN_FLOWCOLOR       //颜色 
        public float Dir = 0f;// , ShaderPropertyNameDefine.CN_SPN_FLOWTYPE        //方向
        public float Speed = 0f; // , ShaderPropertyNameDefine.CN_SPN_FLOWSPEED       //速度
        public float TileCount = 0f;  // , ShaderPropertyNameDefine.CN_SPN_FLOWTILECOUNT   //
        private bool _texChanged = false;

        public override string ShaderName
        {
            get
            {
                return "Ares/Entity/LocalPlayer";
            }
        }

        public override void SetUpShader(Material mat)
        {
            Texture tex = null;
            if (!string.IsNullOrEmpty(TexTure))
            {
                var path = Application.dataPath + "/GameAssets/Resources/Texture/Shader/" + TexTure + ".tga";
                if (!File.Exists(path))
                {
                    path = Application.dataPath + "/GameAssets/Resources/Texture/Shader/" + TexTure + ".png";
                    if (!File.Exists(path))
                    {
                        path = Application.dataPath + "/GameAssets/Resources/Texture/Shader/" + TexTure + ".jpg";
                        if (!File.Exists(path))
                        {
                            path = Application.dataPath + "/GameAssets/Resources/Texture/Shader/" + TexTure + ".dds";
                            if (!File.Exists(path))
                            {
                                path = Application.dataPath + "/GameAssets/Resources/Texture/Shader/" + TexTure + ".exr";
                            }
                        }
                    }
                }
                path = path.Replace('\\', '/');
                path = path.Substring(path.IndexOf("Assets"));
                tex = AssetDatabase.LoadAssetAtPath<Texture>(path);
            }
            mat.SetTexture(ShaderPropertyNameDefine.CN_SPN_FLOWTEX, tex);
            mat.SetColor(ShaderPropertyNameDefine.CN_SPN_FLOWCOLOR, Color);
            mat.SetFloat(ShaderPropertyNameDefine.CN_SPN_FLOWTYPE, Dir);
            mat.SetFloat(ShaderPropertyNameDefine.CN_SPN_FLOWSPEED, Speed);
            mat.SetFloat(ShaderPropertyNameDefine.CN_SPN_FLOWTILECOUNT, TileCount);
        }

        public override void Parse(string paramStr)
        {
            var paramsArray = paramStr.Split(';');
            TexTure = ParseText(0, paramsArray, string.Empty);
            Color = ParseColor(1, paramsArray, Color.white);
            Dir = ParseFloat(2, paramsArray, 0f);
            Speed = ParseFloat(3, paramsArray, 0f);
            TileCount = ParseFloat(4, paramsArray, 0f);
            _texChanged = false;
        }

        public override string ToString()
        {
            return string.Format("{0};{1};{2};{3};{4}", TexTure, ToString(Color), Dir, Speed, TileCount);
        }
        public override bool OnGUI()
        {
            bool result = false;
            EditorGUILayout.BeginVertical();
            EditorGUILayout.BeginHorizontal();
            GUILayout.Label("纹理", GUILayout.Width(30));
            GUILayout.TextField(TexTure, GUILayout.Width(100));
            if (GUILayout.Button("选择", GUILayout.Width(30)))
            {
                ModelSelectTextureEditor.Open((texName) =>
                {
                    TexTure = texName;
                    _texChanged = true;
                });
            }
            EditorGUILayout.EndHorizontal();
            var newColor = EditorGUILayout.ColorField("颜色", Color, GUILayout.Width(300));
            var newDir = EditorGUILayout.FloatField("方向", Dir, GUILayout.Width(200));
            var newSpeed = EditorGUILayout.FloatField("速度", Speed, GUILayout.Width(200));
            var newCount = EditorGUILayout.FloatField("数量", TileCount, GUILayout.Width(200));
            EditorGUILayout.EndVertical();
            if (newColor != Color || newDir != Dir || newSpeed != Speed || newCount != TileCount)
            {
                Color = newColor;
                Dir = newDir;
                Speed = newSpeed;
                TileCount = newCount;
                result = true;
            }
            if (_texChanged)
            {
                _texChanged = false;
                result = true;
            }
            return result;
        }
    }

    //边缘光
    public class RimShaderInfo : ModelShaderInfoBase
    {
        public float Power = 0f;//, ShaderPropertyNameDefine.CN_SPN_RIMPOWER       //边缘光的集中度
        public Color Color = Color.white;//, ShaderPropertyNameDefine.CN_SPN_RIMCOLOR       //边缘光颜色      
        public override string ShaderName
        {
            get
            {
                return "Ares/EntityState/BeHit";
            }
        }
        public override void SetUpShader(Material mat)
        {
            mat.SetFloat(ShaderPropertyNameDefine.CN_SPN_RIMPOWER, Power);
            mat.SetColor(ShaderPropertyNameDefine.CN_SPN_RIMCOLOR, Color);
        }
        public override void Parse(string paramStr)
        {
            var paramsArray = paramStr.Split(';');
            Power = ParseFloat(0, paramsArray, 5f);
            Color = ParseColor(1, paramsArray, Color.white);
        }

        public override string ToString()
        {
            return string.Format("{0};{1}", Power, ToString(Color));
        }
        public override bool OnGUI()
        {
            EditorGUILayout.BeginVertical();
            var result = false;
            var newPower = EditorGUILayout.FloatField("强度", Power, GUILayout.Width(200));
            var newColor = EditorGUILayout.ColorField("颜色", Color, GUILayout.Width(300));
            EditorGUILayout.EndVertical();

            if (newPower < 0f) newPower = 0f;
            if (newPower != Power || newColor != Color)
            {
                Power = newPower;
                Color = newColor;
                result = true;
            }
            return result;
        }
    }

    //消融
    public class DissolvingShaderInfo : ModelShaderInfoBase
    {
        public float GrayTime;//, ShaderPropertyNameDefine.CN_SPN_GRAYTIME            //灰色时间
        public float DissTime; //, ShaderPropertyNameDefine.CN_SPN_DISSTIME            //溶解的时间
        public float TimeLine; //, ShaderPropertyNameDefine.CN_SPN_TIMELINE            //时间线,用于设置当前的状态
        public override string ShaderName
        {
            get
            {
                return "Ares/EntityState/Dead";
            }
        }
        public override void SetUpShader(Material mat)
        {
            mat.SetFloat(ShaderPropertyNameDefine.CN_SPN_GRAYTIME, GrayTime);
            mat.SetFloat(ShaderPropertyNameDefine.CN_SPN_DISSTIME, DissTime);
            mat.SetFloat(ShaderPropertyNameDefine.CN_SPN_TIMELINE, TimeLine);
        }
        public override void Parse(string paramStr)
        {
            var paramsArray = paramStr.Split(';');
            GrayTime = ParseFloat(0, paramsArray, 0f);
            DissTime = ParseFloat(1, paramsArray, 1f);
            TimeLine = ParseFloat(2, paramsArray, 0.5f);
        }

        public override string ToString()
        {
            return string.Format("{0};{1};{2}", GrayTime, DissTime, TimeLine);
        }

        public override bool OnGUI()
        {
            EditorGUILayout.BeginVertical();
            var result = false;
            var newGrayTime = EditorGUILayout.FloatField("灰色时间", GrayTime, GUILayout.Width(200));
            var newDissTime = EditorGUILayout.FloatField("溶解时间", DissTime, GUILayout.Width(200));
            var newTimeLine = EditorGUILayout.FloatField("时间线", TimeLine, GUILayout.Width(200));
            EditorGUILayout.EndVertical();
            if (newGrayTime < 0f) newGrayTime = 0f;
            if (newDissTime < 0f) newDissTime = 0f;
            if (newTimeLine < 0f) newTimeLine = 0f;
            if (newGrayTime != GrayTime || newDissTime != DissTime || newTimeLine != TimeLine)
            {
                GrayTime = newGrayTime;
                DissTime = newDissTime;
                TimeLine = newTimeLine;
                result = true;
            }
            return result;
        }
    }

    //半透
    public class TransparentShaderInfo : ModelShaderInfoBase
    {
        public Color Color;//, ShaderPropertyNameDefine.CN_SPN_COLOR            //颜色
        public override string ShaderName
        {
            get
            {
                return "Ares/EntityState/Grown";
            }
        }
        public override void SetUpShader(Material mat)
        {
            mat.SetColor(ShaderPropertyNameDefine.CN_SPN_COLOR, Color);
        }
        public override void Parse(string paramStr)
        {
            var paramsArray = paramStr.Split(';');
            Color = ParseColor(0, paramsArray, Color.white);
        }

        public override string ToString()
        {
            return string.Format("{0}", ToString(Color));
        }
        public override bool OnGUI()
        {
            GUILayout.Label("颜色", GUILayout.Width(30));
            var newColor = EditorGUILayout.ColorField(Color, GUILayout.Width(80));
            if (newColor != Color)
            {
                Color = newColor;
                return true;
            }
            return false;
        }
    }

    //琉璃效果
    public class GlassShaderInfo : ModelShaderInfoBase
    {
        public string TexTure = string.Empty;

        private bool _texChanged = false;
        public override string ShaderName
        {
            get
            {
                return "Ares/Show/Entity/GlazeEntity";
            }
        }

        public override bool OnGUI()
        {
            bool result = false;
            EditorGUILayout.BeginVertical();
            EditorGUILayout.BeginHorizontal();
            GUILayout.Label("纹理", GUILayout.Width(30));
            GUILayout.TextField(TexTure, GUILayout.Width(100));
            if (GUILayout.Button("选择", GUILayout.Width(30)))
            {
                ModelSelectTextureEditor.Open((texName) =>
                {
                    TexTure = texName;
                    _texChanged = true;
                });
            }
            EditorGUILayout.EndHorizontal();
            EditorGUILayout.EndVertical();

            if (_texChanged)
            {
                _texChanged = false;
                result = true;
            }
            return result;
        }

        public override void Parse(string paramStr)
        {
            TexTure = paramStr;
        }

        public override void SetUpShader(Material mat)
        {
            Texture tex = null;
            if (!string.IsNullOrEmpty(TexTure))
            {
                var path = Application.dataPath + "/GameAssets/Resources/Texture/Shader/" + TexTure + ".tga";
                if (!File.Exists(path))
                {
                    path = Application.dataPath + "/GameAssets/Resources/Texture/Shader/" + TexTure + ".png";
                    if (!File.Exists(path))
                    {
                        path = Application.dataPath + "/GameAssets/Resources/Texture/Shader/" + TexTure + ".jpg";
                        if (!File.Exists(path))
                        {
                            path = Application.dataPath + "/GameAssets/Resources/Texture/Shader/" + TexTure + ".dds";
                            if (!File.Exists(path))
                            {
                                path = Application.dataPath + "/GameAssets/Resources/Texture/Shader/" + TexTure + ".exr";
                            }
                        }
                    }
                }
                path = path.Replace('\\', '/');
                path = path.Substring(path.IndexOf("Assets"));
                tex = AssetDatabase.LoadAssetAtPath<Texture>(path);
            }
            mat.SetTexture(ShaderPropertyNameDefine.CN_SPN_ENVCUBE, tex);
        }

        public override string ToString()
        {
            return TexTure;
        }
    }

    //新流光
    public class NewFlowShaderInfo : ModelShaderInfoBase
    {
        public string TexTure = string.Empty;  //, ShaderPropertyNameDefine.CN_SPN_FLOWTEX         //纹理
        public Color Color1 = Color.white; // , ShaderPropertyNameDefine.CN_SPN_FLOWCOLOR       //颜色 
        public Color Color2 = Color.white; // , ShaderPropertyNameDefine.CN_SPN_FLOWCOLOR2       //颜色 
        public float Speed = 0f; // , ShaderPropertyNameDefine.CN_SPN_FLOWSPEED       //速度
        private bool _texChanged = false;

        public override string ShaderName
        {
            get
            {
                return "Ares/Entity/LocalPlayer_Flux";
            }
        }

        public override void SetUpShader(Material mat)
        {
            Texture tex = null;
            if (!string.IsNullOrEmpty(TexTure))
            {
                var path = Application.dataPath + "/GameAssets/Resources/Texture/Shader/" + TexTure + ".tga";
                if (!File.Exists(path))
                {
                    path = Application.dataPath + "/GameAssets/Resources/Texture/Shader/" + TexTure + ".png";
                    if (!File.Exists(path))
                    {
                        path = Application.dataPath + "/GameAssets/Resources/Texture/Shader/" + TexTure + ".jpg";
                        if (!File.Exists(path))
                        {
                            path = Application.dataPath + "/GameAssets/Resources/Texture/Shader/" + TexTure + ".dds";
                            if (!File.Exists(path))
                            {
                                path = Application.dataPath + "/GameAssets/Resources/Texture/Shader/" + TexTure + ".exr";
                            }
                        }
                    }
                }
                path = path.Replace('\\', '/');
                path = path.Substring(path.IndexOf("Assets"));
                tex = AssetDatabase.LoadAssetAtPath<Texture>(path);
            }
            mat.SetTexture(ShaderPropertyNameDefine.CN_SPN_FLOWTEX, tex);
            mat.SetColor(ShaderPropertyNameDefine.CN_SPN_FLOWCOLOR, Color1);
            mat.SetColor(ShaderPropertyNameDefine.CN_SPN_FLOWCOLOR2, Color2);
            mat.SetFloat(ShaderPropertyNameDefine.CN_SPN_FLOWSPEED, Speed);
        }

        public override void Parse(string paramStr)
        {
            var paramsArray = paramStr.Split(';');
            TexTure = ParseText(0, paramsArray, string.Empty);
            Color1 = ParseColor(1, paramsArray, Color.white);
            Color2 = ParseColor(2, paramsArray, Color.white);
            Speed = ParseFloat(3, paramsArray, 0f);
            _texChanged = false;
        }

        public override string ToString()
        {
            return string.Format("{0};{1};{2};{3}", TexTure, ToString(Color1), ToString(Color2), Speed);
        }
        public override bool OnGUI()
        {
            bool result = false;
            EditorGUILayout.BeginVertical();
            EditorGUILayout.BeginHorizontal();
            GUILayout.Label("纹理", GUILayout.Width(30));
            GUILayout.TextField(TexTure, GUILayout.Width(100));
            if (GUILayout.Button("选择", GUILayout.Width(30)))
            {
                ModelSelectTextureEditor.Open((texName) =>
                {
                    TexTure = texName;
                    _texChanged = true;
                });
            }
            EditorGUILayout.EndHorizontal();
            var newColor1 = EditorGUILayout.ColorField("颜色1", Color1, GUILayout.Width(300));
            var newColor2 = EditorGUILayout.ColorField("颜色2", Color2, GUILayout.Width(300));
            var newSpeed = EditorGUILayout.FloatField("速度", Speed, GUILayout.Width(200));
            EditorGUILayout.EndVertical();
            if (newColor1 != Color1 || newColor2 != Color2 || newSpeed != Speed)
            {
                Color1 = newColor1;
                Color2 = newColor2;
                Speed = newSpeed;
                result = true;
            }
            if (_texChanged)
            {
                _texChanged = false;
                result = true;
            }
            return result;
        }
    }
}