Unity 编辑器扩展 Chapter2—Gizmos

二. 使用Gizoms绘制网格及矩阵转换使用

1. 创建Leve类，作为场景控制类：

using UnityEngine;
//使用namespace方便脚本管理
namespace RunAndJump {
//使用部分类partial将类依据不同的功能分布到各个文件中，便于功能区分个管理
    public partial class Level : MonoBehaviour {
        [SerializeField]
        public int _totalTime = 60;
        [SerializeField]
        private float _gravity = -30;
        [SerializeField]
        private AudioClip _bgm;
        [SerializeField]
        private Sprite _background;

        [SerializeField]
        private int _totalColumns = 25;

        [SerializeField]
        private int _totalRows = 10;

        public const float GridSize = 1.28f;

        private readonly Color _normalColor = Color.grey;
        private readonly Color _selectedColor = Color.yellow;
        public int TotalTime {
            get { return _totalTime; }
            set { _totalTime = value; }
        }

        public float Gravity {
            get { return _gravity; }
            set { _gravity = value; }
        }

        public AudioClip Bgm {
            get { return _bgm;}
            set { _bgm = value; }
        }

        public Sprite Background {
            get { return _background; }
            set { _background = value; }
        }

        public int TotalColumns
        {
            get
            {
                return _totalColumns;
            }

            set
            {
                _totalColumns = value;
            }
        }

        public int TotalRows
        {
            get
            {
                return _totalRows;
            }

            set
            {
                _totalRows = value;
            }
        }

    //绘制边界
        private void GridFrameGizmo(int cols, int rows)
        {
            Gizmos.DrawLine(new Vector3(0,0,0),new Vector3(0,rows*GridSize,0) );
            Gizmos.DrawLine(new Vector3(0, 0, 0), new Vector3(cols*GridSize,0, 0));
            Gizmos.DrawLine(new Vector3(cols*GridSize, 0, 0), new Vector3(cols*GridSize, rows * GridSize, 0));
            Gizmos.DrawLine(new Vector3(0, rows*GridSize, 0), new Vector3(cols*GridSize, rows * GridSize, 0));
        }

//绘制内部线条
        private void GridGizmos(int cols, int rows)
        {
            for (int i = 0; i < cols; i++)
            {
                Gizmos.DrawLine(new Vector3(i*GridSize,0,0),new Vector3(i*GridSize,rows*GridSize,0) );
            }

            for (int j = 0; j < rows; j++)
            {
                Gizmos.DrawLine(new Vector3(0,j * GridSize, 0), new Vector3(cols * GridSize, j * GridSize, 0));
            }
        }

    //D使用unity默认的OnDrawGizmos方法来绘制Gzimos
        private void OnDrawGizmos()
        {
            Color oldColor = Gizmos.color;//修改的这些属性都是静态属性，所以要在修改前保存其值，修改后再复原，防止后续使用该静态属性是修改后的
            Matrix4x4 oldMatrix = Gizmos.matrix;//修改的这些属性都是静态属性，所以要在修改前保存其值，修改后再复原，防止后续使用该静态属性是修改后的
            Gizmos.matrix = transform.localToWorldMatrix;//该语句可以为gizmos提供该transform位移，旋转，缩放等特性

            Gizmos.color = _normalColor;
            GridGizmos(_totalColumns,_totalRows);
            GridFrameGizmo(_totalColumns,_totalRows);

            Gizmos.color = oldColor;//恢复修改后的静态属性
            Gizmos.matrix = oldMatrix;//恢复修改后的静态属性
        }

        private void OnDrawGizmosSelected()
        {
            Color oldColor = Gizmos.color;
            Matrix4x4 oldMatrix = Gizmos.matrix;
            Gizmos.matrix = transform.localToWorldMatrix;


            Gizmos.color = _selectedColor;
            GridFrameGizmo(_totalColumns, _totalRows);

            Gizmos.color = oldColor;
            Gizmos.matrix = oldMatrix;

        }

        /// <summary>
        /// 将世界坐标转换为grid网格中的点坐标
        /// </summary>
        /// <param name="point">世界坐标</param>
        /// <returns></returns>
        public Vector3 WordToGridCoordinates(Vector3 point)
        {
            Vector3 gridPoint=new Vector3((int)((point.x-transform.position.x)/GridSize),(int)((point.y-transform.position.y)/GridSize),0.0f);
            return gridPoint;
        }

