using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEditor;
 
public class Mybianyi : EditorWindow
{
    string PasswordField = "";
    string m_textArea = "";
    float sliders = 0;
    int slidera = 0;
    string BeginToggleGroup = "BeginToggleGroup";
    bool ToggleGroup = false;
    string Textfield = "";
    bool fg = false;
    float sum = 0;
    int count = 0;
    string tag = "aaa";
    int Layerfield=0;
    string[] pathname = new string[] { "All", "Asset", "..." }; 
    float minVal = 1;
    float maxVal = 2;
    float minLimit = -5;
    float maxLimit = 5;
    static Vector3 center = new Vector3(1, 2, 3);
    static Vector3 size1 = new Vector3(1, 2, 3);
    Bounds _bounds = new Bounds(center, size1);
    Color m_color = Color.white;
    AnimationCurve m_curve = AnimationCurve.Linear(0, 0, 10, 10);
    Vector2 size = new Vector2(100,100);
    int flags = 0;
    string[] options = new string[] { "CanJump", "CanShoot", "CanSwim" ,"Canabc","Canacc"};
    GameObject game ;
    bool showFoldout;
    Vector2 m_vector2 = new Vector2();
    Vector3 m_vector3 = new Vector3();
    Vector4 m_vector4 = new Vector4();
    Transform selectedTransform;
    GameObject selectedGameObject;
    bool fold;
    bool fold2;
    [MenuItem("MyWindow/Window")]
    static void window()
    {
        Mybianyi mybianyi = GetWindow<Mybianyi>();
        mybianyi.Show();
    }
    private void OnGUI()
    {
     
        // GUILayout.Width  控制在窗口中物体所在的宽
        // GUILayout.Height  控制在窗口中物体所在的高
        //它们的返回的类型为GUILayoutOption
        #region GUILayout.Label 提示语句
 
        GUILayout.Label("我的编译器（My compiler）", GUILayout.Width(50), GUILayout.Height(10)); //提示语句
        #endregion
        #region GUILayout.Button( 按钮
        GUILayout.Label("按钮");
        if( GUILayout.Button("按钮", GUILayout.Width(40), GUILayout.Height(40)))
        {
 
        }
        #endregion
        #region GUILayout.TextField 文本
        GUILayout.Label("文本（可以输入）");
        Textfield = GUILayout.TextField(Textfield);//单行
        //参数2 maxLength 最大有效长度
        // Textfield = GUILayout.TextField(Textfield,5);
        #endregion
        #region GUILayout.Space 空行
        //参数为float类型代表空行的距离
        GUILayout.Space(10);
        #endregion
        #region EditorGUILayout.Toggle 开关（跟Toggle一样）
        fg = EditorGUILayout.Toggle("Toggle", fg);//开关
        #endregion
        #region GUILayout.BeginHorizontal 横向
        GUILayout.BeginHorizontal();//可以在里面存放多个如果不规定大小系统会平均分配大小
        GUILayout.Button("按钮");
        Textfield = GUILayout.TextField(Textfield);
        GUILayout.EndHorizontal();//结束语一定要有
        #endregion
        #region GUILayout.BeginVertical 纵向
        GUILayout.BeginVertical();//可以在里面存放多个如果不规定大小系统会平均分配大小
        GUILayout.Button("按钮");
        Textfield = GUILayout.TextField(Textfield);
        GUILayout.EndVertical();//结束语一定要有
        #endregion
        #region  GUILayout.HorizontalSlider（横） GUILayout.VerticalSlider（纵）  Slider(分横纵 上横下纵)
        sum = GUILayout.HorizontalSlider(sum, 0, 10);
        // sum = GUILayout.VerticalSlider(sum, 0, 10);
        GUILayout.Space(20);
        #endregion
        #region EditorGUILayout.Popup  下拉
        count = EditorGUILayout.Popup("下拉：",count,pathname);
        #endregion
        #region GUILayout.BeginScrollView  滑动列表 
        //两个true可以让横纵两条线显示出了
        //两个false可以让横纵两条线不显示出来
        size = GUILayout.BeginScrollView(size,true,true);
        
        GUILayout.EndScrollView();
        #endregion
        #region EditorGUILayout.BoundsField （边界输入）   EditorGUILayout.ColorField（颜色输入）  EditorGUILayout.CurveField（曲线输入）   输入框
        //BoundsField 边界输入框
        _bounds = EditorGUILayout.BoundsField("BoundsField:", _bounds);
        //ColorField 颜色输入框
        m_color = EditorGUILayout.ColorField("ColorField:", m_color);
        //CurveField 曲线输入框
        m_curve = EditorGUILayout.CurveField("CurveField:", m_curve);
        #endregion
        #region EditorGUILayout.TagField    tag(标签)
        tag = EditorGUILayout.TagField("TagField:", tag);
 
        #endregion
        #region   EditorGUILayout.LayerField(可以获取所有的Layer)
        //Layerfield 可以获取所有的Layer
        Layerfield = EditorGUILayout.LayerField("LayerField:", Layerfield);
 
        #endregion
        #region   EditorGUILayout.MaskField (下拉可以多选)
        flags = EditorGUILayout.MaskField("MaskField:", flags, options);
        //Debug.Log(flags);// 除了数组的第一个是1 后面全是2的幂（幂为对应的下标）   如果多选它们会相加   系统默认会添加Nothing （对应的值0） 和Everything（-1）
        #endregion
        #region EditorGUILayout.ObjectField(选择物体)
        game = (GameObject) EditorGUILayout.ObjectField(game,typeof(GameObject),true);//typeof(类型) 确定好类型系统会自动帮我找到所有的关于这个类型的物体
        #endregion
        #region  EditorGUILayout.Foldout 折叠
        showFoldout = EditorGUILayout.Foldout(showFoldout, "折叠子物体：");
        if (showFoldout)
        {
            EditorGUI.indentLevel++;//缩进级别
            EditorGUILayout.LabelField("折叠块内容1");
            EditorGUI.indentLevel++;
            EditorGUILayout.LabelField("折叠块内容2");
            EditorGUI.indentLevel--;
            EditorGUI.indentLevel--;
            EditorGUILayout.LabelField("折叠块内容3");
        }
        #endregion
        #region EditorGUILayout.BeginToggleGroup(开关)
        ToggleGroup = EditorGUILayout.BeginToggleGroup(BeginToggleGroup, ToggleGroup);
            Textfield = GUILayout.TextField(Textfield);
        EditorGUILayout.EndToggleGroup();
        #endregion
        #region  GUILayout.FlexibleSpace（布局之间左右对齐）
        EditorGUILayout.BeginHorizontal();//开始最外层横向布局
        GUILayout.FlexibleSpace();//布局之间左右对齐
        GUILayout.Label("-----------------分割线-----------------");
        GUILayout.FlexibleSpace();//布局之间左右对齐
        EditorGUILayout.EndHorizontal();
        #endregion
        #region  EditorGUILayout.HelpBox（提示语句）
        EditorGUILayout.HelpBox("HelpBox Error:", MessageType.Error);//红色错误号
        EditorGUILayout.HelpBox("HelpBox Info:", MessageType.Info);//白色提示号
        EditorGUILayout.HelpBox("HelpBox None:", MessageType.None);//解释号
        EditorGUILayout.HelpBox("HelpBox Warning:", MessageType.Warning);//黄色警告号
        #endregion
        #region EditorGUILayout.Slider(Slider)
        sliders = EditorGUILayout.Slider("Slider:",sliders,0,10);
        #endregion
        #region  EditorGUILayout.TextArea（text 自适应高）
        m_textArea = EditorGUILayout.TextArea(m_textArea);//可以多行
        #endregion
        #region GUILayout.PasswordField(可以改变成对应的符号)
        EditorGUILayout.BeginHorizontal();
        GUILayout.Label("密码text", GUILayout.Width(60));
        PasswordField = GUILayout.PasswordField(PasswordField, '*');//可以改变成对应的符号
        EditorGUILayout.EndHorizontal();
        #endregion
        #region  EditorGUILayout.Vector2Field  EditorGUILayout.Vector3Field  EditorGUILayout.Vector4Field 
        m_vector2 = EditorGUILayout.Vector2Field("Vector2:", m_vector2);
        m_vector3 = EditorGUILayout.Vector3Field("Vector3:", m_vector3);
        m_vector4 = EditorGUILayout.Vector4Field("Vector4:", m_vector4);
        #endregion
        #region EditorGUILayout.SelectableLabel （可以复制粘贴）
        EditorGUILayout.SelectableLabel("SelectableLabel");
        #endregion
        #region  EditorGUILayout.MinMaxSlider （取值范围）
        EditorGUILayout.LabelField("Min Val:", minVal.ToString());
        EditorGUILayout.LabelField("Max Val:", maxVal.ToString());
        EditorGUILayout.MinMaxSlider("MinMaxSlider", ref minVal, ref maxVal, minLimit, maxLimit);
                                                     //现在最小  现在最大 最小长度 最大长度 
        #endregion
        #region   EditorGUILayout.IntSlider（只能是整数）
        slidera = EditorGUILayout.IntSlider("IntSlider:", slidera, 1, 10);
        #endregion
        #region  EditorGUILayout.InspectorTitlebar（将物体返回回来）
        //Transform selectedTransform = Selection.activeGameObject.transform;
        //GameObject selectedGameObject = Selection.activeGameObject;//选择物体（GameObject）
        //fold = EditorGUILayout.InspectorTitlebar(fold, selectedTransform);
        //fold2 = EditorGUILayout.InspectorTitlebar(fold2, selectedGameObject);
        #endregion
    }
}

