前言：写shader的时候，一旦参数多起来，就感觉一大串超级长超级难看，所以在此学习一下别的大佬些的GUI。
    1：模仿目标是熊猫的shaderGUI
    image.png
    看了一下GUI文件，5000多行。。超级长，加上不是特别熟练，很多都看不太懂，看来是不能一下子全部实现,,,没办法，先定个小目标，只实现基础设置这一个模块。
    image.png
    第一段，自定义下拉菜单的形状属性

    1. //自定义下拉菜单的形状属性
    2.     static bool Foldout(bool display, string title)
    3.     {
    4.         var style = new GUIStyle("ShurikenModuleTitle");
    5.         style.font = new GUIStyle(EditorStyles.boldLabel).font;
    6.         style.border = new RectOffset(15, 7, 4, 4);
    7.         style.fixedHeight = 22;
    8.         style.contentOffset = new Vector2(20f, -2f);
    9.         style.fontSize = 11;
    10.         style.normal.textColor = new Color(0.7f, 0.8f, 0.9f);
    13.         var rect = GUILayoutUtility.GetRect(16f, 25f, style);
    14.         GUI.Box(rect, title, style);
    16.         var e = Event.current;
    18.         var toggleRect = new Rect(rect.x + 4f, rect.y + 2f, 13f, 13f);
    19.         if (e.type == EventType.Repaint)
    20.         {
    21.             EditorStyles.foldout.Draw(toggleRect, false, false, display, false);
    22.         }
    24.         if (e.type == EventType.MouseDown && rect.Contains(e.mousePosition))
    25.         {
    26.             display = !display;
    27.             e.Use();
    28.         }
    30.         return display;
    31.     }

    好了，一开始就遇到不懂的问题了（不愧是我）
    看到第一行定义了style，这里有一个GUIStyle不是很清楚是干嘛的，看起来像是新建一个什么东东。这时候就到百度上场了！

    1. var style = new GUIStyle("ShurikenModuleTitle");

    上链接！
    https://blog.csdn.net/u011428080/article/details/106676213
    GUIStyle可以new一个全新的实例，这样，需要自己处理所有自己需要的效果。
    GUIStyle还可以基于已经存在的实例new一个新的实例，这样，只需对原有的效果中不符合自己需求的进行修改（省事省力，这类情况是我们最常用的），譬如：

    1. GUIStyle btnStyle = new GUIStyle("Command");
    2. btnStyle.fontSize = 12;
    3. btnStyle.alignment = TextAnchor.MiddleCenter;
    4. btnStyle.imagePosition = ImagePosition.ImageAbove;
    5. btnStyle.fontStyle = FontStyle.Normal;
    6. btnStyle.fixedWidth = 60;
    8. //等同于：
    9. GUIStyle btnStyle_1 = new GUIStyle("Command")
    10. {
    11.     fontSize = 12,
    12.     alignment = TextAnchor.MiddleCenter,
    13.     imagePosition = ImagePosition.ImageAbove,
    14.     fontStyle = FontStyle.Normal,
    15.     fixedWidth = 60
    16. };

    那么到底怎么从内置的GUIStyle中找到自己想要的呢？

    AssetStore里曾经有一个名为“Edior Style Viewer”的插件可以预览内置的所有GUIStyle，但是该插件已经下架。其实我们可以自己写一个脚本去查看，因为遍历 GUI.skin.customStyles 可以取到所有的内置GUIStyle，先上效果图：
    image.png
    （名字这一列是可以被选中复制的）
    话不多说，Editor下的代码如下：

    1. using UnityEngine;
    2. using UnityEditor;
    4.  public class GUIStyleViewer : EditorWindow {
    6.      Vector2 scrollPosition = new Vector2(0,0);
    7.      string search = "";
    8.      GUIStyle textStyle;
    10.      private static GUIStyleViewer window;
    11.      [MenuItem("Tool/GUIStyleViewer", false, 10)]
    12.      private static void OpenStyleViewer()
    13.      {
    14.          window = GetWindow<GUIStyleViewer>(false, "内置GUIStyle");
    15.      }
    17.      void OnGUI()
    18.      {
    19.          if (textStyle == null)
    20.          {
    21.              textStyle = new GUIStyle("HeaderLabel");
    22.              textStyle.fontSize = 25;
    23.          }
    25.          GUILayout.BeginHorizontal("HelpBox");
    26.          GUILayout.Label("结果如下：", textStyle);
    27.          GUILayout.FlexibleSpace();
    28.          GUILayout.Label("Search:");
    29.          search = EditorGUILayout.TextField(search);
    30.          GUILayout.EndHorizontal(); 
    31.          GUILayout.BeginHorizontal("PopupCurveSwatchBackground");
    32.          GUILayout.Label("样式展示", textStyle, GUILayout.Width(300));
    33.          GUILayout.Label("名字", textStyle, GUILayout.Width(300));
    34.          GUILayout.EndHorizontal();
    37.          scrollPosition = GUILayout.BeginScrollView(scrollPosition);
    39.          foreach (var style in GUI.skin.customStyles)
    40.          {
    41.              if (style.name.ToLower().Contains(search.ToLower()))
    42.              {
    43.                  GUILayout.Space(15);
    44.                  GUILayout.BeginHorizontal("PopupCurveSwatchBackground");
    45.                 if (GUILayout.Button(style.name, style, GUILayout.Width(300)))
    46.                  {
    47.                      EditorGUIUtility.systemCopyBuffer = style.name ;
    48.                      Debug.LogError(style.name);
    49.                  }
    50.                  EditorGUILayout.SelectableLabel(style.name, GUILayout.Width(300));
    51.                  GUILayout.EndHorizontal();
    52.              }
    53.          }
    55.          GUILayout.EndScrollView();
    56.      }
    57.  }

    感觉这也算是一个标准的GUI文件了，可以参考这个格式。

    1. using System.Collections.Generic;
    2. using UnityEngine;
    3. using UnityEditor;
    4. using System.Linq;
    6. public class CustomShaderGUI : ShaderGUI
    7. {
    8.     override public void OnGUI(MaterialEditor materialEditor, MaterialProperty[] properties)
    9.     {
    10.         // 使用默认GUI渲染着色器属性
    11.         base.OnGUI(materialEditor, properties);
    13.         // 从材料中获取当前的关键字
    14.         Material targetMat = materialEditor.target as Material;
    15.         string[] keyWords = targetMat.shaderKeywords;
    17.         // 查看是否设置了重新设置，然后显示一个复选框
    18.         bool redify = keyWords.Contains("REDIFY_ON");
    19.         EditorGUI.BeginChangeCheck();
    20.         redify = EditorGUILayout.Toggle("Redify material", redify);
    21.         if (EditorGUI.EndChangeCheck())
    22.         {
    23.             // 如果复选框更改，请重置着色器关键字
    24.             var keywords = new List<string> { redify ? "REDIFY_ON" : "REDIFY_OFF" };
    25.             targetMat.shaderKeywords = keywords.ToArray();
    26.             EditorUtility.SetDirty(targetMat);
    27.         }
    28.     }
    29. }

    在官网翻到ShaderGUI的介绍，感觉这个才是常规操作？
    image.png
    直接套用，在shader面板上多了Redify material，看来这个是可以使用的，但是使用方法还需要研究一下。
    现在还是先回到熊猫的GUI上面来。
    直接在官方API可以查到GUIStyle这个函数的作用。
    image.png
    好！现在局势明朗起来了！实现之后可以尝试diy一下这些属性~
    image.png
    有一段感觉是比较重要的
    image.png
    EventType.Repaint
    UnityGui输入和处理事件的类型。
    用它来判断GUI中发生了哪种类型的事件。事件的类型包括鼠标单击，鼠标拖动，按钮按下，鼠标进入或退出窗口以及滚动轮以及下面提到的其他事件。
    下面是官方给出的代码，看起来是根据我们鼠标的点击，输出不同的结果

    1. //将此脚本附加到游戏对象
    2. //该脚本是一些可用的事件类型的基本概述。它根据当前事件类型输出消息。
    3. using UnityEngine;
    5. public class Example : MonoBehaviour
    6. {
    7.     void OnGUI()
    8.     {
    9.         Event m_Event = Event.current;
    11.         if (m_Event.type == EventType.MouseDown)
    12.         {
    13.             Debug.Log("Mouse Down.");
    14.         }
    16.         if (m_Event.type == EventType.MouseDrag)
    17.         {
    18.             Debug.Log("Mouse Dragged.");
    19.         }
    21.         if (m_Event.type == EventType.MouseUp)
    22.         {
    23.             Debug.Log("Mouse Up.");
    24.         }
    25.     }
    26. }

    在熊猫GUI的里还有2个下拉菜单的形状属性，这里就不贴出来了。
    image.png
    下一步、跳过跳过~跳了几百行代码…因为我们只实现“基础设置下拉菜单”，所以跳过了非常多的代码~
    然后基本到最后阶段了，在脚本里加上这个方法之后，就可以在shader面板里面看到我们想要的结果了。接下来就是详细的解析一遍这些代码。image.png
    image.pngSnipaste_2022-06-06_10-36-20.png
    这一步之后基本就是重复的结构了。
    有个小问题：
    不知道为什么熊猫的shader里面，他的主帖图会有Tilling和Offset
    image.png
    其实就是少了这一句，芜湖~
    image.png

    贴一下复刻的最终效果
    image.png

    1. Shader "Songao/FlowMaskGUITest"
    2. {
    3.     Properties
    4.     {
    5.         [Enum(UnityEngine.Rendering.CullMode)]_Cullmode("Cullmode", Float) = 0
    6.         [Enum(UnityEngine.Rendering.CompareFunction)]_Ztest("Ztest", Float) = 4
    7.         [Enum(UnityEngine.Rendering.BlendMode)]_Scr("Scr", Float) = 5
    8.         [Enum(UnityEngine.Rendering.BlendMode)]_Dst("Dst", Float) = 10
    9.         _Zwrite("Zwrite", Float) = 0
    12.         _MainTex("_MainTex" , 2D)= "white"{}//主贴图
    13.         [HideInInspector]_MainTex_ST("MainTex_ST", Vector) = (1,1,0,0)
    14.         [HDR]_TintColor("_TintColor",Color) = (1,1,1,1)//主颜色
    15.         _Intensity( "_Intensity", Range(0,10) ) = 1//颜色强度
    16.         _MainFlowX("_MainFlowX",float) = 0//主贴图x轴流动
    17.         _MainFlowY("_MainFlowY",float) = 0//主贴图y轴流动
    20.         _NoiseTex("_NoiseTex",2D) = "white" {}//噪音贴图
    21.         _NoiseScaleX( "_NoiseScaleX", float ) = 2//噪音贴图x轴缩放
    22.         _NoiseScaleY( "_NoiseScaleY", float ) = 2//噪音贴图y轴缩放
    23.         _NoiseFlowX( "_NoiseFlowX", float ) = 2//噪音贴图x轴流动
    24.         _NoiseFlowY( "_NoiseFlowY", float ) = 2//噪音贴图x轴流动
    26.         [Toggle(ADD_NO_ISECTRL)]_AddNoiseCtrl("_AddNoiseCtrl",float) = 0
    27.         _NoiseCtrl("_NoiseCtrl",2D) = "Gray" {}//噪声边缘贴图
    28.         _NoiseCtrlIntensity( "_NoiseCtrlIntensity", float ) = 1//噪声边缘强度
    29.         _LineWidth("_LineWidth",Range(0.0,0.2)) = 0.1//边缘宽度
    30.         _LineRange("_LineRange",Range(0.0,0.2)) = 0.05//边缘范围
    31.         _LineChange("_LineChange",float) = 30//边缘变化
    32.         _Amount("_Amount",Range(0.0,2.0)) = 0.0//边缘量
    34.         _DissolveFade( "_DissolveFade", float ) = 20//溶解消失
    35.         [HDR]_DissolveColor1("_DissolveColor1",Color) = (1,0,0,1)//溶解颜色1
    36.         [HDR]_DissolveColor2("_DissolveColor2",Color) = (1,0,0,1)//溶解颜色2
    38.         //_Smooth("Smooth" , Range(0,4)) = 2
    39.         //_FloorY("FloorY" , float ) = 0
    40.     }
    42.     SubShader
    43.     {
    44.         LOD 300
    45.         Tags
    46.         {
    47.             "Queue" = "Transparent"
    48.             "IgnoreProjector" = "True"
    49.         }
    51.         Pass
    52.         {
    53.             Cull [_Cullmode]
    54.             ZWrite [_Zwrite]
    55.             ZTest [_Ztest]
    57.             Lighting Off
    58.             Fog {Mode Off}
    59.             Blend [_Scr] [_Dst]
    61.             CGPROGRAM
    62.             //#pragma shader_feature _AddNoiseCtrl_ON
    63.             #pragma multi_compile __ ADD_NO_ISECTRL
    65.             #pragma vertex vert
    66.             #pragma fragment frag
    67.             #pragma multi_compile_fog
    69.             #pragma fragmentoption APB_precision_hint_faster
    70.             #include "UnityCG.cginc"
    73.             sampler2D _MainTex;
    74.             half4 _MainTex_ST;
    76.             sampler2D _NoiseTex;
    77.             sampler2D _NoiseCtrl;
    78.             half _NoiseCtrlIntensity;
    79.             half4 _NoiseTex_ST;
    80.             fixed _Amount;
    81.             fixed4 _DissolveColor1;
    82.             fixed4 _DissolveColor2;
    83.             fixed _LineWidth;
    84.             half _NoiseScaleX,_NoiseScaleY;
    85.             half _Intensity;
    86.             half4 _TintColor;
    87.             half _LineRange;
    88.             half _LineChange;
    89.             half _NoiseFlowX,_NoiseFlowY;
    90.             half _MainFlowX,_MainFlowY;
    91.             half _DissolveFade;
    94.             struct v2f
    95.             {
    96.                 float4 pos : POSITION;
    97.                 half2 uv : TEXCOORD0;
    98.                 half4 color : COLOR;
    99.                 float4 customData1:TEXCOORD1;
    100.                 half4 dissolveUV:TEXCOORD2;
    101.                 float3 worldPos : TEXCOORD3;
    102.             };
    104.             v2f vert(appdata_full v)
    105.             {
    106.                 v2f o;
    107.                 o.pos = UnityObjectToClipPos(v.vertex);
    108.                 o.uv = v.texcoord.xy * _MainTex_ST.xy + _MainTex_ST.zw;
    109.                 o.uv += half2(_MainFlowX,_MainFlowY) * _Time.y;
    110.                 o.color = v.color;
    111.                 o.customData1 = v.texcoord1;
    112.                 o.dissolveUV.xy =  v.texcoord.xy * half2(_NoiseScaleX,_NoiseScaleY) + ( half2(_NoiseFlowX,_NoiseFlowY) + half2(o.customData1.y, 0) ) * _Time.y + _NoiseTex_ST.zw;
    113.                 o.dissolveUV.zw =  v.texcoord.xy;
    114.                 o.worldPos = mul(unity_ObjectToWorld , v.vertex);
    115.                 return o;
    116.             };
    119.             fixed4 frag(v2f i):COLOR
    120.             {
    121.                 fixed3 dissolve = tex2D(_NoiseTex,i.dissolveUV.xy).rgb;
    122.                 fixed3 dissolveCtrl = tex2D(_NoiseCtrl,i.dissolveUV.zw).rgb * 2 - 1;
    124.                 float vertexAlpha = 1.5 - i.customData1.x * 2;
    126.                 //选择是否添加额外noise
    127.                 #ifdef ADD_NO_ISECTRL
    128.                 vertexAlpha -=  dissolveCtrl.g * _NoiseCtrlIntensity;
    129.                 #endif
    131.                 clip( dissolve.g - vertexAlpha);
    132.                 half2 customUV = i.uv + i.customData1.zw;
    134.                 half4 color = tex2D(_MainTex,customUV);
    136.                 //return color;
    138.                 color.rgb *= _Intensity * _TintColor.rgb * i.color.rgb;
    139.                 fixed t = 1 - smoothstep(0.0,_LineWidth,dissolve.r - _Amount);
    140.                 fixed3 dissolveColor = lerp(_DissolveColor1,_DissolveColor2,t);
    141.                  dissolveColor = pow(dissolveColor,5);
    142.                 half t2 = saturate( ( dissolve.g - vertexAlpha - _LineRange ) * _LineChange );
    143.                 color.rgb = lerp( dissolveColor, color.rgb, t2 );
    145.                 half fade = smoothstep( 0, 1 , saturate( ( dissolve.g - vertexAlpha ) * _DissolveFade ) );
    146.                 color.a *= _TintColor.a * i.color.a * fade;
    147.                 return color;
    150.                 //float worldY = i.worldPos.y;
    151.                 //_FloorY = _GlobalFloorHeight + _FloorY;
    152.                 //float ramp = smoothstep(_FloorY - _Smooth , _FloorY + _Smooth , worldY) ;
    153.                 //color.a *= _TintColor.a * i.color.a * fade  ;
    154.                 //return color;
    155.             };
    157.             ENDCG
    158.         }
    159.     }
    160.     CustomEditor "FlowMaskGUITest"
    161. }
    1. using UnityEngine;
    2. using UnityEditor;
    3. using System;
    5. public class FlowMaskGUITest : ShaderGUI
    6. {
    7.     //自定义一个小按钮
    8.     public GUILayoutOption[] shortButtonStyle = new GUILayoutOption[] { GUILayout.Width(100) };
    9.     //自定义字体
    10.     public GUIStyle style = new GUIStyle();
    11.     //自定义下拉菜单的形状属性
    12.     static bool Foldout(bool display, string title)
    13.     {
    14.         //GUIStyle可以new一个全新的实例，这样，需要自己处理所有自己需要的效果。
    15.         //还可以基于已经存在的实例new一个新的实例，这样，只需对原有的效果中不符合自己需求的进行修改（省事省力，这类情况是我们最常用的）
    16.         var style = new GUIStyle("ShurikenModuleTitle");
    17.         //用于渲染的字体。如果为 null，则使用当前 GUISkin 的默认字体。
    18.         style.font = new GUIStyle(EditorStyles.boldLabel).font;
    20.         //要使用的字体大小（用于动态字体）。
    21.         style.fontSize = 11;
    23.         //背景图像边框
    24.         style.border = new RectOffset(15, 7, 4, 4);
    26.         //如果非 0，则使用此样式呈现的任何 GUI 元素都将具有此处指定的高度。
    27.         style.fixedHeight = 22;
    29.         //应用于此 GUIstyle 内容的像素偏移。
    30.         style.contentOffset = new Vector2(20f, -2f);
    32.         //组件正常显示时的渲染设置。
    33.         style.normal.textColor = new Color(0.7f, 0.8f, 0.9f);
    36.         //为矩形保留布局空间，用于显示具有特定样式的一些内容。
    37.         var rect = GUILayoutUtility.GetRect(16f, 25f, style);
    39.         //在 GUI 层上创建一个框。
    40.         GUI.Box(rect, title, style);
    42.         //当前正在处理的当前事件。
    43.         var e = Event.current;
    45.         //Rect由 X 和 Y 位置、宽度和高度定义的 2D 矩形。
    46.         var toggleRect = new Rect(rect.x + 4f, rect.y + 2f, 13f, 13f);
    48.         //EventType是UnityGUI 输入和处理事件的类型。
    49.         //绘制下拉窗口
    50.         if (e.type == EventType.Repaint)
    51.         {
    52.             EditorStyles.foldout.Draw(toggleRect, false, false, display, false);
    53.         }
    55.         if (e.type == EventType.MouseDown && rect.Contains(e.mousePosition))
    56.         {
    57.             display = !display;
    58.             e.Use();
    59.         }
    61.         return display;
    62.     }
    64.     //自定义下拉菜单2的形状属性
    65.     static bool Foldout2(bool display, string title)
    66.     {
    67.         var style = new GUIStyle("ShurikenModuleTitle");
    68.         style.font = new GUIStyle(EditorStyles.boldLabel).font;
    69.         style.border = new RectOffset(15, 7, 4, 4);
    70.         style.fixedHeight = 22;
    71.         style.contentOffset = new Vector2(20f, -2f);
    72.         style.fontSize = 11;
    73.         style.normal.textColor = new Color(0.65f, 0.55f, 0.55f);
    75.         var rect = GUILayoutUtility.GetRect(16f, 25f, style);
    76.         GUI.Box(rect, title, style);
    78.         var e = Event.current;
    80.         var toggleRect = new Rect(rect.x + 4f, rect.y + 2f, 13f, 13f);
    81.         if (e.type == EventType.Repaint)
    82.         {
    83.             EditorStyles.foldout.Draw(toggleRect, false, false, display, false);
    84.         }
    86.         if (e.type == EventType.MouseDown && rect.Contains(e.mousePosition))
    87.         {
    88.             display = !display;
    89.             e.Use();
    90.         }
    92.         return display;
    93.     }
    95.     //自定义变量
    96.     static bool _Base_Foldout = true;//基础设置下拉菜单，下拉列表判断
    97.     static bool _Maintextures_Foldout = true;//主贴图窗口下拉菜单
    98.     static bool _Disslovetextures_Foldout = true;//溶解窗口下拉菜单
    99.     static bool _NoiseTexAdd = false;//额外的溶解图开关
    101.     MaterialEditor m_MaterialEditor;
    102.     //shader属性
    103.     MaterialProperty mainTex = null;
    104.     MaterialProperty NoiseTex = null;
    105.     MaterialProperty NoiseCtrl = null;
    106.     MaterialProperty NoiseCtrlIntensity = null;
    107.     MaterialProperty Amount = null;
    108.     MaterialProperty DissolveColor1 = null;
    109.     MaterialProperty DissolveColor2 = null;
    110.     MaterialProperty NoiseScaleX = null;
    111.     MaterialProperty NoiseScaleY = null;
    112.     MaterialProperty Intensity = null;
    113.     MaterialProperty TintColor = null;
    114.     MaterialProperty LineWidth = null;
    115.     MaterialProperty LineRange = null;
    116.     MaterialProperty LineChange = null;
    117.     MaterialProperty NoiseFlowX = null;
    118.     MaterialProperty NoiseFlowY = null;
    119.     MaterialProperty MainFlowX = null;
    120.     MaterialProperty MainFlowY = null;
    121.     MaterialProperty DissolveFade = null;
    122.     MaterialProperty AddNoiseCtrl = null;
    126.     //将自定义的需要显示的属性指向shader里的相应变量
    127.     public void FindProperties(MaterialProperty[] props)
    128.     {
    129.         //主帖图属性指向
    130.         mainTex = FindProperty("_MainTex", props);
    131.         NoiseTex = FindProperty("_NoiseTex", props);
    132.         NoiseCtrl = FindProperty("_NoiseCtrl", props);
    133.         NoiseCtrlIntensity = FindProperty("_NoiseCtrlIntensity", props);
    134.         Amount = FindProperty("_Amount", props);
    135.         DissolveColor1 = FindProperty("_DissolveColor1", props);
    136.         DissolveColor2 = FindProperty("_DissolveColor2", props);
    137.         NoiseScaleX = FindProperty("_NoiseScaleX", props);
    138.         NoiseScaleY = FindProperty("_NoiseScaleY", props);
    139.         Intensity = FindProperty("_Intensity", props);
    140.         TintColor = FindProperty("_TintColor", props);
    141.         LineWidth = FindProperty("_LineWidth", props);
    142.         LineChange = FindProperty("_LineChange", props);
    143.         LineRange = FindProperty("_LineRange", props);
    144.         NoiseFlowX = FindProperty("_NoiseFlowX", props);
    145.         NoiseFlowY = FindProperty("_NoiseFlowY", props);
    146.         MainFlowX = FindProperty("_MainFlowX", props);
    147.         MainFlowY = FindProperty("_MainFlowY", props);
    148.         DissolveFade = FindProperty("_DissolveFade", props);
    149.         AddNoiseCtrl = FindProperty("_AddNoiseCtrl", props);
    150.     }
    152.     //将上面定义的属性显示在面板上
    153.     public override void OnGUI(MaterialEditor materialEditor, MaterialProperty[] props)
    154.     {
    155.         FindProperties(props);
    156.         m_MaterialEditor = materialEditor;
    157.         Material material = materialEditor.target as Material;
    159.         //基础设置下拉菜单
    160.         EditorGUILayout.BeginVertical(EditorStyles.helpBox);
    162.         _Base_Foldout = Foldout(_Base_Foldout, "基础设置(BasicSettings)");
    164.         if (_Base_Foldout)
    165.         {
    166.             EditorGUI.indentLevel++;
    167.             GUI_Base(material);
    168.             EditorGUI.indentLevel--;
    169.         }
    170.         EditorGUILayout.EndVertical();
    172.         //主帖图下拉菜单
    173.         if (mainTex.textureValue != null)
    174.         {
    175.             EditorGUILayout.BeginVertical(EditorStyles.helpBox);
    177.             _Maintextures_Foldout = Foldout(_Maintextures_Foldout, "主贴图(MainTexture)");
    179.             if (_Maintextures_Foldout)
    180.             {
    181.                 EditorGUI.indentLevel++;
    182.                 GUI_Maintextures(material);
    183.                 EditorGUI.indentLevel--;
    184.             }
    185.             EditorGUILayout.EndVertical();
    186.         }
    188.         //溶解下拉菜单
    189.         if (mainTex.textureValue != null)
    190.         {
    191.             EditorGUILayout.BeginVertical(EditorStyles.helpBox);
    192.             _Disslovetextures_Foldout = Foldout(_Disslovetextures_Foldout, "溶解(Dissolve)");
    194.             if (_Disslovetextures_Foldout)
    195.             {
    196.                 EditorGUI.indentLevel++;
    197.                 GUI_Dissolve(material);
    198.                 EditorGUI.indentLevel--;
    199.             }
    200.             EditorGUILayout.EndVertical();
    201.         }
    202.     }
    204.     //主帖图具体显示内容
    205.     void GUI_Maintextures(Material material)
    206.     {
    207.         EditorGUILayout.BeginVertical(EditorStyles.helpBox);
    209.         EditorGUILayout.BeginVertical(EditorStyles.helpBox);
    210.         m_MaterialEditor.TexturePropertySingleLine(new GUIContent("主贴图"), mainTex, TintColor);
    211.         m_MaterialEditor.TextureScaleOffsetProperty(mainTex);
    212.         EditorGUILayout.EndVertical();
    214.         EditorGUILayout.BeginVertical(EditorStyles.helpBox);
    215.         m_MaterialEditor.ShaderProperty(Intensity, "颜色强度");
    216.         GUILayout.Space(5);
    217.         m_MaterialEditor.ShaderProperty(MainFlowX, "X轴流动");
    218.         GUILayout.Space(5);
    219.         m_MaterialEditor.ShaderProperty(MainFlowY, "Y轴流动");
    220.         GUILayout.Space(5);
    221.         EditorGUILayout.EndVertical();
    223.         EditorGUILayout.EndVertical();
    225.     }
    227.     void GUI_Dissolve(Material material)
    228.     {
    229.         EditorGUILayout.BeginVertical(EditorStyles.helpBox);
    231.         //划分一个框包裹
    232.         EditorGUILayout.BeginVertical(EditorStyles.helpBox);
    233.         m_MaterialEditor.TexturePropertySingleLine(new GUIContent("溶解贴图"), NoiseTex);
    234.         GUILayout.Space(5);
    235.         m_MaterialEditor.TextureScaleOffsetProperty(NoiseTex);
    236.         EditorGUILayout.EndVertical();
    238.         EditorGUILayout.BeginVertical(EditorStyles.helpBox);
    239.         m_MaterialEditor.ShaderProperty(DissolveFade, "溶解消失");
    240.         GUILayout.Space(5);
    242.         m_MaterialEditor.ShaderProperty(DissolveColor1, "溶解颜色1");
    243.         GUILayout.Space(5);
    245.         m_MaterialEditor.ShaderProperty(DissolveColor2, "溶解颜色2");
    246.         GUILayout.Space(5);
    248.         m_MaterialEditor.ShaderProperty(NoiseScaleX, "X轴缩放");
    249.         GUILayout.Space(5);
    251.         m_MaterialEditor.ShaderProperty(NoiseScaleY, "Y轴缩放");
    252.         GUILayout.Space(5);
    254.         m_MaterialEditor.ShaderProperty(NoiseFlowX, "X轴流动");
    255.         GUILayout.Space(5);
    257.         m_MaterialEditor.ShaderProperty(NoiseFlowY, "Y轴流动");
    258.         GUILayout.Space(5);
    259.         EditorGUILayout.EndVertical();
    262.         //开关判断
    263.         EditorGUILayout.BeginVertical(EditorStyles.helpBox);
    264.         EditorGUILayout.BeginHorizontal();
    265.         EditorGUILayout.PrefixLabel("开启额外溶解图");
    266.         //_NoiseTexAdd = Foldout(_NoiseTexAdd, "额外溶解图");
    267.         if (material.GetFloat("_AddNoiseCtrl") == 0)
    268.         {
    269.             if (GUILayout.Button("已关闭", shortButtonStyle))
    270.             {
    271.                 material.SetFloat("_AddNoiseCtrl", 1);
    273.             }
    274.         }
    275.         else
    276.         {
    277.             if (GUILayout.Button("已开启", shortButtonStyle))
    278.             {
    279.                 material.SetFloat("_AddNoiseCtrl", 0);
    280.             }
    281.         }
    282.         EditorGUILayout.EndHorizontal();
    284.         if (material.GetFloat("_AddNoiseCtrl") == 1)
    285.         {
    286.             m_MaterialEditor.TexturePropertySingleLine(new GUIContent("溶解边缘贴图"), NoiseCtrl);
    287.             m_MaterialEditor.TextureScaleOffsetProperty(NoiseCtrl);
    289.             if (NoiseCtrl.textureValue )
    290.             {
    291.                 m_MaterialEditor.ShaderProperty(NoiseCtrlIntensity, "边缘强度");
    292.                 GUILayout.Space(5);
    294.                 m_MaterialEditor.ShaderProperty(LineWidth, "边缘宽度");
    295.                 GUILayout.Space(5);
    297.                 m_MaterialEditor.ShaderProperty(LineRange, "边缘范围");
    298.                 GUILayout.Space(5);
    300.                 m_MaterialEditor.ShaderProperty(LineChange, "边缘变化");
    301.                 GUILayout.Space(5);
    303.                 m_MaterialEditor.ShaderProperty(Amount, "边缘量");
    304.                 GUILayout.Space(5);
    305.             }
    306.         }
    307.         EditorGUILayout.EndVertical();
    312.         //if (_NoiseTexAdd)
    313.         //{
    314.         //    EditorGUI.indentLevel++;
    316.         //    EditorGUILayout.BeginVertical(EditorStyles.helpBox);
    317.         //    m_MaterialEditor.TexturePropertySingleLine(new GUIContent("溶解边缘贴图"), NoiseCtrl);
    318.         //    m_MaterialEditor.TextureScaleOffsetProperty(NoiseCtrl);
    319.         //    GUILayout.Space(5);
    321.         //    m_MaterialEditor.ShaderProperty(NoiseCtrlIntensity, "边缘强度");
    322.         //    GUILayout.Space(5);
    324.         //    m_MaterialEditor.ShaderProperty(LineWidth, "边缘宽度");
    325.         //    GUILayout.Space(5);
    327.         //    m_MaterialEditor.ShaderProperty(LineRange, "边缘范围");
    328.         //    GUILayout.Space(5);
    330.         //    EditorGUI.indentLevel--;
    331.         //    EditorGUILayout.EndVertical();
    332.         //}
    335.         EditorGUILayout.EndVertical();
    337.     }
    339.     //基础设置内容显示
    340.     void GUI_Base(Material material)
    341.     {
    342.         EditorGUILayout.BeginVertical(EditorStyles.helpBox);
    343.         EditorGUILayout.BeginHorizontal();
    344.         EditorGUILayout.PrefixLabel("混合模式");
    345.         //shader里面的一个控制开关
    346.         if (material.GetFloat("_Scr") == 1)
    347.         {
    348.             //Button一个按钮
    349.             //shortButtonStyle、GUI布局选项尺寸
    350.             if (GUILayout.Button("Add", shortButtonStyle))
    351.             {
    352.                 //如果按下这个按钮，shader里面的参数数值则会变成我们现在所设定的样子
    353.                 material.SetFloat("_Scr", 5);
    354.                 material.SetFloat("_Dst", 10);
    355.                 material.SetFloat("_AlphaAdd", 0);
    356.             }
    357.         }
    358.         else
    359.         {
    360.             if (GUILayout.Button("Alpha", shortButtonStyle))
    361.             {
    362.                 material.SetFloat("_Scr", 1);
    363.                 material.SetFloat("_Dst", 1);
    364.                 material.SetFloat("_AlphaAdd", 1);
    365.             }
    366.         }
    368.         EditorGUILayout.EndHorizontal();
    370.         //在当前布局组中插入一个空间。
    371.         GUILayout.Space(5);
    373.         //需要搭配EditorGUILayout.EndHorizontal();
    374.         //意思差不多就是在里面一段UI中加上边框背景
    375.         EditorGUILayout.BeginHorizontal();
    377.         EditorGUILayout.PrefixLabel("剔除模式");
    379.         if (material.GetFloat("_Cullmode") == 0)
    380.         {
    381.             if (GUILayout.Button("双面显示", shortButtonStyle))
    382.             {
    383.                 material.SetFloat("_Cullmode", 1);
    384.             }
    385.         }
    386.         else
    387.         {
    388.             if (material.GetFloat("_Cullmode") == 1)
    389.             {
    390.                 if (GUILayout.Button("显示背面", shortButtonStyle))
    391.                 {
    392.                     material.SetFloat("_Cullmode", 2);
    393.                 }
    394.             }
    396.             else
    397.             {
    398.                 if (GUILayout.Button("显示正面", shortButtonStyle))
    399.                 {
    400.                     material.SetFloat("_Cullmode", 0);
    401.                 }
    402.             }
    403.         }
    404.         EditorGUILayout.EndHorizontal();
    406.         //if (_tips == true)
    407.         //{
    409.         //    EditorGUILayout.BeginVertical(EditorStyles.helpBox);
    410.         //    style.fontSize = 10;
    411.         //    style.normal.textColor = new Color(0.5f, 0.5f, 0.5f);
    412.         //    GUILayout.Label("*包含显示正面，显示背面，双面显示三种模式", style);
    413.         //    EditorGUILayout.EndVertical();
    414.         //}
    416.         GUILayout.Space(5);
    417.         EditorGUILayout.BeginHorizontal();
    418.         EditorGUILayout.PrefixLabel("显示在最前层");
    420.         if (material.GetFloat("_Ztest") == 4)
    421.         {
    422.             if (GUILayout.Button("否", shortButtonStyle))
    423.             {
    424.                 material.SetFloat("_Ztest", 8);
    426.             }
    427.         }
    428.         else
    429.         {
    430.             if (GUILayout.Button("是", shortButtonStyle))
    431.             {
    432.                 material.SetFloat("_Ztest", 4);
    433.             }
    434.         }
    436.         EditorGUILayout.EndHorizontal();
    438.         //if (_tips == true)
    439.         //{
    440.         //    EditorGUILayout.BeginVertical(EditorStyles.helpBox);
    441.         //    style.fontSize = 10;
    442.         //    style.normal.textColor = new Color(0.5f, 0.5f, 0.5f);
    443.         //    GUILayout.Label("*开启后深度测试ZTest设置为always，可以让特效显示在角色之前，避免穿模", style);
    444.         //    EditorGUILayout.EndVertical();
    445.         //}
    447.         GUILayout.Space(5);
    449.         EditorGUILayout.BeginHorizontal();
    451.         EditorGUILayout.PrefixLabel("写入深度");
    454.         if (material.GetFloat("_Zwrite") == 0)
    455.         {
    456.             if (GUILayout.Button("否", shortButtonStyle))
    457.             {
    458.                 material.SetFloat("_Zwrite", 1);
    460.             }
    461.         }
    462.         else
    463.         {
    464.             if (GUILayout.Button("是", shortButtonStyle))
    465.             {
    466.                 material.SetFloat("_Zwrite", 0);
    467.             }
    468.         }
    470.         EditorGUILayout.EndHorizontal();
    472.         EditorGUILayout.EndVertical();
    473.         GUILayout.Space(5);
    474.     }
    476. }