        /// <summary>
        /// Grid网格中的位置转换为世界坐标坐标
        /// </summary>
        /// <param name="col">行值</param>
        /// <param name="row">列值</param>
        /// <returns></returns>
        public Vector3 GridToWordCoordinates(int col,int row)
        {
            Vector3 wordPoint=new Vector3(transform.position.x+(col*GridSize/2.0f),transform.position.y+(row*GridSize/2.0f),0.0f);
            return wordPoint;
        }
        /// <summary>
        /// 坐标位置是否在网格边界内
        /// </summary>
        /// <param name="point"></param>
        /// <returns></returns>
        public bool IsInsideGridBounds(Vector3 point)
        {
            float minX = transform.position.x;
            float maxX = minX + _totalColumns*GridSize;
            float minY = transform.position.y;
            float maxY = minY + _totalRows*GridSize;
            return (point.x >= minX && point.x <= maxX && point.y >= minY && point.y <= maxY);
        }
    
        /// <summary>
            /// 坐标位置是否在网格边界内
            /// </summary>
            /// <param name="point"></param>
            /// <returns></returns>
    
        public bool IsInsideGridBounds(int col,int row)
        {
            return (col>=0&&col<_totalColumns&&row>=0&&row<=_totalRows);
        }
    }
}

2. 创建EditorUtil类，作为辅助工具类：

using UnityEngine;
using System.Collections;
using UnityEditor;
using UnityEditor.SceneManagement;

namespace RunAndJump.LevelCreator  //为防止类名冲突，使用namespace时一个好的解决方案
{
    public class EditorUtil
    {

        //创建新场景
        public static void NewScene()
        {
            //该方法后续过时，被下面方法替代：EditorApplication.SaveCurrentSceneIfUserWantsTo();
            EditorSceneManager.SaveCurrentModifiedScenesIfUserWantsTo();//当前场景有未保存的东西是，弹出对话框提醒是否保存当前场景
            //该方法后续过时，被下面方法替代：EditorApplication.NewScene();
            EditorSceneManager.NewScene(NewSceneSetup.EmptyScene);
        }


        //清空场景
        public static void CleanScene()
        {
            GameObject[] allObjects = Object.FindObjectsOfType<GameObject>();

            foreach (GameObject go in allObjects)
            {
                GameObject.DestroyImmediate(go);
            }
        }

        //创建新关卡
        public static void NewLevel()
        {
            NewScene();
            CleanScene();

            //可以在创建新关卡时添加上必要的游戏对象
            //add something...

            GameObject levelGo = new GameObject("Level");
            levelGo.transform.position=Vector3.zero;
            levelGo.AddComponent<Level>();

        }
    }
}

3. 创建MenuItems类，作为编辑器菜单工具类：

using UnityEngine;
using System.Collections;
using UnityEditor;

namespace RunAndJump.LevelCreator
{

    //菜单项管理类，用来控制扩展方法在菜单项中显示
    public class MenuItems
    {
        [MenuItem("Tools/LevelCreator/NewLevelScene %q") ]
        private static void NewLevel()
        {
            EditorUtil.NewLevel();
        }
    }
}

4. 创建SnapToGridTest类，用来测试Leve类中方法：

using UnityEngine;
using System.Collections;
using RunAndJump;

[ExecuteInEditMode]//在editor场景模式下不用运行就调用
public class SnapToGridTest : MonoBehaviour {

    // Update is called once per frame
    void Update ()
    {
        print(name+" in level");
        Vector3 gridCoord = Level.Instance.WordToGridCoordinates(transform.position);
        transform.position = Level.Instance.GridToWordCoordinates((int) gridCoord.x, (int) gridCoord.y);
    }

    private void OnDrawGizmos()
    {
        print("gizoms");
        Color oldColor = Gizmos.color;
        Gizmos.color = (Level.Instance.IsInsideGridBounds(transform.position)) ? Color.green : Color.red;
        Gizmos.DrawCube(transform.position,Vector3.one*Level.GridSize);
        Gizmos.color = oldColor;
    }
}

效果：

我们通过MenuItems创建的菜单调用EditorUtil中创建场景的方法，场景中在OnDrawGizoms方法中绘制出自己的网格。现在创建一个空物体为其绑上SnapToGridTest脚本用来验证level中用来对齐坐标到网格和验证是否出界的方法。