using UnityEditor;

public class TutorialWindow : EditorWindow
{
    private static TutorialWindow window; //窗口实例对象，必须是一个static

    [MenuItem("MyWindows/TutorialWindow")] //定义菜单栏位置
    public static void OpenWindow() //打开窗口函数，必须是static
    {
        window = GetWindow<TutorialWindow>(false, "TutorialWindow", true); //实例化窗口
        window.Show(); //显示窗口
    }
    /// <summary>
    /// 窗口内显示的GUI面板
    /// </summary>
    private void OnGUI()
    {

    }
}

public class TutorialMono : MonoBehaviour //基本就是个空的Mono
{
}

using UnityEditor;
using UnityEngine;

[CustomEditor(typeof(TutorialMono))] //指定自定义Editor所要绑定的Mono类型，这里就是typeof(TutorialMono)
public class TutorialMonoInspector : Editor //继承Editor
{
    private TutorialMono m_target; //在Inspector上显示的实例目标
    /// <summary>
    /// 当对象活跃时（在Inspector中显示时），unity自动调用此函数
    /// </summary>
    private void OnEnable()
    {
        m_target = target as TutorialMono; //绑定target，target官方解释： The object being inspected
    }
    /// <summary>
    /// 重写OnInspectorGUI，之后所有的GUI绘制都在此方法中。
    /// </summary>
    public override void OnInspectorGUI()
    {
        base.OnInspectorGUI(); //调用父类方法绘制一次GUI，TutorialMono中原本的可序列化数据等会在这里绘制一次。
        //如果不调用父类方法，则这个Mono的Inspector全权由下面代码绘制。

        if (GUILayout.Button("这是一个按钮"))   //自定义按钮
        {
            Debug.Log("Hello world");
        }
    }
}

private GUIContent content = new GUIContent("DropdownButton"); //定义一下显示内容
...
if (EditorGUILayout.DropdownButton(content, FocusType.Passive))
{
    Debug.Log("按下就触发，而不是抬起");
}

private GameObject m_objectValue; //定义Object
...
//第一个参数： 目标Object
//第二个参数： Object的类型
//第三个参数： 是否允许赋值场景对象（一般是赋值Project中的Asset资源对象）
//最后需要一个【as】进行类型转换
m_objectValue = EditorGUILayout.ObjectField(m_objectValue, typeof(GameObject), true) as GameObject;

private int m_singleInt;
private int m_multiInt;
private string[] intSelections = new string[] { "整数10", "整数20", "整数30" };
private string[] intMultiSelections = new string[] { "1号", "2号", "3号" };
private int[] intValues = new int[] { 10, 20, 30 };
...
m_singleInt = EditorGUILayout.IntPopup("整数单选框", m_singleInt, intSelections, intValues);
EditorGUILayout.LabelField($"m_singleInt is {m_singleInt}");
m_multiInt = EditorGUILayout.MaskField("整数多选框", m_multiInt, intMultiSelections);
EditorGUILayout.LabelField($"m_multiInt is {m_multiInt}");

private bool foldOut;
...
foldOut = EditorGUILayout.Foldout(foldOut, "一般路过折叠栏");
if (foldOut) //只有foldout为true时，才会显示下方内容，相当于“折叠”了。
{
        EditorGUILayout.LabelField("这是折叠标签内容");
}

private bool foldOut;
...
foldOut = EditorGUILayout.BeginFoldoutHeaderGroup(foldOut, "折叠栏组");
if (foldOut) //只有foldout为true时，才会显示下方内容，相当于“折叠”了。
{
        EditorGUILayout.LabelField("这是折叠标签内容");
}
EditorGUILayout.EndFoldoutHeaderGroup(); //只不过这种折叠需要成对使用，不然会有BUG

private bool toggle;
...
toggle = EditorGUILayout.Toggle("Normal Toggle", toggle);
toggle = EditorGUILayout.ToggleLeft("Left Toggle", toggle);

private bool toggle;
private string m_inputText;
...
toggle = EditorGUILayout.BeginToggleGroup("开关组", toggle);
EditorGUILayout.LabelField("------Input Field------");
m_inputText = EditorGUILayout.TextField("输入内容：", m_inputText);
EditorGUILayout.EndToggleGroup();

private float m_sliderValue;
private int m_sliderIntValue;
...        
//参数详解：
//第一个参数： string label 控件名称标签 
//第二个参数： float value 滑动当前值 
//第三个参数： float leftValue 滑动最小值 
//第四个参数： float rightValue 滑动最大值
m_sliderValue = EditorGUILayout.Slider("滑动条Sample：", m_sliderValue, 0.123f, 7.77f);
//参数同上
m_sliderIntValue = EditorGUILayout.IntSlider("整数值滑动条", m_sliderIntValue, 2, 16);

private float m_leftValue;
private float m_rightValue;
...
EditorGUILayout.MinMaxSlider("双块滑动条", ref m_leftValue, ref m_rightValue, 0.25f, 10.25f);
EditorGUILayout.FloatField("滑动左值：", m_leftValue);
EditorGUILayout.FloatField("滑动右值：", m_rightValue);

EditorGUILayout.HelpBox("一般提示，你应该这样做...", MessageType.Info);
EditorGUILayout.HelpBox("警告提示，你可能需要这样做...", MessageType.Warning);
EditorGUILayout.HelpBox("错误提示，你不能这样做...", MessageType.Error);

EditorGUILayout.LabelField("----上面的Label----");
EditorGUILayout.Space(10); //进行10个单位的间隔
EditorGUILayout.LabelField("----下面的Label----");

EditorGUILayout.BeginHorizontal(); //开始水平布局
GUILayout.Button("1号button", GUILayout.Width(200)); //固定button长度： 200
GUILayout.FlexibleSpace(); // 自动填充间隔，如果窗口宽600px，那这种写法就是：【左button：200px】【自动间隔：200px】【右button ：200px】
GUILayout.Button("2号button", GUILayout.Width(200));//固定button长度： 200
EditorGUILayout.EndHorizontal(); //结束水平布局

private Vector2 scrollRoot;
...
EditorGUILayout.BeginHorizontal(); //开始水平布局
//一大堆控件...
EditorGUILayout.EndHorizontal();//结束水平布局

EditorGUILayout.BeginVertical();//开始垂直布局
//一大堆控件...
EditorGUILayout.EndVertical();//结束垂直布局

scrollRoot = EditorGUILayout.BeginScrollView(scrollRoot); //开启滚动视图
//一大堆控件...
EditorGUILayout.EndScrollView(); //结束滚动视图

public class GizmosTutotial : MonoBehaviour //新建脚本，继承自Mono
{
    private Vector3 size = new Vector3(10, 10, 10); //定义Cube大小
    private void OnDrawGizmos() //定义OnDrawGizmos方法，类似于Start，Update的定义方式 {
        Gizmos.DrawCube(Vector3.zero, size); //使用Gizmos绘制一个Cube
    } 
}

public class GizmosTutotial : MonoBehaviour
{
    private void OnDrawGizmos() {
        Gizmos.DrawCube(Vector3.zero, Vector3.one); 
        //参数释义： 1.Cube中心点 2.Cube大小
    }
}

Gizmos.DrawFrustum(Vector3.zero, 60, 300, 0.3f, 1.7f); 
//参数释义：1. 绘制中心 2. FOV角度 3. 远裁切平面 4. 近裁切平面 5. aspect 屏幕长宽比

public Texture texture;
...
if (texture != null)
{
    Gizmos.DrawGUITexture(new Rect(0, 0, 10, 10), texture); //1.指定Rect 2.指定贴图
}

Gizmos.DrawIcon(Vector3.up, "MyIcon"); //1.绘制中心 2.图标名

Gizmos.DrawLine(Vector3.zero, Vector3.one);  //1.from（线段起点） 2.to（线段终点）

public Mesh mesh;
...
if (mesh != null)
{
    Gizmos.DrawMesh(mesh, 0); //1. mesh 2.submeshIndex
}

Gizmos.DrawRay(Vector3.zero, Vector3.one); //1.from 2.direction

Gizmos.DrawSphere(Vector3.up, 1); //1.center 2.radius

public Mesh mesh;
...
Gizmos.DrawWireCube(Vector3.left, Vector3.one);
Gizmos.DrawWireSphere(Vector3.right, 1);
if (mesh != null)
{
    Gizmos.DrawWireMesh(mesh, 0, Vector3.forward);
}

Gizmos.color = Color.red;
Gizmos.DrawSphere(Vector3.left, 0.5f);
Gizmos.color = Color.green;
Gizmos.DrawCube(Vector3.zero, Vector3.one);
Gizmos.color = Color.blue;
Gizmos.DrawLine(Vector3.right, Vector3.right * 2);

Gizmos.matrix = this.transform.localToWorldMatrix; //这里使用挂载transform进行举例
Gizmos.DrawWireSphere(Vector3.zero, 1);

public Transform player; //绑定player
public Transform enemy; //绑定enemy
...
if (player != null && enemy != null)
{
    Gizmos.color = Color.green; //设置绿色
    Gizmos.DrawSphere(player.position, 0.5f); //在player处绘制球体
    Gizmos.color = Color.red; //设置红色
    Gizmos.DrawSphere(enemy.position, 0.5f); //在enemy处绘制球体
    Gizmos.color = Color.yellow; //设置黄色
    Gizmos.DrawLine(player.position, enemy.position); //绘制线段连接player enemy
    DrawCircle(enemy, 3, 0.1f, Color.red); //绘制半径3的红色圆环
    DrawCircle(enemy, 5, 0.1f, Color.green); //绘制半径5的绿色圆环
}
// theta越小，线段绘制数越多，圆环越平滑。
private void DrawCircle(Transform transform, float radius, float theta, Color color)
{
    var matrix = Gizmos.matrix; //保存原本的矩阵信息
    Gizmos.matrix = transform.localToWorldMatrix; //应用目标trans矩阵信息
    Gizmos.color = color; //设置颜色
    Vector3 beginPoint = new Vector3(radius, 0, 0); //定义起始点
    Vector3 firstPoint = new Vector3(radius, 0, 0); //定义起始点
    for (float t = 0; t < 2 * Mathf.PI; t += theta) //循环线段绘制
    {
        float x = radius * Mathf.Cos(t); //计算cos
        float z = radius * Mathf.Sin(t); //计算sin
        Vector3 endPoint = new Vector3(x, 0, z); //确定圆环采样点
        Gizmos.DrawLine(beginPoint, endPoint); //绘制线段
        beginPoint = endPoint; //迭代赋值
    }
    Gizmos.DrawLine(firstPoint, beginPoint); //绘制最后一段
    Gizmos.matrix = matrix; //还原Gizmos矩阵信息
}

public Transform enemy;
...
Gizmos.color = Color.red;
Gizmos.DrawSphere(enemy.position, 0.5f);
DrawArc(enemy, 1, 90, 0.1f, Color.green);
...
private void DrawArc(Transform transform, float radius, float angle, float theta, Color color)
{
    var matrix = Gizmos.matrix;
    Gizmos.matrix = transform.localToWorldMatrix;
    Gizmos.color = color;
    Vector3 beginPoint = Vector3.zero;
    Vector3 firstPoint = Vector3.zero;
    var rad = Mathf.Deg2Rad * angle;
    for (float t = 0; t < rad; t += theta)
    {
        float x = radius * Mathf.Cos(t);
        float z = radius * Mathf.Sin(t);
        Vector3 endPoint = new Vector3(x, 0, z);
        Gizmos.DrawLine(beginPoint, endPoint);
        beginPoint = endPoint;
    }
    Gizmos.DrawLine(firstPoint, beginPoint);
    Gizmos.matrix = matrix;
}

------HandlesMono .cs------
using UnityEngine;
public class HandlesMono : MonoBehaviour
{

}

------HandlesMonoEditor.cs------
using UnityEngine;
using UnityEditor;
[CustomEditor(typeof(HandlesMono))]
public class HandlesMonoEditor : Editor
{
    private void OnSceneGUI()
    {
        Debug.Log("在Editor OnSceneGUI中 调用....");
    }
}

EditorUtility.SetDirty(Object obj); //标记目标资源为“脏”
AssetDatabase.SaveAssets(); //保存项目内的“脏数据”

public static T LoadAssetAtPath<T>(string assetPath)whereT:UnityEngine.Object;//读取路径下的资源文件
public static string GetAssetPath(UnityEngine.Object assetObject);//获取目标资源文件的在项目中的路径

Selection.activeObject = obj; //obj就是目标资源文件

//定义创建资产菜单，menuName : 路径名称， fileName：资产文件名
[CreateAssetMenu(menuName = "MyConfig/SimpleObj", fileName = "SimpleScriptableObejct")]
public class SimpleScriptableObject : ScriptableObject //继承自【ScriptableObject】
{
    [SerializeField] //定义序列化
    public List<InfoPair> pairs; //具体的数据字段
}

[System.Serializable] //定义序列化
public class InfoPair //一种数据类定义
{
    public int someID;
    public string someName;
    public Texture someTex;
}

public SimpleScriptableObject scriptableObject; //定义字段

private void Start() //测试用，在Start时写逻辑
{
    if (scriptableObject != null) //非空（比如提前在Inspector中赋值）
    {
        if (scriptableObject.pairs != null && scriptableObject.pairs.Count > 0) //list非空且有数据
        {
            var name = scriptableObject.pairs[0].someName; //获取下标0的数据
            Debug.Log($"SO element name : {name}"); //打印信息
        }
    }
}

//一般这段代码写在EditorWindow的OnGUI()的某个button下，实现“点击保存”功能
EditorUtility.SetDirty(simpleScriptableObject); //标记脏数据
AssetDatabase.SaveAssets(); //对所有未写入硬盘保存的脏数据信息保存

var simpleScriptableObject = ScriptableObject.CreateInstance<SimpleScriptableObject>();
//值得注意的是，这种创建方式没有创建资产实例，仅仅是在内存中创建，不会保存在硬盘上。

//如果想保存在硬盘上，需要使用如下方式
AssetDatabase.CreateAsset(simpleScriptableObject, "Assets/SomePath/simpleSO.asset");
//记得路径必须合法，也要加上文件后缀

EditorUtility.SetDirty(someObject); //使用例见上文

var flag = EditorUtility.DisplayDialog("标题", "显示消息", "确认键");
//当然，这方法有许多重载，请自行查看

private float value; //定义进度条填充值
private void OnGUI() //EditorWindow.OnGUI
{
    if (GUILayout.Button("增加进度")) //手动增加进度
    {
        value += 0.1f;
        value = Mathf.Clamp01(value); //约束value值到0~1
    }
    EditorUtility.DisplayProgressBar("进度条", "显示信息", value); //显示进度条
    if (value == 1)
    {
        EditorUtility.ClearProgressBar(); //关闭进度条
    }
}

private Texture tex;
...
if (GUILayout.Button("查找法线贴图"))
{
    //参数释义
    //1. 查找对象的引用
    //2. 是否允许查找场景对象
    //3. 查找对象名称过滤（比如这里的normal是指文件名称中有normal的会被搜索到）
    //4. controlID, 默认写0
    EditorGUIUtility.ShowObjectPicker<Texture>(tex, false, "normal", 0);
}

EditorGUIUtility.PingObject(someObj);

private Texture tex;
private string path;
...
tex = EditorGUILayout.ObjectField(tex, typeof(Texture), false) as Texture;
if (GUILayout.Button("获取文件路径"))
{
    path = AssetDatabase.GetAssetPath(tex);
}
EditorGUILayout.LabelField("资产路径是", path);

private string texPath = "Assets/MyShaders/Brick_Normal.JPG"; //定义好路径
private Texture myTex; //定义好对象
...
EditorGUILayout.LabelField("自定义文件路径", texPath);
if (GUILayout.Button("加载资产"))
{
    myTex = AssetDatabase.LoadAssetAtPath<Texture>(texPath); //加载文件
}
EditorGUILayout.ObjectField(myTex, typeof(Texture), false);

Selection.activeGameObejct //返回当前点击的场景游戏物体或Project Prefab;选择多个则返回第一个选择；未选择则返回null
Selection.activeTransform //返回当前点击的场景游戏物体transform。
Selection.activeObject // 返回当前点击的场景游戏物体或Project资产文件。

Selection.gameObjects //返回一个数组，内容为当前点击场景物体或Project Prefab，非GameObject的选择不会加入数组。未选择返回长度为0的数组
Selection.objects //返回一个数组，内容为当前点击的场景物体或Project资源。
Selection.transforms //返回一个数组，内容为当前点击的场景物体。

Selection.selectionChanged //委托，选择变化时调用。

// Contains 选择项中是否包含物体
public static bool Selection.Contains(int instanceID) 
public static bool Selection.Contains(Object obj)

// GetFiltered :返回按类型与模式过滤当前选择
// T : 过滤的泛型，只有某一种类型的对象才会被选择
// SelectionMode ： 选择的模式，下文细讲
public static T[] GetFiltered<T>(SelectionMode mode);

// GetTransforms : 允许使用SelectionMode对选择类型进行颗粒度控制
public static Transform[] GetTransforms(SelectionMode mode);

Unfiltered 返回整个选择（无模式过滤）
TopLevel 只返回最上层transform， 子物体的transform将被过滤掉
Deep 返回选择对象与他所有的子对象
ExcludePrefab 排除选择中的prefab对象
Editable 排除任何无法被修改的对象（只选择可以编辑的对象）
Assets 返回Asset资源
DeepAssets 返回整个文件夹内容（根目录与子文件夹）

private void OnGUI() //EditorWindow的OnGUI方法
{
    if (GUILayout.Button("选择一个文件夹，获取下面所有的Texture资源文件"))
    {
        var texs = Selection.GetFiltered<Texture>(SelectionMode.DeepAssets); //进行深度遍历所有文件夹
        Debug.Log($"Tex总计数：{texs.Length}");
        foreach (var tex in texs)
        {
            //使用AssetDatabase获取一次资产路径
            Debug.Log($"Tex 文件名：{tex.name}，文件路径 ：{AssetDatabase.GetAssetPath(tex)}"); 
        }
    }
}

if (GUILayout.Button("创建一个 Cube，同时选中"))
{
    var obj = GameObject.CreatePrimitive(PrimitiveType.Cube); //创建Cube
    obj.name = "新建的Cube";
    Selection.activeGameObject = obj; //选中Cube
}

public class EventTutorialWindow : EditorWindow
{
    public static EventTutorialWindow m_mainWindow;

    [MenuItem ("MyWindows/EventWindow")]
    public static void OpenWindow()
    {
        m_mainWindow = EditorWindow.GetWindow<EventTutorialWindow>();
        m_mainWindow.Show();
    }
    /// <summary>
    /// 窗口激活时调用
    /// </summary>
    private void OnEnable()
    {
        SceneView.duringSceneGui += OnSceneView; //注册场景视图刷新回调
    }
    /// <summary>
    /// 窗口关闭时调用
    /// </summary>
    private void OnDisable()
    {
        SceneView.duringSceneGui -= OnSceneView; //移除场景视图刷新回调
    }
    /// <summary>
    /// SceneView刷新回调
    /// </summary>
    /// <param name="sceneView"></param>
    private void OnSceneView(SceneView sceneView)
    {
        if (Event.current.type == EventType.MouseDown && Event.current.button == 0)
        {
            Debug.Log("鼠标左键在场景中Clicked....");
        }
    }
    /// <summary>
    /// 面板绘制
    /// </summary>
    private void OnGUI()
    {
        if (Event.current.type == EventType.KeyDown && Event.current.keyCode == KeyCode.A)
        {
            Debug.Log("键盘A键在Window面板中按下....");
        }
    }
}

...//在上文OnSceneView（）中加入以下代码即可
if (Event.current.type == EventType.MouseDown && Event.current.button == 0)
{
    if (Event.current.alt) //检测alt键是否被按下
    {
        Debug.Log("在场景视图中按下了Alt + 鼠标左键");
    }
    else if (Event.current.shift) //检测shift键是否被按下
    {
        Debug.Log("在场景视图中按下了Shift + 鼠标左键");
    }
}

private LayerMask layerMask = -1; //设置为-1，包含所有Layer
...
private void OnSceneView(SceneView sceneView)
{
    if (Event.current.type == EventType.MouseDown && Event.current.button == 0) //检测鼠标点击
    {
        var mousePos = Event.current.mousePosition; //获取鼠标在SceneView中的屏幕位置
        var ray = HandleUtility.GUIPointToWorldRay(mousePos); //生成屏幕坐标-->世界坐标的射线
        RaycastHit hit; //定义射线检测结果结构体
        if (Physics.Raycast(ray, out hit, float.MaxValue, layerMask)) //进行射线检测，layerMask是检测层级
        {
            var obj = GameObject.CreatePrimitive (PrimitiveType. Sphere); //如果检测成功，创建一个球体。
            obj.transform.position = hit.point; //把球体坐标设置为hit交点处。
        }
    }
}

Event.current.Use();

using UnityEditor;
using UnityEngine;

public class PolishWindow : EditorWindow
{
    public static PolishWindow m_mainWindow; //主要窗口对象

    private GUIStyle defaultStyle = new GUIStyle(); //定义 GUIStyle

    [MenuItem("MyWindows/PolishWindow")] //定义窗口菜单栏
    public static void OpenWindow()
    {
        m_mainWindow = EditorWindow.GetWindow<PolishWindow>(); //创建窗口
        m_mainWindow.Show(); //打开窗口
    }
    private void OnGUI()
    {
        defaultStyle.fontSize = 10; //字体大小： 10
        defaultStyle.fontStyle = FontStyle.Normal; //字体样式：normal

        defaultStyle.alignment = TextAnchor.MiddleCenter; //字体对齐方式： 居中对齐
        defaultStyle.normal.textColor = Color.red; //字体颜色： 红色
        EditorGUILayout.LabelField("这是红色字体", defaultStyle); //绘制GUI组件，使用 defaultStyle

        defaultStyle.alignment = TextAnchor.MiddleLeft; //字体对齐方式： 水平靠左，垂直居中
        defaultStyle.normal.textColor = Color.yellow; //字体颜色：黄色
        defaultStyle.fontSize = 20; //字体大小： 20
        EditorGUILayout.LabelField("这是黄色字体", defaultStyle); //绘制GUI组件

        defaultStyle.normal.textColor = Color.green; //字体颜色： 绿色
        defaultStyle.fontSize = 12; //字体大小 ： 12
        defaultStyle.fontStyle = FontStyle.Bold;  //字体样式： Bold（加粗）
        EditorGUILayout.SelectableLabel("这是绿色字体", defaultStyle); //绘制GUI
    }
}

GUI.color = Color.red;
GUILayout.Button("红色Button");
GUI.color = Color.green;
EditorGUILayout.LabelField("绿色Label");
GUI.color = Color.yellow;
EditorGUILayout.IntField("黄色Int Field", 20);

EditorGUILayout.BeginVertical("box");
EditorGUILayout.LabelField("这是【box】样式，用于显示面板的分区");
EditorGUILayout.Vector3Field("比如这是一个Vec3 Field", Vector3.one);
EditorGUILayout.BeginToggleGroup("比如这是一个Toggle Group", false);
EditorGUILayout.HelpBox("比如这是一个HelpBox", MessageType.Warning);
EditorGUILayout.TextArea("比如这是一个TextArea");
EditorGUILayout.EndToggleGroup();
EditorGUILayout.EndVertical();

EditorGUILayout.Space(10);

EditorGUILayout.BeginVertical("frameBox");
EditorGUILayout.LabelField("这是【frameBox】样式，用于显示面板的分区");
EditorGUILayout.BoundsField("比如这是一个BoundField", new Bounds());
EditorGUILayout.Slider("比如这是一个Slider", 5, 0, 10);
EditorGUILayout.TextArea("这是一个【SearchTextField】样式的文本框", "SearchTextField");
EditorGUILayout.EndVertical();

using UnityEditor;
using UnityEngine;

public class PolishWindow : EditorWindow
{
    public static PolishWindow m_mainWindow; //主要窗口对象

    private const int arrayLength = 35; //定义元素数组长度
    private const int countPerPage = 10; //定义每一页的数量

    private GUILayoutOption maxWidth = GUILayout.MaxWidth(120); //定义一个GUI组件的最大宽度
    private Vector2 scrollRoot; //定义组件ScrollView的滚动Root
    private int page = 1; //当前page
    private int currentSelectionIndex = -1; //当前选择index
    private int totalPage; //页面总数
    private int[] someValues; //显示的元素
    private bool foldOut; //折叠flag

    [MenuItem("MyWindows/PolishWindow")] //定义窗口菜单栏
    public static void OpenWindow()
    {
        m_mainWindow = EditorWindow.GetWindow<PolishWindow>(); //创建窗口
        m_mainWindow.Show(); //打开窗口
    }
    /// <summary>
    /// 当窗口打开时调用
    /// </summary>
    private void OnEnable()
    {
        someValues = new int[arrayLength]; //实例化数组
        totalPage = (int)Mathf.Ceil((float)arrayLength / (float)countPerPage); //计算总页数
        for (int i = 0; i < someValues.Length; i++)
        {
            someValues[i] = Random.Range(0, 100); //进行随机数据填充
        }
    }
    /// <summary>
    /// Editor面板绘制方法
    /// </summary>
    private void OnGUI()
    {
        scrollRoot = EditorGUILayout.BeginScrollView(scrollRoot); //开启 滚动视图 
        foldOut = EditorGUILayout.BeginFoldoutHeaderGroup(foldOut, "假装这是一个检索页面"); //开启 折叠组

        if (foldOut) //如果折叠打开，则进行绘制
        {
            EditorGUILayout.BeginVertical("frameBox"); //开始垂直布局，使用GUIStyle ： frameBox
            for (int i = (page - 1) * countPerPage; i < someValues.Length; i++) //循环绘制，page 默认是1开始，这里【page-1】对齐数组下标。
            {
                if (i >= page * countPerPage) //一页只能绘制【countPerPage】个元素，但是arrayLength可能不止，在这里截断。
                    break;

                if (currentSelectionIndex == i) //判断当前index与选择index
                    GUI.color = Color.green; //为真，突出显示选择项
                else
                    GUI.color = Color.white; //为假，还原默认颜色

                EditorGUILayout.BeginHorizontal("box"); //开始水平布局
                if (GUILayout.Button("Select This One", maxWidth)) //绘制选择按钮，使用maxWidth限制组件宽度
                {
                    currentSelectionIndex = i; //记录选择Index
                }
                EditorGUILayout.LabelField($"这是【{i}】号，他的随机值是：{someValues[i]}"); //显示数据信息
                EditorGUILayout.EndHorizontal(); //结束水平布局
            }

            EditorGUILayout.BeginHorizontal(); //开始水平布局
            EditorGUILayout.LabelField($"当前页数：{page.ToString()} / 总页数：{totalPage}"); //绘制页数信息
            if (GUILayout.Button("上一页")) //绘制上一页Button
            {
                page -= 1; //当前页面-1
                page = Mathf.Clamp(page, 1, totalPage); //由于页面数取值是1~totalPage，这里进行一次取值范围约束
            }
            if (GUILayout.Button("下一页")) //绘制下一页Button
            {
                page += 1; //当前页面+1
                page = Mathf.Clamp(page, 1, totalPage); //由于页面数取值是1~totalPage，这里进行一次取值范围约束
            }
            EditorGUILayout.EndHorizontal(); //结束水平布局

            EditorGUILayout.EndVertical(); //结束垂直布局
        }

        EditorGUILayout.EndFoldoutHeaderGroup(); //关闭 折叠组
        EditorGUILayout.EndScrollView(); //关闭 滚动视图
    }
}

using UnityEngine;
using System.Collections;

public class OnValidateExample : MonoBehaviour {
	public int size;

	void OnValidate() {
		Debug.Log("OnValidate");
	}
}

using UnityEngine;
using System.Collections;
 
public class OnValidateExample : MonoBehaviour {
	public float objectRotation;
 
	void OnValidate() {
		// objectRotation
		objectRotation = objectRotation % 360;
	}
}

using UnityEngine;
using System.Collections;
 
public class OnValidateExample : MonoBehaviour {
	[RangeAttribute(16, 4096)]
	public int textureSize;
 
	void OnValidate() {
		// textureSize
		textureSize = Mathf.ClosestPowerOfTwo(textureSize);
	}
}

using UnityEngine;
using System.Collections;
 
public class OnValidateExample : MonoBehaviour {
	[RangeAttribute(10, 300)] [Tooltip("mph")]
	public int maxCarSpeed;
	[RangeAttribute(10, 300)] [Tooltip("mph")]
	public int maxNitroSpeed;
 
	const int minNitroSpeedExtra = 20;
 
	void OnValidate() {
		// speed check
		if (maxNitroSpeed < maxCarSpeed + minNitroSpeedExtra)
			maxNitroSpeed = maxCarSpeed + minNitroSpeedExtra;
	}
}