视野范围动态刷新

发表于 2024-05-19

前言

一直以来除了学图形学渲染的时候接触到摄像机的坐标系转换，平时对于摄像机照射范围的原理知之甚少。当我们在做可视区域判定时(比如SLG游戏只会创建可视区域范围内的东西)，我们需要计算出当前摄像机的照射范围，然后动态请求可视化区域内需要新增显示的地图对象。实现可视区域动态请求显示这一步离不开对摄像机可视区域的计算。本文正是为了深入解决可视区域计算，深入理解摄像机照射原理，实现一套可视化摄像机照射区域和动态可视区域物体动态创建的工具。

摄像机

摄像机目前分为透视摄像机和正交摄像机，前者有深度概念有透视效果会近大远小，后者忽略深度类似是把3D投射到2D平面的效果。

首先我们来看一下透视摄像机的投影图：

其中FOV是透视摄像机里很重要的一个参数，Fov指的是相机视场（Field of View）张角。

FOV指的是图中的DFOV，即对角线视场角。

VFOV指的是垂直视场角，VFOV是受屏幕高度影响

HFOV指的是水平视场角，HFOV是受屏幕宽度影响

摄像机照射区域

摄像机的可见范围计算原理：

不考虑摄像机是正交还是透视，通过将屏幕四个角映射到世界坐标系(屏幕坐标到世界坐标)，得到从摄像机到摄像机四个角的射线数据
计算四条射线到在指定平面的交叉点计算，得出的4个交叉点构成的形状就是我们要的透视摄像机在指定平面上的投影形状

仅仅是需要知道透视摄像机四条射线的前提下，我们不需要自己去计算DFOV，VFOV，HFOV等数据。

/// <summary>
/// 四个角的视口坐标
/// </summary>
private static Vector3[] ViewPortPoints = new Vector3[5]
{
    new Vector3(0, 0, 0),        // 左下角
    new Vector3(0, 1, 0),        // 左上角
    new Vector3(1, 1, 0),        // 右上角
    new Vector3(1, 0, 0),        // 右下角
    new Vector3(0.5f, 0.5f, 0),  // 中心
};

/// <summary>
/// 获取指定摄像机的射线数据列表
/// </summary>
/// <param name="camera"></param>
/// <param name="rayCastDataList"></param>
/// <returns></returns>
public static bool GetCameraRayCastDataList(Camera camera, ref List<KeyValuePair<Vector3, Vector3>> rayCastDataList)
{
    rayCastDataList.Clear();
    if(camera == null)
    {
        Debug.LogError($"不允许传递空摄像机组件，获取摄像机的射线数据列表失败！");
        return false;
    }

    var cameraNearClipPlane = camera.nearClipPlane;
    ViewPortPoints[0].z = cameraNearClipPlane;
    ViewPortPoints[1].z = cameraNearClipPlane;
    ViewPortPoints[2].z = cameraNearClipPlane;
    ViewPortPoints[3].z = cameraNearClipPlane;
    ViewPortPoints[4].z = cameraNearClipPlane;

    var isOrthographic = camera.orthographic;
    if(isOrthographic)
    {
        // 转换为射线
        for (int i = 0; i < ViewPortPoints.Length; i++)
        {
            Ray ray = camera.ViewportPointToRay(ViewPortPoints[i]);
            var rayCastToPoint = ray.origin + ray.direction * camera.farClipPlane;
            var rayCastData = new KeyValuePair<Vector3, Vector3>(ray.origin, rayCastToPoint);
            rayCastDataList.Add(rayCastData);
        }
    }
    else
    {
        var radio = camera.farClipPlane / cameraNearClipPlane;
        var cameraPosition = camera.transform.position;

        // 获取饰扣四个角的屏幕映射世界坐标
        var lbNearPlaneWorldPoints = camera.ViewportToWorldPoint(ViewPortPoints[0]);
        var ltNearPlaneWorldPoints = camera.ViewportToWorldPoint(ViewPortPoints[1]);
        var rtNearPlaneWorldPoints = camera.ViewportToWorldPoint(ViewPortPoints[2]);
        var rbNearPlaneWorldPoints = camera.ViewportToWorldPoint(ViewPortPoints[3]);
        var ctNearPlaneWorldPoints = camera.ViewportToWorldPoint(ViewPortPoints[4]);

        var lbNearPlaneCameraWorldPointDir = lbNearPlaneWorldPoints - cameraPosition;
        var ltNearPlaneCameraWorldPointDir = ltNearPlaneWorldPoints - cameraPosition;
        var rtNearPlaneCameraWorldPointDir = rtNearPlaneWorldPoints - cameraPosition;
        var rbNearPlaneCameraWorldPointDir = rbNearPlaneWorldPoints - cameraPosition;
        var ctNearPlaneCameraWorldPointDir = ctNearPlaneWorldPoints - cameraPosition;

        var lbFarPlaneWorldPoint = cameraPosition + lbNearPlaneCameraWorldPointDir * radio;
        var ltFarPlaneWorldPoint = cameraPosition + ltNearPlaneCameraWorldPointDir * radio;
        var rtFarPlaneWorldPoint = cameraPosition + rtNearPlaneCameraWorldPointDir * radio;
        var rbFarPlaneWorldPoint = cameraPosition + rbNearPlaneCameraWorldPointDir * radio;
        var ctFarPlaneWorldPoint = cameraPosition + ctNearPlaneCameraWorldPointDir * radio;

        var lbRayCastData = new KeyValuePair<Vector3, Vector3>(lbNearPlaneWorldPoints, lbFarPlaneWorldPoint);
        var ltRayCastData = new KeyValuePair<Vector3, Vector3>(ltNearPlaneWorldPoints, ltFarPlaneWorldPoint);
        var rtRayCastData = new KeyValuePair<Vector3, Vector3>(rtNearPlaneWorldPoints, rtFarPlaneWorldPoint);
        var rbRayCastData = new KeyValuePair<Vector3, Vector3>(rbNearPlaneWorldPoints, rbFarPlaneWorldPoint);        
        var ctRayCastData = new KeyValuePair<Vector3, Vector3>(ctNearPlaneWorldPoints, ctFarPlaneWorldPoint);        
        rayCastDataList.Add(lbRayCastData);
        rayCastDataList.Add(ltRayCastData);
        rayCastDataList.Add(rtRayCastData);
        rayCastDataList.Add(rbRayCastData);
        rayCastDataList.Add(ctRayCastData);
    }
    return true;
}

得到屏幕四个角映射的射线数据后，利用射线和平面的交叉计算得到指定平面交叉的点就能得到我们要的平面照射区域

/// <summary>
/// Vector3Utilities.cs
/// Vector3静态工具类
/// </summary>
public static class Vector3Utilities
{
    /// <summary>
    /// 获取指定射线和平面数据的交叉点(返回null表示没有交叉点)
    /// </summary>
    /// <param name="rayOrigin"></param>
    /// <param name="rayDirection"></param>
    /// <param name="planePoint"></param>
    /// <param name="planeNormal"></param>
    /// <returns></returns>
    public static Vector3? GetRayAndPlaneIntersect(Vector3 rayOrigin, Vector3 rayDirection, Vector3 planePoint, Vector3 planeNormal)
    {
        // 计算法向量和方向向量的点积
        float ndotu = Vector3.Dot(planeNormal, rayDirection);

        // 向量几乎平行，可能没有交点或者射线在平面内
        if (Mathf.Approximately(Math.Abs(ndotu), Mathf.Epsilon))
        {
            return null;
        }

        // 计算 t
        Vector3 w = rayOrigin - planePoint;
        float t = -Vector3.Dot(planeNormal, w) / ndotu;

        // 交点在射线起点的后面
        if (t < 0)
        {
            return null;
        }

        // 计算交点
        Vector3 intersectionPoint = rayOrigin + t * rayDirection;
        return intersectionPoint;
    }
}

/// <summary>
/// 获取指定摄像机指定区域顶点和法线的的可视区域顶点数据
/// </summary>
/// <param name="camera"></param>
/// <param name="areaPoint"></param>
/// <param name="areaNormal"></param>
/// <param name="areaPointsList"></param>
/// <param name="rectPointList"></param>
/// <returns></returns>
public static bool GetCameraVisibleArea(Camera camera, Vector3 areaPoint, Vector3 areaNormal, ref List<Vector3> areaPointsList, ref List<Vector3> rectPointList)
{
    areaPointsList.Clear();
    rectPointList.Clear();
    if (camera == null)
    {
        Debug.LogError($"不允许传递空摄像机组件，获取摄像机的可视区域顶点数据失败！");
        return false;
    }

    RayCastDataList.Clear();
    GetCameraRayCastDataList(camera, ref RayCastDataList);
    foreach(var rayCastData in RayCastDataList)
    {
        var rayCastDirection = rayCastData.Value - rayCastData.Key;
        var areaData = Vector3Utilities.GetRayAndPlaneIntersect(rayCastData.Key, rayCastDirection, areaPoint, areaNormal);
        if(areaData != null)
        {
            areaPointsList.Add((Vector3)areaData);
        }
    }

    rectPointList.Add(new Vector3(areaPointsList[1].x, areaPointsList[0].y, areaPointsList[0].z));
    rectPointList.Add(new Vector3(areaPointsList[1].x, areaPointsList[1].y, areaPointsList[1].z));
    rectPointList.Add(new Vector3(areaPointsList[2].x, areaPointsList[2].y, areaPointsList[2].z));
    rectPointList.Add(new Vector3(areaPointsList[2].x, areaPointsList[3].y, areaPointsList[3].z));
    rectPointList.Add(areaPointsList[4]);
    return true;
}

从上面可以看到无论是areaPointsList还是rectPointList都返回了5个顶点数据，第五个是屏幕中心映射的点。

之所以返回矩形的映射区域，是为了简化后面透视摄像机梯形判定顶点复杂度，简化成AABB和点的交叉判定。

摄像机照射区域可视化

得到了屏幕映射的顶点数据，通过构建线条数据，我们就能利用GUI相关接口画出可视化可见区域了

/// <summary>
/// 区域顶点
/// </summary>
[Header("区域顶点")]
public Vector3 AreaPoint = Vector3.zero;

/// <summary>
/// 区域法线
/// </summary>
[Header("区域法线")]
public Vector3 AreaNormal = Vector3.up;

/// <summary>
/// 更新摄像机指定平面映射区域数据
/// </summary>
public void UpdateAreaDatas()
{
    CameraUtilities.GetCameraRayCastDataList(mCameraComponent, ref mRayCastDataList);
    CameraUtilities.GetCameraVisibleArea(mCameraComponent, AreaPoint, AreaNormal, ref mAreaPointsList, ref mRectAreaPointsList);
    mAreaLinesList.Clear();
    mRectAreaLinesList.Clear();
    if(mAreaPointsList.Count > 0)
    {
        var lbToLtLine = new KeyValuePair<Vector3, Vector3>(mAreaPointsList[0], mAreaPointsList[1]);
        var ltToRtLine = new KeyValuePair<Vector3, Vector3>(mAreaPointsList[1], mAreaPointsList[2]);
        var rtToRbLine = new KeyValuePair<Vector3, Vector3>(mAreaPointsList[2], mAreaPointsList[3]);
        var rbToLbLine = new KeyValuePair<Vector3, Vector3>(mAreaPointsList[3], mAreaPointsList[0]);
        mAreaLinesList.Add(lbToLtLine);
        mAreaLinesList.Add(ltToRtLine);
        mAreaLinesList.Add(rtToRbLine);
        mAreaLinesList.Add(rbToLbLine);

        var rectLbToLtLine = new KeyValuePair<Vector3, Vector3>(mRectAreaPointsList[0], mRectAreaPointsList[1]);
        var rectLtToRtLine = new KeyValuePair<Vector3, Vector3>(mRectAreaPointsList[1], mRectAreaPointsList[2]);
        var rectRtToRbLine = new KeyValuePair<Vector3, Vector3>(mRectAreaPointsList[2], mRectAreaPointsList[3]);
        var rectRbToLbLine = new KeyValuePair<Vector3, Vector3>(mRectAreaPointsList[3], mRectAreaPointsList[0]);
        mRectAreaLinesList.Add(rectLbToLtLine);
        mRectAreaLinesList.Add(rectLtToRtLine);
        mRectAreaLinesList.Add(rectRtToRbLine);
        mRectAreaLinesList.Add(rectRbToLbLine);
    }
}

/// <summary>
/// 绘制区域信息Gizmos
/// </summary>
private void DrawAreaInfoGUI()
{
    var preGizmosColor = Gizmos.color;
    Gizmos.color = Color.green;
    Gizmos.DrawSphere(AreaPoint, SphereSize);
    var areaPointTo = AreaPoint + AreaNormal * 5;
    Gizmos.DrawLine(AreaPoint, areaPointTo);
    Gizmos.color = preGizmosColor;
}

/// <summary>
/// 绘制矩形区域
/// </summary>
private void DrawRectAreaGUI()
{
    var preGizmosColor = Gizmos.color;
    Gizmos.color = new Color(0, 0.5f, 0);
    if(mRectAreaLinesList.Count > 0)
    {
        Gizmos.DrawLine(mRectAreaLinesList[0].Key, mRectAreaLinesList[0].Value);
        Gizmos.DrawLine(mRectAreaLinesList[1].Key, mRectAreaLinesList[1].Value);
        Gizmos.DrawLine(mRectAreaLinesList[2].Key, mRectAreaLinesList[2].Value);
        Gizmos.DrawLine(mRectAreaLinesList[3].Key, mRectAreaLinesList[3].Value);
    }
    Gizmos.color = preGizmosColor;
}

/// <summary>
/// 绘制区域Gizmos
/// </summary>
private void DrawAreaGUI()
{
    var preGizmosColor = Gizmos.color;
    Gizmos.color = Color.green;
    if(mAreaLinesList.Count > 0)
    {
        Gizmos.DrawLine(mAreaLinesList[0].Key, mAreaLinesList[0].Value);
        Gizmos.DrawLine(mAreaLinesList[1].Key, mAreaLinesList[1].Value);
        Gizmos.DrawLine(mAreaLinesList[2].Key, mAreaLinesList[2].Value);
        Gizmos.DrawLine(mAreaLinesList[3].Key, mAreaLinesList[3].Value);
    }
    if(mAreaPointsList.Count > 0)
    {
        Gizmos.DrawSphere(mAreaPointsList[4], SphereSize);
    }
    Gizmos.color = preGizmosColor;
}

摄像机照射区域可视化：

可以看到黄色是远截面照射区域，深绿色是近截面照射区域，浅绿色是摄像机近截面换算成矩形后的区域，红色线条是摄像机近截面和远截面射线，

透视摄像机效果如下:

正交摄像机效果如下:

摄像机照射区域动态刷新

动态区域刷新核心要点:

映射屏幕4个点得到四条摄像机照射射线，通过计算4条射线与指定平面的交叉点得到照射区域，简化照射区域形状到矩形，将物体是否在照射区域转换成点与AABB交叉判定

实战摄像机照射区域动态刷新参考地图编辑器:

MapEditor

实战效果图：

Note:

屏幕4个顶点计算顺序依次是左下，左上，右上，右下

重点知识

不考虑摄像机是正交还是透视，通过将屏幕四个角映射到世界坐标系(屏幕坐标到世界坐标)，得到从摄像机到摄像机四个角的射线数据，然后将摄像机区域计算转换成计算四条射线到在指定平面的交叉点计算，得出的4个交叉点构成的形状就是我们要的透视摄像机在指定平面上的投影形状
FOV分为DFOV(对角线视场角)，VFOV(垂直视场角，受屏幕高度影响)和HFOV(水平视场角，受屏幕宽度影响)
透视摄像机看多少不仅受FOV影响还受屏幕分辨率影响
摄像机指定位置平面照射形状可以转换成摄像机4个射线和平面的相交检测处理

博客

地图编辑器

GitHub

MapEditor

Reference

根据相机参数计算视场角（Filed of View, FOV）

摄像与平面的相交检测(Ray-Plane intersection test)

浅析相机FOV

Fov数值推荐设置

地图编辑器

By Tony Tang

发表于 2024-04-23

Introduction

游戏开发过程中，我们搭建关卡时需要一个工具去支持摆放场景物件和数据埋点编辑，从而支持快速搭建关卡和策划数据埋点。这一工具正是本章节需要实现的地图编辑器。

地图编辑器

需求

实现一个工具，首先第一步，我们还是需要理清需求：

纯Editor地图编辑器，用于场景编辑和数据埋点。
支持自定义场景对象数据和自由摆放场景对象进行场景编辑，场景对象支持静态摆放和动态创建两种。
支持自定义埋点数据和自由摆放埋点数据进行数据埋点编辑。
支持自定义调整场景大小以及场景地形指定和大小自动适配。
场景数据和埋点数据支持导出自定义数据格式(比如Lua,Json等)。
同一个场景支持编辑多个场景编辑和数据埋点。

设计实现

接下来针对前面提到的需求，我们一一分析我们应该用什么方案和技术来实现。

实现思路：

地图编辑器主要由地图编辑器配置窗口和地图编辑器挂在操作脚本Inspector组成。
地图编辑器编辑数据分为两大类(1. 地图编辑 2. 数据埋点)。
继承EditorWindow实现场景编辑和数据埋点的基础数据配置编辑。
继承Editor自定义Inspector面板实现纯单个场景编辑和数据埋点操作。
地图编辑操作通过挂在脚本(Map.cs)的方式作为单个场景编辑和数据埋点单位，从而实现单个场景多个场景编辑和数据埋点支持。
场景对象编辑采用直接创建实体GameObject的方式，从而实现场景编辑完成后的场景可直接用于作为场景使用。
场景对象编辑通过自定义Inspector面板实现快速删除和创建场景对象GameObject实现场景对象的编辑。
数据埋点采用Gizmos(Monobehaviour:OnDrawGizmos())，Handles(Editor.OnSceneGUI())实现可视化编辑对象和相关数据显示，自定义场景大小配置网格显示也是用Gizmos实现。
地图编辑器配置窗口用于配置基础的场景数据和埋点数据配置，Map.cs的挂在脚本通过自定义数据结构和自定义面板显示实现自定义数据配置。
场景静态对象相关数据通过挂在MapObjectDataMono脚本存储相关对象数据。
导出前通过Map.cs存储的数据构建自定义数据(MapExport.cs)实现自定义数据导出
大地图未来有需求可以做成所有静态对象通过导出数据根据逻辑加载的方式实现按需加载。

核心思路和技术实现方案都在上面介绍了，这里就不一一介绍代码实现了，这里只放部分关键代码，让我们直接实战看效果，需要源码的直接在文章末尾Github链接去取即可。

配置窗口

配置窗口主要负责实现对地图编辑对象，地图编辑埋点的基础数据定义，一些相关操作按钮和全局配置。

配置定义

地图配置数据结构定义:

/// <summary>
/// MapSetting.cs
/// </summary>
public class MapSetting : ScriptableObject
{
#if UNITY_EDITOR
    /// <summary>
    /// Editor下的地图配置单例对象
    /// </summary>
    private static MapSetting EditorSingleton;

    /// <summary>
    /// 获取Editor地图配置单例对象
    /// </summary>
    /// <returns></returns>
    public static MapSetting GetEditorInstance()
    {
        if(EditorSingleton == null)
        {
            EditorSingleton = MapUtilities.LoadOrCreateGameMapSetting();
        }
        return EditorSingleton;
    }
    #endif
        
    /// <summary>
    /// 默认地图横向大小
    /// </summary>
    [Header("默认地图横向大小")]
    [Range(1, 1000)]
    public int DefaultMapWidth = MapConst.DefaultMapWidth;

    /// <summary>
    /// 默认地图纵向大小
    /// </summary>
    [Header("默认地图纵向大小")]
    [Range(1, 1000)]
    public int DefaultMapHeight = MapConst.DefaultMapHeight;

    /// <summary>
    /// 地图对象配置数据
    /// </summary>
    [Header("地图对象配置数据")]
    public MapObjectSetting ObjectSetting = new MapObjectSetting();

    /// <summary>
    /// 地图埋点配置数据
    /// </summary>
    [Header("地图埋点配置数据")]
    public MapDataSetting DataSetting = new MapDataSetting();
}

地图对象配置定义:

/// <summary>
/// MapObjectType.cs
/// 地图对象类型枚举
/// </summary>
public enum MapObjectType
{
    Scene = 0,                  // 场景
    Door = 1,                   // 门
}

/// <summary>
/// MapObjectSetting.cs
/// 地图对象设置数据
/// </summary>
[Serializable]
public class MapObjectSetting
{
    /// <summary>
    /// 所有地图对象类型配置数据
    /// </summary>
    [Header("所有地图对象类型配置数据")]
    [SerializeReference]
    public List<MapObjectTypeConfig> AllMapObjectTypeConfigs = new List<MapObjectTypeConfig>();
    
    /// <summary>
    /// 所有地图对象配置数据
    /// </summary>
    [Header("所有地图对象配置数据")]
    [SerializeReference]
    public List<MapObjectConfig> AllMapObjectConfigs = new List<MapObjectConfig>();
    
    ******
}

/// <summary>
/// MapObjectConfig.cs
/// 地图对象数据配置
/// </summary>
[Serializable]
public class MapObjectConfig
{
    /// <summary>
    /// 唯一ID(用于标识地图对象配置唯一)
    /// </summary>
    [Header("唯一ID")]
    public int UID;

    /// <summary>
    /// 地图对象类型
    /// </summary>
    [Header("地图对象类型")]
    public MapObjectType ObjectType;

    /// <summary>
    /// 是否是动态地图对象
    /// </summary>
    [Header("是否是动态地图对象")]
    public bool IsDynamic;

    /// <summary>
    /// 关联Id
    /// </summary>
    [Header("关联Id")]
    public int ConfId;

    /// <summary>
    /// 资源Asset
    /// </summary>
    [Header("资源Asset")]
    public GameObject Asset;

    /// <summary>
    /// 描述
    /// </summary>
    [Header("描述")]
    public string Des;
    
    ******
}

地图埋点配置定义:

/// <summary>
/// MapDataType.cs
/// 地图数据埋点类型枚举
/// </summary>
public enum MapDataType
{
    PlayerSpawn = 0,           // 玩家出生点位置数据
    Monster = 1,               // 怪物数据
    TreasureBox = 2,           // 宝箱数据
    Trap = 3,                  // 陷阱数据
}

/// <summary>
/// MapDataSetting.cs
/// 地图数据配置数据
/// </summary>
[Serializable]
public class MapDataSetting
{
    /// <summary>
    /// 所有地图埋点数据配置
    /// </summary>
    [Header("所有地图埋点数据配置")]
    [SerializeReference]
    public List<MapDataConfig> AlllMapDataConfigs = new List<MapDataConfig>();

    ******
}

/// <summary>
/// MapDataConfig.cs
/// 地图埋点数据配置
/// </summary>
[Serializable]
public class MapDataConfig
{
    /// <summary>
    /// 唯一ID(用于标识地图埋点配置唯一)
    /// </summary>
    [Header("唯一ID")]
    public int UID;

    /// <summary>
    /// 地图数据类型
    /// </summary>
    [Header("地图数据类型")]
    public MapDataType DataType;

    /// <summary>
    /// 关联Id
    /// </summary>
    [Header("关联Id")]
    public int ConfId;

    /// <summary>
    /// 场景球体颜色
    /// </summary>
    [Header("场景球体颜色")]
    public Color SceneSphereColor = Color.red;

    /// <summary>
    /// 描述
    /// </summary>
    [Header("描述")]
    public string Des;
    
    ******
}

配置定义设计如下:

MapSetting是地图编辑器配置数据结构定义，继承至ScriptableObject，保存到Editor
MapObjectSetting是地图对象的所有编辑器配置结构定义。MapObjectConfig是地图对象编辑器单条配置结构定义。MapObjectType是地图对象类型定义。
MapDataSetting是地图埋点的所有编辑器配置结构定义。MapDataConfig是地图埋点编辑器单条配置结构定义。MapDataType是地图埋点类型定义。

配置窗口

可以看到在地图编辑器窗口主要分为4个区域：

快捷按钮区域
自定义地图基础数据区域(e.g. 默认地图宽高)
地图对象配置区域
地图埋点配置区域

以上配置数据会成为我们后面操作编辑Inspector里用户可以添加操作的基础数据来源，详细代码参见MapEditorWindow.cs。

快捷按钮区域

效果图：

可以看到目前提供了三个快捷按钮：

保存地图配置数据 – 用于确保我们在配置窗口的数据配置修改保存到本地ScriptableObject Asset
打开地图编辑场景 – 用于帮助我们快速打开辅助地图编辑的场景
快速选中地图地编对象 – 用于帮助我们快速选中当前场景里第一个带Map.cs脚本的对象，方便快速进入Map.cs的Inspector操作面板操作
一键导出所有地图 – 用于一键导出所有编辑好的地图埋点数据
一键烘焙导出所有地图 – 用于一键烘焙所有场景和导出所有编辑好的地图埋点数据

自定义地图数据区域

效果图：

自定义数据目前只支持了默认创建地图编辑宽高配置(挂在Map.cs脚本时默认创建的地图横向竖向大小数据来源)。

未来扩展更多基础配置数据在这里添加。

地图对象配置区域

效果图：

地图对象配置设计如下:

以UID作为唯一配置Id标识(不允许重复)，此Id会作为我们编辑器地图对象配置数据读取的依据。
通过MapObjectType指定地图对象类型。
通过定义ConfId(关联配置Id)实现关联游戏内动态对象Id的功能。
地图对象编辑通过定义Asset实现指定自定义预制件Asset作为实体对象的资源对象。
描述用于方便用户自定义取名，方便识别不同的地图对象配置。

Note:

需要参与导出的地图基础配置数据如果修改了(比如关联配置Id)，对应用到此基础配置数据的关卡都需要重新导出。
MapObjectType需要代码自定义扩展后，编辑器才有更多选项

地图埋点配置区域

效果图：

地图埋点配置设计如下:

以UID作为唯一配置Id标识(不允许重复)，此Id会作为我们编辑器地图埋点配置数据读取的依据。
通过MapDataType指定地图埋点类型。
通过定义ConfId(关联配置Id)实现关联游戏内动态对象Id的功能。
场景球体颜色用于配置地图埋点的GUI球体绘制颜色配置。
初始旋转用于配置地图埋点添加时的初始旋转配置(方便自定义大部分用到的初始宣旋转数据)
描述用于方便用户自定义取名，方便识别不同的地图埋点配置。

Note:

MapDataType需要代码自定义扩展后，编辑器才有更多选项

操作编辑Inspector

操作编辑Inspector主要负责实现对地图编辑对象和地图编辑埋点的一些相关操作面板，可视化GUI数据绘制，地图编辑自定义基础数据配置以及一些快捷操作按钮，详细代码参见Map.cs和MapEditor.cs。

基础数据配置区域

基础数据配置区域用于GUI开关，地图大小，地图起始位置，自定义地形等配置。

效果图:

自定义配置区域介绍：

场景GUI总开关 – 所有绘制GUI的总开关
地图线条GUI开关 – 控制地图N*N的线条GUI绘制开关
地图对象场景GUI开关 – 控制地图对象相关的GUI绘制开关
地图埋点场景GUI开关 – 控制地图埋点相关的GUI绘制开关
地图对象创建自动聚焦开关 – 控制地图对象创建后是否需要自动聚焦选中
地图横向大小和地图纵向大小 – 用于控制我们需要编辑的关卡地图的大小，会影响默认地图或自定义地图的大小和平铺
游戏地图起始位置 – 用于控制关卡的起始位置偏移，方便支持自定义不同起始位置的关卡设置

快捷操作按钮区域

快捷操作按钮区域用于支持自定义功能。

效果图:

快捷按钮功能介绍：

拷贝NavMesh Asset按钮 – NavMeshSurface默认烘焙Asset保存在对应场景同层目录，此按钮用于快速拷贝对应Asset到对应关卡预制件同层目录
一键重创地图对象按钮 – 用于我们更新了某些已经创建好的静态地图对象(脱离预制件关联)相关资源后一键确保使用最新资源创建
导出地图数据按钮 – 用于完成我们的关卡数据序列化导出
保存关卡数据 – 用于独立保存关卡埋点相关数据(支持自定义名字，默认和预制件同名)
一键烘焙拷贝导出 – 用于一键完成恢复动态对象+烘培寻路+拷贝寻路+清除动态对象+导出地图数据操作

Note:

场景对象是否参与寻路烘培，通过修改预制件Layer和NavMeshSurface的寻路烘培的Layer决定
大部分操作在实体对象做成预制件后需要进入预制件编辑模式，所以部分操作会根据脚本所在实体对象情况决定是否自动进入预制件编辑模式

地图对象编辑区域

效果图:

地图对象数据定义：

/// <summary>
/// MapObjectData.cs
/// 地图对象数据
/// </summary>
[Serializable]
public class MapObjectData
{
    /// <summary>
    /// 唯一Id(用于标识地图对象配置唯一)
    /// </summary>
    [Header("唯一Id")]
    public int UID;

    /// <summary>
    /// 实体对象
    /// </summary>
    [Header("实体对象")]
    public GameObject Go;

    /// <summary>
    /// 埋点位置(地图对象可能删除还原，所以需要逻辑层面记录位置)
    /// </summary>
    [Header("埋点位置")]
    public Vector3 Position;

    /// <summary>
    /// 旋转(地图对象可能删除还原，所以需要逻辑层面记录旋转)
    /// </summary>
    [Header("旋转")]
    public Vector3 Rotation = Vector3.zero;

    /// <summary>
    /// 本地缩放(地图对象可能删除还原，所以需要逻辑层面记录缩放)
    /// </summary>
    [Header("缩放")]
    public Vector3 LocalScale = Vector3.one;

    /// <summary>
    /// 碰撞器中心点
    /// </summary>
    [Header("碰撞器中心点")]
    public Vector3 ColliderCenter = new Vector3(0, 0, 0);

    /// <summary>
    /// 碰撞器大小
    /// </summary>
    [Header("碰撞器大小")]
    public Vector3 ColliderSize = new Vector3(1, 1, 1);

    /// <summary>
    /// 碰撞体半径
    /// </summary>
    [Header("碰撞体半径")]
    public float ColliderRadius = 1;

    /// <summary>
    /// 带参构造函数
    /// </summary>
    /// <param name="uid"></param>
    /// <param name="go"></param>
    public MapObjectData(int uid, GameObject go)
    {
        UID = uid;
        Go = go;
    }
}

地图对象编辑通过选择地图对象类型和地图对象选择决定要添加的地图对象配置。

地图对象编辑和地图对象选择后面的**+默认是添加到地图对象数据列表尾部**。

地图对象数据列表后的操作可以对已经配置的地图对象数据进行相关操作，此处的**+号是将选择的地图对象类型和地图对象选择插入的当前数据位置**。

Note:

地图对象可以通过地图对象配置面板配置的关联id导出给程序实现动态对象的配置关联
地图对象的数据关联是通过挂在MapObjectDataMono.cs脚本实现
未来如果地图对象要想实现按需加载可以通过导出地图对象数据给程序动态加载实现，相关代码参考MapObjectExport.cs相关代码(不分代码注释着)

地图埋点编辑区域

效果图:

地图埋点数据定义：

/// <summary>
/// MapData.cs
/// 地图数据买点数据
/// </summary>
[Serializable]
public class MapData
{
    /// <summary>
    /// 唯一Id(用于标识地图对象配置唯一)
    /// </summary>
    [Header("唯一Id")]
    public int UID;

    /// <summary>
    /// 埋点位置
    /// </summary>
    [Header("埋点位置")]
    public Vector3 Position;

    /// <summary>
    /// 埋点旋转
    /// </summary>
    [Header("埋点旋转")]
    public Vector3 Rotation;

    /// <summary>
    /// 批量操作开关
    /// </summary>
    [Header("批量操作开关")]
    public bool BatchOperationSwitch;

    /// <summary>
    /// GUI关闭开关
    /// </summary>
    [Header("GUI关闭开关")]
    public bool GUISwitchOff = false;
    
    public MapData(int uid)
    {
        UID = uid;
    }

    public MapData(int uid, Vector3 position, Vector3 rotation)
    {
        UID = uid;
        Position = position;
        Rotation = rotation;
    }
}

地图埋点编辑通过选择地图埋点类型和地图埋点选择决定要添加的地图埋点配置。

地图埋点编辑和地图埋点选择后面的**+默认是添加到地图埋点数据列表尾部**。

地图埋点数据列表后的操作可以对已经配置的地图埋点数据进行相关操作，此处的**+号是将选择的地图埋点类型和地图对象选择插入的当前数据位置**。

地图埋点支持批量操作位置，通过勾选批量选项决定哪些地图埋点数据要一起操作位置，然后操作(拖拽或者输入坐标)勾选了批量的地图埋点对象的位置，可以实现一起修改勾选了批量操作的地图埋点位置。

一键清除批量勾选按钮 – 用于快速取消所有已勾选批量的地图埋点数据

快捷键操作:

前提:选中挂载Map脚本的GameObject

Scene场景里按住W键会看到埋点数据位置的坐标轴，然后就可以直接拖拽位置。

Scene场景里按住E键会看到埋点数据旋转的坐标轴，然后就可以直接拖拽旋转。

Note:

地图数据的编辑和导出是按Map.cs脚本为单位。
地图埋点数据时通过Editor GUI(e.g. Handles和Gimoz)绘制的
地图埋点的位置调整需要按住W按键，旋转调整需要按住E按键
地图埋点支持配置自定义数据，这部分可以参考Monster埋点的自定义数据配置
地图埋点通过地图埋点配置面板配置的关联id导出给程序实现地图埋点的配置关联
自定义数据埋点可视化可以通过扩展MapEditor.cs实现自定义绘制

寻路烘培

目前场景编辑是以Map.cs为单位。所以寻路烘培目前也是按Map.cs所在预制件为单位。

通过每个Map.cs所在GameObject挂在NavMeshSurface组件实现对当前GameObject的寻路烘培。

效果图:

Note:

NavMeshSurface设置Collect Objects为Children(只有子节点参与烘培)，参与烘培的Include Layers设置成自定义的实现是否参与烘培的Layer规则。

数据导出

数据导出是通过点击导出地图数据按钮或者一键烘培拷贝导出按钮实现的。

为了支持多种不同数据格式的导出，在数据导出之前我进行导出数据的定义和抽象。

地图导出数据结构定义:

/// <summary>
/// MapExport.cs
/// 地图导出数据结构定义(统一导出结构定义，方便支持导出不同的数据格式)
/// </summary>
[Serializable]
public class MapExport
{
    /// <summary>
    /// 地图导出数据成员
    /// </summary>
    public MapDataExport MapData = new MapDataExport();

    /// <summary>
    /// 所有怪物导出数据列表
    /// </summary>
    public List<MonsterMapDataExport> ALlMonsterMapDatas = new List<MonsterMapDataExport>();

    /// <summary>
    /// 所有宝箱导出数据列表
    /// </summary>
    public List<TreasureBoxMapDataExport> AllTreasureBoxMapDatas = new List<TreasureBoxMapDataExport>();

    /// <summary>
    /// 所有陷阱导出数据列表
    /// </summary>
    public List<TrapMapDataExport> AllTrapMapDatas = new List<TrapMapDataExport>();

    /// <summary>
    /// 剩余其他地图埋点导出数据成员
    /// </summary>
    public List<BaseMapDataExport> AllOtherMapDatas = new List<BaseMapDataExport>();
}

地图对象导出数据基类定义:

/// <summary>
/// MapObjectExport.cs
/// 地图动态物体数据导出定义
/// </summary>
[Serializable]
public class MapObjectExport
{
    /// <summary>
    /// 地图对象类型
    /// </summary>
    public MapObjectType MapObjectType;

    /// <summary>
    /// 关联配置Id
    /// </summary>
    public int ConfId;

    /// <summary>
    /// 位置信息
    /// </summary>
    public Vector3 Position;

    /// <summary>
    /// 旋转信息
    /// </summary>
    public Vector3 Rotation;

    /// <summary>
    /// 缩放信息
    /// </summary>
    public Vector3 LocalScale;

    public MapObjectExport(MapObjectType mapObjectType, int confId, Vector3 position, Vector3 rotation, Vector3 localScale) 
    {
        MapObjectType = mapObjectType;
        ConfId = confId;
        Position = position;
        Rotation = rotation;
        LocalScale = localScale;
    }
}

地图埋点导出数据基类定义:

/// <summary>
/// BaseMapDataExport.cs
/// 地图埋点数据基类导出定义
/// </summary>
[Serializable]
public class BaseMapDataExport
{
    /// <summary>
    /// 埋点类型
    /// </summary>
    public MapDataType MapDataType;

    /// <summary>
    /// 关联Id
    /// </summary>
    public int ConfId;

    /// <summary>
    /// 位置信息
    /// </summary>
    public Vector3 Position;

    /// <summary>
    /// 旋转信息
    /// </summary>
    public Vector3 Roation;

    public BaseMapDataExport(MapDataType mapDataType, int confId, Vector3 position, Vector3 rotation)
    {
        MapDataType = mapDataType;
        ConfId = confId;
        Position = position;
        Roation = rotation;
    }
}

怪物埋点数据导出定义：

/// <summary>
/// MonsterMapDataExport.cs
/// 怪物地图埋点数据导出
/// </summary>
[Serializable]
public class MonsterMapDataExport : BaseMapDataExport
{
    /// <summary>
    /// 怪物创建半径
    /// </summary>
    public float MonsterCreateRadius;

    /// <summary>
    /// 怪物警戒半径
    /// </summary>
    public float MonsterActiveRadius;

    public MonsterMapDataExport(MapDataType mapDataType, int confId, Vector3 position,  Vector3 rotation, float monsterCreateRadius, float monsterActiveRadius)
        : base(mapDataType, confId, position, rotation)
        {
            MonsterCreateRadius = monsterCreateRadius;
            MonsterActiveRadius = monsterActiveRadius;
        }
}

地图导出数据预览Level1.json:

{
    "MapData": {
        "Width": 8,
        "Height": 30,
        "StartPos": {
            "x": 0.0,
            "y": 0.0,
            "z": 0.0
        },
        "BirthPos": [
            {
                "x": 4.0,
                "y": 0.0,
                "z": 2.0
            }
        ]
    },
    "AllBaseMapObjectExportDatas": [
        {
            "MapObjectType": 2,
            "ConfId": 1,
            "Position": {
                "x": 4.0,
                "y": 1.0,
                "z": 3.7200000286102297
            },
            "Rotation": {
                "x": 0.0,
                "y": 0.0,
                "z": 0.0
            }
        },
        {
            "MapObjectType": 2,
            "ConfId": 1,
            "Position": {
                "x": 4.0,
                "y": 1.0,
                "z": 11.600000381469727
            },
            "Rotation": {
                "x": 0.0,
                "y": 0.0,
                "z": 0.0
            }
        }
    ],
    "AllColliderMapDynamicExportDatas": [
        {
            "MapObjectType": 1,
            "ConfId": 2,
            "Position": {
                "x": 4.0,
                "y": 0.25,
                "z": 8.149999618530274
            },
            "Rotation": {
                "x": 0.0,
                "y": 0.0,
                "z": 0.0
            },
            "ColliderCenter": {
                "x": 0.0,
                "y": 0.0,
                "z": 0.0
            },
            "ColliderSize": {
                "x": 0.0,
                "y": 0.0,
                "z": 0.0
            },
            "ColliderRiduis": 0.5
        },
        {
            "MapObjectType": 0,
            "ConfId": 3,
            "Position": {
                "x": 4.0,
                "y": 0.5,
                "z": 18.809999465942384
            },
            "Rotation": {
                "x": 0.0,
                "y": 0.0,
                "z": 0.0
            },
            "ColliderCenter": {
                "x": 0.0,
                "y": 0.0,
                "z": 0.0
            },
            "ColliderSize": {
                "x": 1.0,
                "y": 1.0,
                "z": 1.0
            },
            "ColliderRiduis": 0.0
        },
        {
            "MapObjectType": 0,
            "ConfId": 3,
            "Position": {
                "x": 4.0,
                "y": 0.5,
                "z": 14.899999618530274
            },
            "Rotation": {
                "x": 0.0,
                "y": 0.0,
                "z": 0.0
            },
            "ColliderCenter": {
                "x": 0.0,
                "y": 0.0,
                "z": 0.0
            },
            "ColliderSize": {
                "x": 1.0,
                "y": 1.0,
                "z": 1.0
            },
            "ColliderRiduis": 0.0
        }
    ],
    "AllMonsterGroupMapDatas": [
        {
            "MapDataType": 2,
            "ConfId": 0,
            "Position": {
                "x": 4.0,
                "y": 0.0,
                "z": 8.0
            },
            "Roation": {
                "x": 0.0,
                "y": 0.0,
                "z": 0.0
            },
            "GroupId": 1,
            "MonsterCreateRadius": 4.0,
            "MonsterActiveRadius": 3.0,
            "AllMonsterMapExportDatas": [
                {
                    "MapDataType": 1,
                    "ConfId": 1,
                    "Position": {
                        "x": 4.0,
                        "y": 0.0,
                        "z": 7.0
                    },
                    "Roation": {
                        "x": 0.0,
                        "y": 90.0,
                        "z": 0.0
                    },
                    "GroupId": 1
                },
                {
                    "MapDataType": 1,
                    "ConfId": 1,
                    "Position": {
                        "x": 5.0,
                        "y": 0.0,
                        "z": 9.0
                    },
                    "Roation": {
                        "x": 0.0,
                        "y": 90.0,
                        "z": 0.0
                    },
                    "GroupId": 1
                },
                {
                    "MapDataType": 1,
                    "ConfId": 1,
                    "Position": {
                        "x": 6.0,
                        "y": 0.0,
                        "z": 8.0
                    },
                    "Roation": {
                        "x": 0.0,
                        "y": 90.0,
                        "z": 0.0
                    },
                    "GroupId": 1
                }
            ]
        },
        {
            "MapDataType": 2,
            "ConfId": 0,
            "Position": {
                "x": 4.0,
                "y": 0.0,
                "z": 25.0
            },
            "Roation": {
                "x": 0.0,
                "y": 0.0,
                "z": 0.0
            },
            "GroupId": 2,
            "MonsterCreateRadius": 6.0,
            "MonsterActiveRadius": 4.0,
            "AllMonsterMapExportDatas": [
                {
                    "MapDataType": 1,
                    "ConfId": 1,
                    "Position": {
                        "x": 4.0,
                        "y": 0.0,
                        "z": 26.0
                    },
                    "Roation": {
                        "x": 0.0,
                        "y": 90.0,
                        "z": 0.0
                    },
                    "GroupId": 2
                },
                {
                    "MapDataType": 1,
                    "ConfId": 1,
                    "Position": {
                        "x": 5.0,
                        "y": 0.0,
                        "z": 26.0
                    },
                    "Roation": {
                        "x": 0.0,
                        "y": 90.0,
                        "z": 0.0
                    },
                    "GroupId": 2
                },
                {
                    "MapDataType": 1,
                    "ConfId": 1,
                    "Position": {
                        "x": 3.0,
                        "y": 0.0,
                        "z": 25.0
                    },
                    "Roation": {
                        "x": 0.0,
                        "y": 90.0,
                        "z": 0.0
                    },
                    "GroupId": 2
                },
                {
                    "MapDataType": 1,
                    "ConfId": 1,
                    "Position": {
                        "x": 5.0,
                        "y": 0.0,
                        "z": 23.0
                    },
                    "Roation": {
                        "x": 0.0,
                        "y": 90.0,
                        "z": 0.0
                    },
                    "GroupId": 2
                }
            ]
        }
    ],
    "ALlNoGroupMonsterMapDatas": [],
    "AllOtherMapDatas": []
}

上面的数据正对应我们导出填充的MapExport数据结构。

MapExport导出数据构建是通过GameMapEditorUtilities.GetMapExport()通过Map脚本获取所有相关数据去构建MapExport实现导出数据填充构建的。

Note:

因为静态地图对象是跟随预制件一起加载的，所以暂时没导出地图对象数据，有需要可以自行扩展支持动态地图对象导出和加载
扩展自定义配置数据需要自行扩展或继承MapObjectData或MapData和MapEditor.cs面板显示
扩展自定义导出数据需要自行扩展或继承BaseMapDataExportt定义
自定义地图埋点数据导出通过继承BaseMapDataExport定义

实战

新增地图埋点数据

以新增地图埋点类型MapDataType.Monster为例，怪物有两个DIY属性MonsterCreateRadius (怪物创建半径)和MonsterActiveRadius(怪物警戒半径)

新增地图埋点数据显示

增加地图埋点类型定义(MapDataType.cs)

/// <summary>
/// MapDataType.cs
/// 地图数据埋点类型枚举
/// </summary>
public enum MapDataType
{
    PlayerSpawn = 0,           // 玩家出生点位置数据
    Monster = 1,               // 怪物数据
}

新增地图埋点数据定义(MonsterMapData.cs)

using System;
using UnityEngine;

namespace MapEditor
{
    /// <summary>
    /// MonsterMapData.cs
    /// 怪物地图埋点数据
    /// </summary>
    [Serializable]
    public class MonsterMapData : MapData
    {
        /// <summary>
        /// 怪物创建半径
        /// </summary>
        [Header("怪物创建半径")]
        public float MonsterCreateRadius = 4;

        /// <summary>
        /// 怪物警戒半径
        /// </summary>
        [Header("怪物警戒半径")]
        public float MonsterActiveRadius = 3;

        public MonsterMapData(int uid) : base(uid)
        {

        }

        public MonsterMapData(int uid, Vector3 position, Vector3 rotation, float monsterCreateRadius, float monsterActiveRadius)
            : base(uid, position, rotation)
            {
                MonsterCreateRadius = monsterCreateRadius;
                MonsterActiveRadius = monsterActiveRadius;
            }

        /// <summary>
        /// 复制自定义数据
        /// </summary>
        /// <param name="sourceMapData"></param>
        /// <returns></returns>
        public override bool CopyCustomData(MapData sourceMapData)
        {
            if(!base.CopyCustomData(sourceMapData))
            {
                return false;
            }
            var realSourceMapData = sourceMapData as MonsterMapData;
            MonsterCreateRadius = realSourceMapData.MonsterCreateRadius;
            MonsterActiveRadius = realSourceMapData.MonsterActiveRadius;
            return true;
        }
    }
}

新增编辑器操作添加怪物地图埋点数据(MapUtilities.cs)

/// <summary>
/// 创建指定地图埋点数据类型，指定uid和指定位置的埋点数据
/// </summary>
/// <param name="mapDataType"></param>
/// <param name="uid"></param>
/// <param name="position"></param>
/// <param name="rotation"></param>
/// <param name="monsterCreateRadius"></param>
/// <param name="monsterActiveRadius"></param>
/// <returns></returns>
public static MapData CreateMapDataByType(MapDataType mapDataType, int uid, Vector3 position, Vector3 rotation, float monsterCreateRadius, float monsterActiveRadius)
{
    if (mapDataType == MapDataType.Monster)
    {
        return new MonsterMapData(uid, position, rotation, monsterCreateRadius, monsterActiveRadius);
    }
    else if (mapDataType == MapDataType.PlayerSpawn)
    {
        return new PlayerSpawnMapData(uid, position, rotation);
    }
    ******
    else
    {
        Debug.LogWarning($"地图埋点类型:{mapDataType}没有创建自定义类型数据，可能不方便未来扩展！");
        return new MapData(uid, position, rotation);
    }
}

新增怪物编辑器GUI显示数据定义(MapEditorUtilities.cs)

/// <summary>
/// 地图埋点类型UI类型显示数据列表
/// </summary>
private static readonly List<MapDataTypeDisplayData> MapDataTypeDisplayDatas = new List<MapDataTypeDisplayData>()
{
    new MapDataTypeDisplayData(MapDataType.PlayerSpawn, MapFoldType.PlayerSpawnMapDataFold, "玩家出生点", Color.yellow),
    new MapDataTypeDisplayData(MapDataType.Monster, MapFoldType.MonsterMapDataFold, "怪物", Color.magenta),
    ******
};

新增怪物自定义数据UI显示数据定义(MapUIType.cs)

  /// <summary>
  /// MapUIType.cs
  /// 地图数据UI类型
  /// </summary>
  public enum MapUIType
  {
*******
      MonsterCreateRadius = 12,               // 怪物创建半径UI
      MonsterActiveRadius = 13,               // 怪物警戒半径UI
  }

新增怪物自定义类型数据UI显示相关数据定义(MapEditorUtilities.cs)

/// <summary>
/// 地图埋点类型和UI显示类型Map<地图埋点类型，<地图UI显示类型，是否显示>>
/// Note:
/// 所有需要显示的折叠数据都在这里定义相关UI是否显示
/// 通用必显示的不同定义在这里，详情参见CommonGameMapUITypeMap
/// 所有MapDataType类型必定会自动初始化到MapFoldAndUITypeMap，没有DIY UI显示的可以不定义在这
/// </summary>
private static Dictionary<MapDataType, Dictionary<MapUIType, bool>> MapFoldAndUITypeMap = new Dictionary<MapDataType, Dictionary<MapUIType, bool>>()
{
    {
        MapDataType.Monster, new Dictionary<MapUIType, bool>()
        {
            {MapUIType.MonsterCreateRadius, true},
            {MapUIType.MonsterActiveRadius, true},
        }
    },
};

/// <summary>
/// 地图UI类型显示数据列表
/// Note:
/// 标题和属性默认按照这里定义的顺序显示
/// </summary>
public static readonly List<MapUITypeDisplayData> MapUITypeDisplayData = new List<MapUITypeDisplayData>()
{
    ******
        new MapUITypeDisplayData(MapUIType.MonsterCreateRadius, "MonsterCreateRadius", "创建半径", MapEditorConst.InspectorDataMonsterCreateRadiusUIWidth, MapStyles.TabMiddleStyle),
    new MapUITypeDisplayData(MapUIType.MonsterActiveRadius, "MonsterActiveRadius", "警戒半径", MapEditorConst.InspectorDataMonsterActiveRediusUIWidth, MapStyles.TabMiddleStyle),
    ******
};

新增属性GUI显示代码(MapEditor.cs)

/// <summary>
/// 绘制单个地图埋点属性，索引，地图埋点类型和现实数据的数据
/// </summary>
/// <param name="mapDataProperty"></param>
/// <param name="mapDataIndex"></param>
/// <param name="mapDataType"></param>
/// <param name="mapUITypeDisplayData"></param>
private void DrawOneMapDataPropertyByData(SerializedProperty mapDataProperty, int mapDataIndex, MapDataType mapDataType, MapUITypeDisplayData mapUITypeDisplayData)
{
    ******
    else if (mapUIType == MapUIType.MonsterCreateRadius)
    {
        DrawFloatChangeMapDataProperty(mapDataIndex, property, propertyName, MapEditorConst.InspectorDataMonsterCreateRadiusUIWidth);
    }
    else if (mapUIType == MapUIType.MonsterActiveRadius)
    {
        DrawFloatChangeMapDataProperty(mapDataIndex, property, propertyName, MapEditorConst.InspectorDataMonsterActiveRediusUIWidth);
    }
    ******
}

至此我们成功添加了自定义埋点数据类型和DIY数据显示，接下来就是数据导出。

MonsterMapDataUIOperation

Note:

公共UI类型是否显示定义在MapEditorUtilities.CommonMapUITypeMap里，自定义UI类型是否显示定义在MapEditorUtilities.MapFoldAndUITypeMap里

新增地图埋点数据导出

新增怪物导出数据定义(MonsterMapDataExport.cs)

/// <summary>
/// MonsterMapDataExport.cs
/// 怪物地图埋点数据导出
/// </summary>
[Serializable]
public class MonsterMapDataExport : BaseMapDataExport
{
    /// <summary>
    /// 怪物创建半径
    /// </summary>
    public float MonsterCreateRadius;

    /// <summary>
    /// 怪物警戒半径
    /// </summary>
    public float MonsterActiveRadius;

    public MonsterMapDataExport(MapDataType mapDataType, int confId, Vector3 position,  Vector3 rotation, float monsterCreateRadius, float monsterActiveRadius)
        : base(mapDataType, confId, position, rotation)
        {
            MonsterCreateRadius = monsterCreateRadius;
            MonsterActiveRadius = monsterActiveRadius;
        }
}

导出数据添加怪物导出数据定义(MapExport.cs)

/// <summary>
/// MapExport.cs
/// 地图导出数据结构定义(统一导出结构定义，方便支持导出不同的数据格式)
/// </summary>
[Serializable]
public class MapExport
{
    ******
    
    /// <summary>
    /// 所有怪物导出数据列表
    /// </summary>
    public List<MonsterMapDataExport> ALlMonsterMapDatas = new List<MonsterMapDataExport>();
    
    ******
}

构建导出数据并填充到怪物导出数据列表里(MapExportEditorUtilities.cs)

/// <summary>
/// 指定地图埋点数据列表更新地图导出数据
/// </summary>
/// <param name="mapExport"></param>
/// <param name="map"></param>
private static void UpdateMapExportByMapDatas(MapExport mapExport, Map map)
{
    if(map?.MapDataList == null)
    {
        return;
    }
    var mapDatas = map.MapDataList;
    var mapDataTypeDatasMap = GetMapDataTypeDatas(mapDatas);
    ******
        List<MapData> monsterDatas;
    if (mapDataTypeDatasMap.TryGetValue(MapDataType.Monster, out monsterDatas))
    {
        foreach (var monsterData in monsterDatas)
        {
            var monsterMapDataExport = GetMonsterMapDataExport(monsterData);
            mapExport.ALlMonsterMapDatas.Add(monsterMapDataExport);
        }
    }
    ******
}

/// <summary>
/// 获取指定地图埋点数据的地图埋点怪物导出数据
/// </summary>
/// <param name="mapData"></param>
/// <returns></returns>
private static MonsterMapDataExport GetMonsterMapDataExport(MapData mapData)
{
    if (mapData == null)
    {
        Debug.LogError("不允许获取空地图埋点数据的地图埋点怪物导出数据失败！");
        return null;
    }
    var mapDataUID = mapData.UID;
    var mapDataConfig = MapSetting.GetEditorInstance().DataSetting.GetMapDataConfigByUID(mapDataUID);
    if (mapDataConfig == null)
    {
        Debug.LogError($"找不到地图埋点UID:{mapDataUID}的配置，获取地图埋点怪物导出数据失败！");
        return null;
    }
    var monsterMapData = mapData as MonsterMapData;
    var monsterCreateRadius = monsterMapData.MonsterCreateRadius;
    var monsterActiveRadius = monsterMapData.MonsterActiveRadius;
    return new MonsterMapDataExport(mapDataConfig.DataType, mapDataConfig.ConfId, mapData.Position, mapData.Rotation, monsterCreateRadius, monsterActiveRadius);
}

然后MapExport导出时，数据就会序列化到Json:

{
    "MapData": {
     "Width": 8,
        "Height": 40,
        "StartPos": {
            "x": 0.0,
            "y": 0.0,
            "z": 0.0
        },
        "BirthPos": [
            {
                "x": 3.0,
                "y": 0.0,
                "z": 3.0
            }
        ],
        "GameVirtualCameraInitPos": {
            "x": 3.0,
            "y": 15.0,
            "z": -10.0
        },
        "GridSize": 0.0
    },
    "ALlMonsterMapDatas": [
        {
            "MapDataType": 1,
            "ConfId": 1,
            "Position": {
                "x": 3.0,
                "y": 0.0,
                "z": 15.0
            },
            "Roation": {
                "x": 0.0,
                "y": 0.0,
                "z": 0.0
            },
            "MonsterCreateRadius": 8.0,
            "MonsterActiveRadius": 5.0
        },
        {
            "MapDataType": 1,
            "ConfId": 2,
            "Position": {
                "x": 3.0,
                "y": 0.0,
                "z": 20.0
            },
            "Roation": {
                "x": 0.0,
                "y": 0.0,
                "z": 0.0
            },
            "MonsterCreateRadius": 8.0,
            "MonsterActiveRadius": 5.0
        }
    ],
    ******
}

新增地图埋点数据读取

完成埋点数据导出后，接下来就是数据读取(MapGameManager.cs)

/// <summary>
/// 加载关卡配置
/// </summary>
private void LoadLevelConfig()
{
    var levelTxtAsset = Resources.Load<TextAsset>(MapGameConst.LevelConfigPath);
    if (levelTxtAsset == null)
    {
        Debug.LogError($"关卡配置:{MapGameConst.LevelConfigPath}加载失败！");
    }
    else
    {
        LevelConfig = JsonUtility.FromJson<MapExport>(levelTxtAsset.text);
    }
    ******
}

最后通过MapGameManager.Singleton.LevelConfig.ALlMonsterMapDatas即可访问导出的怪物埋点数据了。

摄像机可见范围可视化

摄像机的可见范围计算原理：

不考虑摄像机是正交还是透视，通过将屏幕四个角映射到世界坐标系(屏幕坐标到世界坐标)，得到从摄像机到摄像机四个角的射线数据。

/// <summary>
/// 四个角的视口坐标
/// </summary>
private static Vector3[] ViewPortPoints = new Vector3[5]
{
    new Vector3(0, 0, 0),        // 左下角
    new Vector3(0, 1, 0),        // 左上角
    new Vector3(1, 1, 0),        // 右上角
    new Vector3(1, 0, 0),        // 右下角
    new Vector3(0.5f, 0.5f, 0),  // 中心
};

/// <summary>
/// 获取指定摄像机的射线数据列表
/// </summary>
/// <param name="camera"></param>
/// <param name="rayCastDataList"></param>
/// <returns></returns>
public static bool GetCameraRayCastDataList(Camera camera, ref List<KeyValuePair<Vector3, Vector3>> rayCastDataList)
{
    rayCastDataList.Clear();
    if(camera == null)
    {
        Debug.LogError($"不允许传递空摄像机组件，获取摄像机的射线数据列表失败！");
        return false;
    }

    var cameraNearClipPlane = camera.nearClipPlane;
    ViewPortPoints[0].z = cameraNearClipPlane;
    ViewPortPoints[1].z = cameraNearClipPlane;
    ViewPortPoints[2].z = cameraNearClipPlane;
    ViewPortPoints[3].z = cameraNearClipPlane;
    ViewPortPoints[4].z = cameraNearClipPlane;

    var isOrthographic = camera.orthographic;
    if(isOrthographic)
    {
        // 转换为射线
        for (int i = 0; i < ViewPortPoints.Length; i++)
        {
            Ray ray = camera.ViewportPointToRay(ViewPortPoints[i]);
            var rayCastToPoint = ray.origin + ray.direction * camera.farClipPlane;
            var rayCastData = new KeyValuePair<Vector3, Vector3>(ray.origin, rayCastToPoint);
            rayCastDataList.Add(rayCastData);
        }
    }
    else
    {
        var radio = camera.farClipPlane / cameraNearClipPlane;
        var cameraPosition = camera.transform.position;

        // 获取饰扣四个角的屏幕映射世界坐标
        var lbNearPlaneWorldPoints = camera.ViewportToWorldPoint(ViewPortPoints[0]);
        var ltNearPlaneWorldPoints = camera.ViewportToWorldPoint(ViewPortPoints[1]);
        var rtNearPlaneWorldPoints = camera.ViewportToWorldPoint(ViewPortPoints[2]);
        var rbNearPlaneWorldPoints = camera.ViewportToWorldPoint(ViewPortPoints[3]);
        var ctNearPlaneWorldPoints = camera.ViewportToWorldPoint(ViewPortPoints[4]);

        var lbNearPlaneCameraWorldPointDir = lbNearPlaneWorldPoints - cameraPosition;
        var ltNearPlaneCameraWorldPointDir = ltNearPlaneWorldPoints - cameraPosition;
        var rtNearPlaneCameraWorldPointDir = rtNearPlaneWorldPoints - cameraPosition;
        var rbNearPlaneCameraWorldPointDir = rbNearPlaneWorldPoints - cameraPosition;
        var ctNearPlaneCameraWorldPointDir = ctNearPlaneWorldPoints - cameraPosition;

        var lbFarPlaneWorldPoint = cameraPosition + lbNearPlaneCameraWorldPointDir * radio;
        var ltFarPlaneWorldPoint = cameraPosition + ltNearPlaneCameraWorldPointDir * radio;
        var rtFarPlaneWorldPoint = cameraPosition + rtNearPlaneCameraWorldPointDir * radio;
        var rbFarPlaneWorldPoint = cameraPosition + rbNearPlaneCameraWorldPointDir * radio;
        var ctFarPlaneWorldPoint = cameraPosition + ctNearPlaneCameraWorldPointDir * radio;

        var lbRayCastData = new KeyValuePair<Vector3, Vector3>(lbNearPlaneWorldPoints, lbFarPlaneWorldPoint);
        var ltRayCastData = new KeyValuePair<Vector3, Vector3>(ltNearPlaneWorldPoints, ltFarPlaneWorldPoint);
        var rtRayCastData = new KeyValuePair<Vector3, Vector3>(rtNearPlaneWorldPoints, rtFarPlaneWorldPoint);
        var rbRayCastData = new KeyValuePair<Vector3, Vector3>(rbNearPlaneWorldPoints, rbFarPlaneWorldPoint);        
        var ctRayCastData = new KeyValuePair<Vector3, Vector3>(ctNearPlaneWorldPoints, ctFarPlaneWorldPoint);        
        rayCastDataList.Add(lbRayCastData);
        rayCastDataList.Add(ltRayCastData);
        rayCastDataList.Add(rtRayCastData);
        rayCastDataList.Add(rbRayCastData);
        rayCastDataList.Add(ctRayCastData);
    }
    return true;
}

得到屏幕四个角映射的射线数据后，利用射线和平面的交叉计算得到指定平面交叉的点就能得到我们要的平面照射区域

/// <summary>
/// Vector3Utilities.cs
/// Vector3静态工具类
/// </summary>
public static class Vector3Utilities
{
    /// <summary>
    /// 获取指定射线和平面数据的交叉点(返回null表示没有交叉点)
    /// </summary>
    /// <param name="rayOrigin"></param>
    /// <param name="rayDirection"></param>
    /// <param name="planePoint"></param>
    /// <param name="planeNormal"></param>
    /// <returns></returns>
    public static Vector3? GetRayAndPlaneIntersect(Vector3 rayOrigin, Vector3 rayDirection, Vector3 planePoint, Vector3 planeNormal)
    {
        // 计算法向量和方向向量的点积
        float ndotu = Vector3.Dot(planeNormal, rayDirection);

        // 向量几乎平行，可能没有交点或者射线在平面内
        if (Mathf.Approximately(Math.Abs(ndotu), Mathf.Epsilon))
        {
            return null;
        }

        // 计算 t
        Vector3 w = rayOrigin - planePoint;
        float t = -Vector3.Dot(planeNormal, w) / ndotu;

        // 交点在射线起点的后面
        if (t < 0)
        {
            return null;
        }

        // 计算交点
        Vector3 intersectionPoint = rayOrigin + t * rayDirection;
        return intersectionPoint;
    }
}

/// <summary>
/// 获取指定摄像机指定区域顶点和法线的的可视区域顶点数据
/// </summary>
/// <param name="camera"></param>
/// <param name="areaPoint"></param>
/// <param name="areaNormal"></param>
/// <param name="areaPointsList"></param>
/// <param name="rectPointList"></param>
/// <returns></returns>
public static bool GetCameraVisibleArea(Camera camera, Vector3 areaPoint, Vector3 areaNormal, ref List<Vector3> areaPointsList, ref List<Vector3> rectPointList)
{
    areaPointsList.Clear();
    rectPointList.Clear();
    if (camera == null)
    {
        Debug.LogError($"不允许传递空摄像机组件，获取摄像机的可视区域顶点数据失败！");
        return false;
    }

    RayCastDataList.Clear();
    GetCameraRayCastDataList(camera, ref RayCastDataList);
    foreach(var rayCastData in RayCastDataList)
    {
        var rayCastDirection = rayCastData.Value - rayCastData.Key;
        var areaData = Vector3Utilities.GetRayAndPlaneIntersect(rayCastData.Key, rayCastDirection, areaPoint, areaNormal);
        if(areaData != null)
        {
            areaPointsList.Add((Vector3)areaData);
        }
    }

    rectPointList.Add(new Vector3(areaPointsList[1].x, areaPointsList[0].y, areaPointsList[0].z));
    rectPointList.Add(new Vector3(areaPointsList[1].x, areaPointsList[1].y, areaPointsList[1].z));
    rectPointList.Add(new Vector3(areaPointsList[2].x, areaPointsList[2].y, areaPointsList[2].z));
    rectPointList.Add(new Vector3(areaPointsList[2].x, areaPointsList[3].y, areaPointsList[3].z));
    rectPointList.Add(areaPointsList[4]);
    return true;
}

从上面可以看到无论是areaPointsList还是rectPointList都返回了5个顶点数据，第五个是屏幕中心映射的点。

之所以返回矩形的映射区域，是为了简化后面透视摄像机梯形判定顶点复杂度，简化成AABB和点的交叉判定。

得到了屏幕映射的顶点数据，通过构建线条数据，我们就能利用GUI相关接口画出可视化可见区域了

/// <summary>
/// 区域顶点
/// </summary>
[Header("区域顶点")]
public Vector3 AreaPoint = Vector3.zero;

/// <summary>
/// 区域法线
/// </summary>
[Header("区域法线")]
public Vector3 AreaNormal = Vector3.up;

/// <summary>
/// 更新摄像机指定平面映射区域数据
/// </summary>
public void UpdateAreaDatas()
{
    CameraUtilities.GetCameraRayCastDataList(mCameraComponent, ref mRayCastDataList);
    CameraUtilities.GetCameraVisibleArea(mCameraComponent, AreaPoint, AreaNormal, ref mAreaPointsList, ref mRectAreaPointsList);
    mAreaLinesList.Clear();
    mRectAreaLinesList.Clear();
    if(mAreaPointsList.Count > 0)
    {
        var lbToLtLine = new KeyValuePair<Vector3, Vector3>(mAreaPointsList[0], mAreaPointsList[1]);
        var ltToRtLine = new KeyValuePair<Vector3, Vector3>(mAreaPointsList[1], mAreaPointsList[2]);
        var rtToRbLine = new KeyValuePair<Vector3, Vector3>(mAreaPointsList[2], mAreaPointsList[3]);
        var rbToLbLine = new KeyValuePair<Vector3, Vector3>(mAreaPointsList[3], mAreaPointsList[0]);
        mAreaLinesList.Add(lbToLtLine);
        mAreaLinesList.Add(ltToRtLine);
        mAreaLinesList.Add(rtToRbLine);
        mAreaLinesList.Add(rbToLbLine);

        var rectLbToLtLine = new KeyValuePair<Vector3, Vector3>(mRectAreaPointsList[0], mRectAreaPointsList[1]);
        var rectLtToRtLine = new KeyValuePair<Vector3, Vector3>(mRectAreaPointsList[1], mRectAreaPointsList[2]);
        var rectRtToRbLine = new KeyValuePair<Vector3, Vector3>(mRectAreaPointsList[2], mRectAreaPointsList[3]);
        var rectRbToLbLine = new KeyValuePair<Vector3, Vector3>(mRectAreaPointsList[3], mRectAreaPointsList[0]);
        mRectAreaLinesList.Add(rectLbToLtLine);
        mRectAreaLinesList.Add(rectLtToRtLine);
        mRectAreaLinesList.Add(rectRtToRbLine);
        mRectAreaLinesList.Add(rectRbToLbLine);
    }
}

/// <summary>
/// 绘制区域信息Gizmos
/// </summary>
private void DrawAreaInfoGUI()
{
    var preGizmosColor = Gizmos.color;
    Gizmos.color = Color.green;
    Gizmos.DrawSphere(AreaPoint, SphereSize);
    var areaPointTo = AreaPoint + AreaNormal * 5;
    Gizmos.DrawLine(AreaPoint, areaPointTo);
    Gizmos.color = preGizmosColor;
}

/// <summary>
/// 绘制矩形区域
/// </summary>
private void DrawRectAreaGUI()
{
    var preGizmosColor = Gizmos.color;
    Gizmos.color = new Color(0, 0.5f, 0);
    if(mRectAreaLinesList.Count > 0)
    {
        Gizmos.DrawLine(mRectAreaLinesList[0].Key, mRectAreaLinesList[0].Value);
        Gizmos.DrawLine(mRectAreaLinesList[1].Key, mRectAreaLinesList[1].Value);
        Gizmos.DrawLine(mRectAreaLinesList[2].Key, mRectAreaLinesList[2].Value);
        Gizmos.DrawLine(mRectAreaLinesList[3].Key, mRectAreaLinesList[3].Value);
    }
    Gizmos.color = preGizmosColor;
}

/// <summary>
/// 绘制区域Gizmos
/// </summary>
private void DrawAreaGUI()
{
    var preGizmosColor = Gizmos.color;
    Gizmos.color = Color.green;
    if(mAreaLinesList.Count > 0)
    {
        Gizmos.DrawLine(mAreaLinesList[0].Key, mAreaLinesList[0].Value);
        Gizmos.DrawLine(mAreaLinesList[1].Key, mAreaLinesList[1].Value);
        Gizmos.DrawLine(mAreaLinesList[2].Key, mAreaLinesList[2].Value);
        Gizmos.DrawLine(mAreaLinesList[3].Key, mAreaLinesList[3].Value);
    }
    if(mAreaPointsList.Count > 0)
    {
        Gizmos.DrawSphere(mAreaPointsList[4], SphereSize);
    }
    Gizmos.color = preGizmosColor;
}

摄像机照射区域可视化：

可以看到黄色是远截面照射区域，深绿色是近截面照射区域，浅绿色是摄像机近截面换算成矩形后的区域，红色线条是摄像机近截面和远截面射线，

Note:

屏幕4个顶点计算顺序依次是左下，左上，右上，右下

摄像机可见范围动态创建和销毁

前面我们已经成功得到了摄像机照射范围映射到指定平面映射顶点数据，接下来就是通过埋点对象数据的位置结合摄像机映射数据，通过判定AABB和点的交互决定指定地图埋点数据是否可见，从而决定是否创建或移除相关地图埋点数据的对象数据。

/// <summary>
/// 2D AABB定义
/// </summary>
[Serializable]
public struct AABB2D
{
    /// <summary>
    /// 中心点位置
    /// </summary>
    [Header("中心点位置")]
    public Vector2 Center;

    /// <summary>
    /// 宽和高
    /// </summary>
    [Header("宽和高")]
    public Vector2 Extents;

    public AABB2D(Vector2 center, Vector2 extents)
    {
        Center = center;
        Extents = extents;
    }
}

/// <summary>
/// MapGameConst.cs
/// 游戏常量
/// </summary>
public static class MapGameConst
{
    *******
    
    /// <summary>
    /// 区域顶点
    /// </summary>
    public static readonly Vector3 AreaPoint = Vector3.zero;

    /// <summary>
    /// 区域法线
    /// </summary>
    public static readonly Vector3 AreaNormal = Vector3.up;
}

/// <summary>
/// MapObjectEntitySpawnSystem.cs
/// 地图对象Entity生成系统
/// </summary>
public class MapObjectEntitySpawnSystem : BaseSystem
{
    /// <summary>
    /// 摄像机指定平面映射区域顶点数据列表
    /// </summary>
    private List<Vector3> mAreaPointsList = new List<Vector3>();

    /// <summary>
    /// 摄像机指定平面映射矩形区域顶点数据列表
    /// </summary>
    private List<Vector3> mRectAreaPointsList = new List<Vector3>();

    /// <summary>
    /// 已生成的BaseMapDataExport数据和对应Entity Uuid Map
    /// </summary>
    private Dictionary<BaseMapDataExport, int> mSpawnedMapDataEntityMap = new Dictionary<BaseMapDataExport, int>();

    /// <summary>
    /// 临时需要移除的地图埋点导出数据列表
    /// </summary>
    private List<BaseMapDataExport> mTempRemoveSpawnedMapDataExportList = new List<BaseMapDataExport>();

    /// <summary>
    /// 摄像机矩形区域
    /// </summary>
    private AABB2D mCameraRectArea = new AABB2D();

    /// <summary>
    /// 地图埋点临时Vector2位置数据
    /// </summary>
    private Vector2 mTempMapDataExportPos = new Vector2();

    /// <summary>
    /// 指定MapDataExport数据是否已生成Entity
    /// </summary>
    /// <param name="mapDataExport"></param>
    /// <returns></returns>
    private bool IsMapDataSpawned(BaseMapDataExport mapDataExport)
    {
        return mSpawnedMapDataEntityMap.ContainsKey(mapDataExport);
    }

    /// <summary>
    /// 添加指定地图埋点数据和对应生成Entity Uuid
    /// </summary>
    /// <param name="mapDataExport"></param>
    /// <param name="uuid"></param>
    /// <returns></returns>
    private bool AddMapDataSpawnedEntityUuid(BaseMapDataExport mapDataExport, int uuid)
    {
        if(IsMapDataSpawned(mapDataExport))
        {
            Debug.LogError($"MapDataExport.MapDataType:{mapDataExport.MapDataType},MapDataExport.ConfId:{mapDataExport.ConfId}已生成Entity，添加生成Entity Uuid:{uuid}失败！");
            return false;
        }
        mSpawnedMapDataEntityMap.Add(mapDataExport, uuid);
        Debug.Log($"添加MapDataExport.MapDataType:{mapDataExport.MapDataType},MapDataExport.ConfId:{mapDataExport.ConfId}的生成Entity Uuid:{uuid}成功！");
        return true;
    }

    /// <summary>
    /// 移除指定地图埋点数据的Entity生成数据
    /// </summary>
    /// <param name="mapDataExport"></param>
    /// <returns></returns>
    private bool RemoveMapDataSpawned(BaseMapDataExport mapDataExport)
    {
        int uuid;
        if(mSpawnedMapDataEntityMap.TryGetValue(mapDataExport, out uuid))
        {
            mSpawnedMapDataEntityMap.Remove(mapDataExport);
            Debug.Log($"移除MapDataExport.MapDataType:{mapDataExport.MapDataType},MapDataExport.ConfId:{mapDataExport.ConfId}的生成Entity Uuid:{uuid}成功！");
            return true;
        }
        Debug.LogError($"MapDataExport.MapDataType:{mapDataExport.MapDataType},MapDataExport.ConfId:{mapDataExport.ConfId}未生成对应Entity，移除Entity Uuid:{uuid}失败！");
        return false;
    }

    /// <summary>
    /// Entity过滤
    /// </summary>
    /// <param name="entity"></param>
    /// <returns></returns>
    public override bool Filter(BaseEntity entity)
    {
        var entityType = entity.EntityType;
        return entityType == EntityType.Camera;
    }

    /// <summary>
    /// Entity处理
    /// </summary>
    /// <param name="entity"></param>
    /// <param name="deltaTime"></param>
    public override void Process(BaseEntity entity, float deltaTime)
    {
        base.Process(entity, deltaTime);
        var cameraEntity = entity as CameraEntity;
        if(!cameraEntity.SyncPosition)
        {
            return;
        }
        UpdateCameraDatas();
        CheckAllMapDataExportEntitySpawn();
        CheckAllSpawnEntityRemove();
    }

    /// <summary>
    /// 更新摄像机数据
    /// </summary>
    private void UpdateCameraDatas()
    {
        var mainCamera = MapGameManager.Singleton.MainCamera;
        CameraUtilities.GetCameraVisibleArea(mainCamera, MapGameConst.AreaPoint, MapGameConst.AreaNormal, ref mAreaPointsList, ref mRectAreaPointsList);

        var minX = Math.Min(mRectAreaPointsList[0].x, mRectAreaPointsList[1].x);
        var maxX = Math.Max(mRectAreaPointsList[2].x, mRectAreaPointsList[3].x);
        var minZ = Math.Min(mRectAreaPointsList[0].z, mRectAreaPointsList[3].z);
        var maxZ = Math.Max(mRectAreaPointsList[1].z, mRectAreaPointsList[2].z);
        var width = maxX - minX;
        var height = maxZ - minZ;
        var centerX = mRectAreaPointsList[1].X + width / 2;
        var centerZ = mRectAreaPointsList[0].Z + height / 2;
        mCameraRectArea.Center.x = centerX;
        mCameraRectArea.Center.y = centerZ;
        mCameraRectArea.Extents.x = width;
        mCameraRectArea.Extents.y = height;
    }

    /// <summary>
    /// 检查地图埋点导出数据Entity生成
    /// </summary>
    private void CheckAllMapDataExportEntitySpawn()
    {
        var allMonsterMapDatas = MapGameManager.Singleton.LevelConfig.ALlMonsterMapDatas;
        var allTreasureBoxMapDatas = MapGameManager.Singleton.LevelConfig.AllTreasureBoxMapDatas;
        var allTrapMapDatas = MapGameManager.Singleton.LevelConfig.AllTrapMapDatas;
        foreach (var monsterMapDataExport in allMonsterMapDatas)
        {
            CheckAllMapDataExportEntitySpawn(monsterMapDataExport);
        }
        foreach (var treasureBoxMapDataExport in allTreasureBoxMapDatas)
        {
            CheckAllMapDataExportEntitySpawn(treasureBoxMapDataExport);
        }
        foreach (var trapMapDataExport in allTrapMapDatas)
        {
            CheckAllMapDataExportEntitySpawn(trapMapDataExport);
        }
    }

    /// <summary>
    /// 检查指定地图埋点导出数据Entity生成
    /// </summary>
    /// <param name="mapDataExport"></param>
    private void CheckAllMapDataExportEntitySpawn(BaseMapDataExport mapDataExport)
    {
        if(IsMapDataSpawned(mapDataExport))
        {
            return;
        }
        var mapDataExportPosition = mapDataExport.Position;
        mTempMapDataExportPos.x = mapDataExportPosition.x;
        mTempMapDataExportPos.y = mapDataExportPosition.z;
        if(Collision2DUtilities.PointInAABB(mCameraRectArea, mTempMapDataExportPos))
        {
            BaseEntity entity = null;
            var position = mapDataExport.Position;
            if(mapDataExport is MonsterMapDataExport)
            {
                var monsterEntity = OwnerWorld.CreateEtity<MonsterEntity>(MapGameConst.MonsterPrefabPath);
                entity = monsterEntity;
                monsterEntity.SetPosition(position.x, position.y, position.z);
            }
            else if(mapDataExport is TreasureBoxMapDataExport)
            {
                var treasureEntity = OwnerWorld.CreateEtity<TreasureBoxEntity>(MapGameConst.TreasureBoxPrefabPath);
                entity = treasureEntity;
                treasureEntity.SetPosition(position.x, position.y, position.z);
            }
            else if(mapDataExport is TrapMapDataExport)
            {
                var trapEntity = OwnerWorld.CreateEtity<TrapEntity>(MapGameConst.TrapPrefabPath);
                entity = trapEntity;
                trapEntity.SetPosition(position.x, position.y, position.z);
            }
            else
            {
                Debug.LogError($"不支持的MapDataExport类型:{mapDataExport.GetType().Name},检测MapDataEntity创建失败！");
            }
            if(entity != null)
            {
                AddMapDataSpawnedEntityUuid(mapDataExport, entity.Uuid);
            }
        }
    }

    /// <summary>
    /// 检查已经生成的Entity回收
    /// </summary>
    private void CheckAllSpawnEntityRemove()
    {
        mTempRemoveSpawnedMapDataExportList.Clear();
        foreach(var spawnedMapDataEntity in mSpawnedMapDataEntityMap)
        {
            var entityUuid = spawnedMapDataEntity.Value;
            var actorEntity = OwnerWorld.GetEntityByUuid<BaseActorEntity>(entityUuid);
            if (actorEntity == null)
            {
                continue;
            }
            var entityPosition = actorEntity.Position;
            mTempMapDataExportPos.x = entityPosition.x;
            mTempMapDataExportPos.y = entityPosition.z;
            if(!Collision2DUtilities.PointInAABB(mCameraRectArea, mTempMapDataExportPos))
            {
                mTempRemoveSpawnedMapDataExportList.Add(spawnedMapDataEntity.Key);
                OwnerWorld.DestroyEntityByUuid(entityUuid);
            }
        }
        foreach(var removeSpawnMapDataExport in mTempRemoveSpawnedMapDataExportList)
        {
            RemoveMapDataSpawned(removeSpawnMapDataExport);
        }
    }
}

上面的代码已经成功检测到地图埋点位置在可视域就创建，不在可视域就销毁的逻辑。

从截图可以看到近处的两个红色怪物埋点因为超出了摄像机区域后被销毁了，而远处两个宝箱和陷阱因为进入摄像机照射区域而创建显示了。

学习总结

EditorWindow配置编辑器基础可配置数据，Inspector面板提供地图编辑器操作入口和数据序列化存储
地图对象通过序列化位置+旋转+碰撞等数据可以实现场景编辑后一键更新所有场景对象效果
地图对象数据存储可以挂在Mono脚本或自定义数据导出实现场景对象相关配置数据存储和导出
数据埋点显示和操作通过Gizmo和Handles可以实现自己设计的操作交互和显示
摄像机可视域的计算和判定基本上就是数学上的运算

Github

MapEditor

Reference

碰撞检测

UnityEditor知识

UIToolkit

By Tony Tang

发表于 2023-05-20

Introduction

之前有一篇学习Unity Editor相关的知识:UnityEditor知识

UIToolkit作为Unity最新一代UI系统，这里准备单独用篇来学习记录，通过深入学习UIToolkit，为后续编写一套节点系统做准备(用于AI系统，剧情系统和引导系统实现)。

Note:

本章节重点是UIToolkit在Editor上的学习使用，Runtime目前看来UIToolkit还不够成熟，不适合用到Runtime(2023/5/20)

UIToolkit

UI Toolkit is the newest UI system in Unity. It’s designed to optimize performance across platforms, and is based on standard web technologies. You can use UI Toolkit to create extensions for the Unity Editor, and to create runtime UI for games and applications (when you install the UI Toolkit package.

看官方介绍可以看出，UI Toolkit是官方推的新一代UI系统，基于Web技术概念的一套UI系统，可用于Editor和运行时通吃。

UI Toolkit由三大部分组成:

UI system(Contains the core features and functionality required to create user interfaces.)
UI Assets(Asset types inspired by standard web formats. Use them to structure and style UI.)(个人理解类似UI布局文件Asset)
Tools and resources(Create and debug your interfaces, and learn how to use UI toolkit.)

UI system

UI系统由以下部分组成:

Visual tree(Defines every user interface you build with the UI Toolkit. A visual tree is an object graph, made of lightweight nodes, that holds all the elements in a window or panel.)(定义UI界面的数据，包含了所有组成UI显示的成员节点信息)
Controls(A library of standard UI controls such as buttons, popups, list views, and color pickers. You can use them as-is, customize them, or create your own controls.)(UI组件)
Data binding system(Links properties to the controls that modify their values.)(关联数据属性到UI组件)
Layout Engine(A layout system based on the CSS Flexbox model. It positions elements based on layout and styling properties.)(类似CSS的UI布局系统)
Event System(Communicates user interactions to elements; for example, input, touch and pointer interactions, drag and drop operations, and other event types. The system includes a dispatcher, a handler, a synthesizer, and a library of event types.)(UI事件系统，负责事件的分发等)
UI Renderer(A rendering system built directly on top of Unity’s graphics device layer.)(在Unity基础上设计的UI渲染系统)
UI Toolkit Runtime Support(Contains the components required to create runtime UI. The UI Toolkit package is currently in preview.)

Visual tree

Visual tree由VisualElement组成，VisualElement是所有UI Toolkit的节点基类，VisualElment包含了所有UI组件，排版，UI风格，UI事件处理等数据信息。

UI元素绘制顺序树广度扩展:

UIToolkit里的坐标系分为两种：

Relative(position: relative相对坐标系)
Absolute(position: absolute绝对坐标系)

上面两个坐标系和Unity里的相对位置和世界位置的概念差不多。

Note:

坐标原点在左上角
VisualElementExtensions的扩展方法里提供了坐标系转换相关的方法和接口

Layout Engine

UI Toolkit includes a layout engine that positions visual elements based on layout and styling properties.(UI Toolkit的排版系统是基于VisualElement的排版和Styling属性设置决定的)

UXML format

Unity Extensible Markup Language (UXML) files are text files that define the structure of the user interface. (Unity支持用UXML来描述UI界面组件数据)

可以使用UI Builder实现可视化布局编辑。

UXML通过代码动态创建的数据对象类为VisualElementAssets。

UXML现有可用Element查询

UXML布局构建事例

深入使用，待学习……

Note:

You can’t generate a VisualTreeAsset from raw UXML at runtime.

Uity style sheets(USS)

Style properties are either set in C# or from a style sheet. Style properties have their own data structure (IStyle interface). UI Toolkit supports style sheets written in USS (Unity style sheet).(Unity支持定义类似CSS的USS文件来定义UI界面使用的Style属性设置)

USS通过代码动态创建的数据对象类为StyleSheet

USS包含以下部分:

Style rules that include a selector and a declaration block.(个人理解Style定义包含选择器和内容定义)
Selectors that identify which visual element the style rule affects.(选择器用于匹配Element的Style使用)
A declaration block, inside curly braces, that has one or more style declarations. Each style declaration has a property and a value. Each style declaration ends with a semi-colon.(内容定义Style的详细配置)

USS Selector

Style选择器分有很多种，简单的选择器有:

Type selector

type selectors match elements based on their element types.(通过类型名字匹配)

Button {
  border-radius: 8px;
  width: 100px;
  }

1	<Button name="Cancel" text="Cancel" />

Note:

type selector的名字不允许包含命名空间

Class selector

class selectors match elements that have specific USS classes assigned. (通过定义类名匹配)

1
2
3

.yellow {
    background-color: yellow;
}

1	<Button name="OK" class="yellow" text="OK" />

Note:

calss selector大小写敏感且不允许带数字

Name selector

name selectors match elements based on the name of an element.(通过名字匹配)

#Cancel {
    border-width: 2px;
    border-color: DarkRed;
    background-color: pink;
}

1	<Button name="Cancel" text="Cancel" />

Note:

代码里可以通过VisualElement.name修改去匹配Name Selector

Universal selector

universal selector, also called the wildcard selector, matches any element.(通过通配符(正则)去匹配)

1
2
3

* {
    background-color: yellow;
}

<VisualElement name="container1">
    <VisualElement name="container2" class="yellow">
      <Button name="OK" class="yellow" text="OK" />
      <Button name="Cancel" text="Cancel" />
</VisualElement>

更多复杂的选择器参考:

Complex selectors

USS properties

USS property assigns a style or behavior to a VisualElement. (USS的内容属性用于给VisualElement指定具体显示配置)

USS data types

Syntax - auto, ,等。

如果一个属性有多个值，可以如下方式表达不同含义：

Side-by-side表示全部都必须按顺序出现
|表示多个选择里必须出现一个
||表示1个或多个必须按顺序出现
&&表示所有都必须出现
[]表示一个选择组(类似正则里[]的概念)

上面提到的属性多个值都支持类似正则里*,+,?,{A,B}的后缀描述，表达的含义也就是类似正则里的出现次数控制。

Length - 支持像素(px)和百分比(%)两种长度单位

initial - 全局关键词，标识重置属性到初始默认值

Color - 支持16进制(#FFFFFF)和rgb表达方式(rgba(255, 255, 255, 1))

Color关键词详情查看:

USS color keywords

Assets - 支持引用项目里的资源，resource()(标识使用Resources目录资源)，url()(标识使用项目Asset资源，支持相对USS所在目录的相对路径和项目相对路径)

USS common properties

在了解一些常规布局属性概念前，让我们先来看看官网给的一张示意图:

宽高属性

width(宽度)，height(高度)，min-width(最小宽度)，min-height(最小高度)，max-width(最大宽度)，max-height(最大高度)……

边缘(Margins)属性

margin-left(左侧边缘)，margin-top(顶部边缘)，margin-right(右侧边缘)，margin-bottom(底部边缘)……

边界(Border)属性

border-left-width(左侧边界)，border-top-width(顶部边界)，border-right-width(右侧边界)，border-bottom-width(底部边界)，border-color(边界颜色)……

内边距(Padding)属性

padding-left(左侧内边距)，padding-top(顶部内边距)，padding-right(右侧内边距)，padding-bottom(底部内边距)……

排版属性

Items
- flex-grow(排版放大设置)
- flex-shrink(排版缩小设置)
- flex-basic(排版大小设置)
- align-self(自身对齐设置)
- ……
Containers
- flex-direction(子成员排版对齐方向)
- flex-wrap(子成员放不下是否多行显示排版)
- align-content(子成员在排版方向上的对齐方式)
- ……

位置属性

position(位置坐标系-绝对|相对)，left(距离父容器左测距离)，top(距离父容器顶部距离)，right(距离父容器右侧距离)，bottom(距离父容器底部距离)……

UIToolkit里的坐标属性有两种坐标系:

绝对坐标
相对坐标

Note:

设置了Left,Top,Right,Bottom后，Width属性相关设置会被忽略。
绝对坐标适合一些固定位置的弹窗，绝对坐标确定位置后，内部用局部坐标排版UI显示

背景属性

background-color(背景颜色)，backtground-image(背景图片)，-unity-background-scale-mode(背景图片缩放模式)，-unity-background-image-tint-color(背景图片色调?)……

九宫属性

-unity-slice-left(左侧切割数值)，-unity-slice-top(顶部切割数值)，-unity-slice-right(右侧切割数值)，-unity-slice-bottom(底部切割数值)，-unity-slice-scale(九宫缩放值?)……

Appearance(外观)属性

overflow(溢出显示设置),-unity-overflow-clip-box(溢出裁剪box设置),-unity-paragraph-spacing(段落间隔设置),opacity(透明度显示设置),visibility(可见性设置),display(排版显示设置)……

文本属性

color(绘制颜色设置),-unity-font(绘制文本字体设置),-unity-font-definition(?),font-size(字体大小设置),-unity-font-style(字体风格设置),-unity-text-align(字体对齐设置),-unity-text-overflow-position(?),white-space(空格处理方式设置),-unity-text-outline-width(描边宽度设置),-unity-text-outline-color(描边颜色设置)……

详细USS properties查看:

USS properties reference

W3C CSS的详细属性效果查看:

CSS

Note:

USS properties use the same syntax as W3C CSS documents(USS的内容属性采用W3C CSS相关文档规则)
The USS display property supports only a small subset of the CSS display property’s available keyword values.(USS的属性支持只是CSS的很小部分子集)

USS custom properties

USS variables, also called custom properties, define values that you can reuse in other USS rules. You can create variables for any type of USS property.

可以看到USS支持在USS文件里自定义变量，然后像编程里的变量一样，一处定义多处使用。

USS自定义变量规则如下:

–变量名:值

USS自定义变量在其他USS文件访问规则:

var(–变量名, 默认值(可选))

内置自定义变量查询:

USS built-in variable references

Best practices for USS

官方关于使用USS Style的建议:

Avoid inline styles(个人理解是使用全局USS File，避免对单个Visual Element设置Styles(会导致耗费更多内存))
Selector architecture consideration(选择合适的selector方案，过多或过于复杂的selector方案会导致运行时选择style开销更大)

更多建议参考:

Best practices for USS

Theme Style Sheet(TSS)

Theme Style Sheet (TSS) files are regular USS files. UI Toolkit treats TSS as a distinct asset type and uses it for management purposes.

更多学习，待添加……

Query Elements

Unity提供了Query功能(类似Linq)，方便用户快速从VisualTree或Elements里查找符合条件的Element。

UQuery

UQuery is a set of extension methods allowing you to select individual or collection of visualElements inside a complex hierarchy.(一系列扩展方法用于查询指定VisualElements)
UQueryBuilder

Utility Object that contructs a set of selection rules to be ran on a root visual element.(工具类，辅助UQuery构建一系列查询规则)
Q

Q is the shorthand for Query.First(). It returns the first element that matches the selection rules.(Q是查询首个符合规则的Element的缩写)

Event System

Dispatch Events

UIToolkit Event System监听系统事件，然后通过EventDispatcher派发事件给Visual Element。

所有的事件派发都会经历以下三个阶段：

Trickles down: Events sent to elements during the trickle down phase.(个人没太理解这个阶段，感觉是一个事件捕获从上往下派发事件的过程(不含响应事件的最里层Visual Element)
Bubbles up: Events sent to elements during the bubble-up phase.(事件从目标节点向上冒泡派发给Visual Element的，即最里层符合的Visual Element最先派发(从下往上)(含响应事件最里层Visual Element))
Cancellable: Events that can have their default action execution cancelled, stopped, or prevented.(事件是可取消的，比如一般的事件冒泡为了不继续想外层冒泡，我们会设置事件阻断防止继续冒泡)

通过上面的介绍可以了解到，事件派发有两个流程(Trickles down & Bubbles up)，在不打断事件派发的前提下，最里层响应Visual Element只会派发一次，其他外层传递路线上的Visual Element会派发两次事件。

事件基类为EventBase，所有相关事件介绍参考:

Event reference

Note:

The UI Toolkit event system shares the same terminology and event naming as HTML events(UIToolkit采用和HTML一样的事件名和术语)

Handle Events

事件处理顺序如下：

Execute event callbacks on elements from the root element down to the parent of the event target. This is the trickle-down phase of the dispatch process.(事件捕获阶段从上往下触发事件)
Execute event callbacks on the event target. This is the target phase of the dispatch process.(在目标响应Visual Element上触发事件)
Call ExecuteDefaultActionAtTarget() on the event target.(在目标响应Visual Element上触发ExecuteDefaultActionAtTarget()方法)
Execute event callbacks on elements from the event target parent up to the root. This is the bubble-up phase of the dispatch process.(从目标Visual Element开始向上冒泡触发事件)
Call ExecuteDefaultAction() on the event target.(在目标响应Visual Element上触发ExecuteDefaultAction()方法)

事件响应里有两个重要的概念:

Event.currentTarget is the visual element on which the callback was registered.(当前注册响应事件的Visual Element)
Event.target is the element where the event occurs, for example the element directly under the mouse.(当前事件发生的Visual Element)

By default, a registered callback executes during the target phase and the bubble-up phase. This default behavior ensures that a parent element reacts after its child element.(默认状态下，我们注册的事件回调是在target phase和bubble-up phase阶段执行。这是为了确保事件回调触发是从下往上)

如果我们想在指定阶段(e.g. tickle-down phase或bubble-up phase)触发注册事件回调，我们需要在注册事件回调处，显示传参说明响应阶段:

1
2
3

VisualElement myElement = new VisualElement();

myElement.RegisterCallback<MouseDownEvent>(MyCallback, TrickleDown.TrickleDown);

如果我们想事件传递自定义数据，我们需要自定义一个含自带数据的方法回调并监听事件：

1
2
3

myElement.RegisterCallback<MouseDownEvent, MyType>(MyCallbackWithData, myData);

void MyCallbackWithData(MouseDownEvent evt, MyType data) { /* ... */ }

SerializedObject Data Binding

A binding refers to the link between the property and the visual control that modifies it.(数据绑定是用于快速关联UI组件和数据属性，实现UI组件快速修改数据属性)

数据绑定要求:

数据绑定只支持可序列化的属性或类(e.g. ScriptableObject, MonoBehaviour, int, bool, float, Vector3, Color, Object……)
You can only bind the value property of visual elements that implement the INotifyValueChanged interface. (值绑定Visual Element只在实现了INotifyValueChanged接口的组件允许)
You can bind between an object and any visual element that either derives from BindableElement or implements the IBindable interface.(object绑定Visual Element只在继承BindableElement或实现了IBindable接口的组件允许)

数据绑定接口:

Bind() - 绑定VisualElement到指定ScriptableObject

调用Bind前需要设置bindingPath指定哪些属性需要绑定
Unbind() - 解绑VisualElement(含子VisualElement)

EditorWindow关闭会自动解绑，我们只需要在绑定不同数据来源时调用Unbind
bindingPath - 给VisualElement指定需要绑定的属性

bindingPath就是绑定属性的名字
BindProperty() - 绑定VisualElement到制定SerializedProperty

需要自定义哪些属性需要绑定显示的时候
TrackPropertyValue() - 检查指定VisualElement绑定的属性是否变化，变化后触发回调通知
TrackSerializedObjectValue() - 任何VisualElement绑定的属性变化时触发回调通知

官方建议:

自定义Editor或PropertyDrawer，建议使用bindingPath而非Bind()和BindProperty()
尽量避免多次对相同VisualElement调用Bind()，为性能考虑

Note:

SerializedObject data binding only works in the Editor, not at runtime.(SerializedObject的数据绑定只支持Editor模式不支持Runtime模式)
bind a visual element to nested properties in the source object(VisualElement支持绑定到嵌套属性)
Don’t call Bind() from the Editor.CreateInspectorGUI() or PropertyDrawer.CreatePropertyGUI() override. These overrides are called automatically on the visual elements that these methods return.(Editor.CreateInspectorGUI()和 PropertyDrawer.CreatePropertyGUI()里要调用Bind，在这两个方法返回后会自动Bind所有返回的Visual Elements)

UI Assets

Unity提供了两种Asset用于布局系统

UXML documents(Unity eXtensible Markup Language (UXML) is an HTML and XML inspired markup language that you use to define the structure of user interfaces and reusable UI templates.)(类似HTML和XML的标记性语言，用于定义UI布局)
Unity Style Sheets(USS)(Style sheets allow you to apply visual styles and behaviors to user interfaces. They’re similar to Cascading Style Sheets (CSS) used on the web, and support a subset of standard CSS properties. )(类似CSS用于定义UI风格)

UI Tools and resources

Unity提供了几个辅助工具，帮助我们学习和调试UI Toolkit

UI Debugger(UI调试器–可视化查看UI节点详细数据)
UI Builder(UI布局可视化编辑器(预览版本))
UI Samples(UI事例)

实战

接下来通过实战学习，进一步了解UIToolkit的使用和设计。

基础学习

代码+USS创建UI

代码创建UI

UIToolkit为了帮助我们快速创建Editor UI窗口，提供了快捷创建入口:

Asset->Create->UI Toolkit->Editor Window

考虑到不适用UXML作为UI布局，使用纯代码写Editor UI，这里就不勾选UXML了。

创建完会看到生成一个*.cs文件和一个*.uss文件，这是因为我们勾选了C#和USS，接下来我们打开UICreateUIByCodeEditorWindow.cs开始我们的Editor UI代码编写，后续会讲到如何利用*.uss文件来指定UI风格。

UICreateUIByCodeEditorWindow.cs

public class UICreateUIByCodeEditorWindow : EditorWindow
{
    [MenuItem("Window/UI Toolkit/UIToolkitStudy/UICreateUIByCodeEditorWindow")]
    public static void ShowUICodeStyleEditorWindow()
    {
        UICreateUIByCodeEditorWindow wnd = GetWindow<UICreateUIByCodeEditorWindow>();
        wnd.titleContent = new GUIContent("UICreateUIByCodeEditorWindow");
    }
    
    /// <summary>
    /// UIToolkit的rootVisualElement绘制方法
    /// </summary>
    public void CreateGUI()
    {
        CreateUIByCode();
    }
    
    /// <summary>
    /// 通过代码创建UI
    /// </summary>
    private void CreateUIByCode()
    {
        // 创建一个ui容器，用于管理我们新增的ui组件
        VisualElement uiContainer = new VisualElement();
        // 添加一个标题作为ui容器标题组件显示
        Label uiTitleLable = new Label("代码创建UI容器");
        uiContainer.Add(uiTitleLable);

        // 添加按钮组件
        Button btn1 = new Button();
        btn1.text = "代码创建按钮1";
        uiContainer.Add(btn1);

        // 必须将需要显示的组件添加到根节点才能显示
        // 将ui容器添加到根节点作为需要显示的UIElement
        rootVisualElement.Add(uiContainer);
    }
}

可以看到编写基于UIToolkit的Editor Window还是和以往一样，要继承EditorWindow，但实现GUI绘制的接口不是OnGUI()而是CreateGUI()。

正如前面提到的UIToolkit里绘制的对象Visual Tree是由Visual Element组成的树状结构。而EditorWindow.rootVisualElement正是UIToolkit绘制EditorWindow的根VisualElement，我们所有的UIToolkit元素都是添加到此EditorWindow.rootVisualElement实现排版绘制的。

代码修改USS

所有的UIToolkit组件都继承至VisualElement，想通过代码修改UIToolkit组件的Style很简单，直接访问VisualElement.style即可。

UIChangeUSSByCodeEditorWindow.cs

/// <summary>
/// 通过代码修改USS创建UI
/// </summary>
private void CreateStyleUIByCode()
{
    ******
    // 给Label指定不同的Color Style
    uiTitleLable.style.color = Color.red;
    // 设置Label居中显示Style
    uiTitleLable.style.alignSelf = Align.Center;
    ******
}

可以看到通过访问style属性并修改其中的color属性，我成功的修改了标题文本的颜色显示风格。更多的属性修改参考文档:

IStyle

使用USS指定UI风格

第一步依然是使用Create->UI Toolkit->Editor WIndow

去掉UXML勾选，这里依然只通过代码和USS文件创建UI显示。

UIUseUSSEditorWindow.cs

public class UIUseUSSEditorWindow : EditorWindow
{
    [MenuItem("Window/UI Toolkit/UIToolkitStudy/UIUseUSSEditorWindow")]
    public static void ShowUIUseUSSEditorWidnow()
    {
        UIUseUSSEditorWindow wnd = GetWindow<UIUseUSSEditorWindow>();
        wnd.titleContent = new GUIContent("UIUseUSSEditorWindow");
    }
    
    public void CreateGUI()
    {
        CreateUIByUseUSS();
    }
    
    /// <summary>
    /// 使用USS创建UI
    /// </summary>
    private void CreateUIByUseUSS()
    {
        VisualElement root = rootVisualElement;
        // 加载并指定USS的使用
        var styleSheet = AssetDatabase.LoadAssetAtPath<StyleSheet>("Assets/Scripts/Editor/UIToolkitStudy/UIUseUSSEditorWindow/UIUseUSSEditorWindow.uss");
        root.styleSheets.Add(styleSheet);
        
        VisualElement smallLabelWithStyle = new Label("USS Using SmallLabel Class Selector!");
        smallLabelWithStyle.AddToClassList("SmallLabel");
        VisualElement bigLabelWithStyle = new Label("USS Using BigLabel Class Selector!");
        smallLabelWithStyle.AddToClassList("BigLabel");
        VisualElement labelWithStyle = new Label("USS Using Label Type Selector!");
        VisualElement boldLabelWithStyle = new Label("USS Using BoldLabel Class Selector!");
        boldLabelWithStyle.AddToClassList("BoldLabel");
        root.Add(smallLabelWithStyle);
        root.Add(bigLabelWithStyle);
        root.Add(labelWithStyle);
        root.Add(boldLabelWithStyle);
        
        Button ussCenterButton = new Button();
        ussCenterButton.name = "CenterButton";
        ussCenterButton.text = "Center USS Button Name Selector";
        root.Add(ussCenterButton);
    }
}

UIUseUSSEditorWindow.uss

Label {
	font-size: 20px;
	color: rgb(68, 138, 255);
}

.SmallLabel {
	font-size: 10px;
	color: rgb(68, 138, 255);
}

.BigLabel {
	font-size: 40px;
	color: rgb(68, 138, 255);
}

.BoldLabel {
	font-size: 20px;
	-unity-font-style: bold;
	color: rgb(68, 138, 255);
}

#CenterButton {
	align-self: center;
	-unity-text-align: middle-center;
}

可以看到我们在UIUseUSSEditorWindow.uss里分别定义了，Type Selector(Label)，Class Selector(.SmallLabel, .BigLabel, .BoldLabel),Name Selector(CenterButton)。

对应的我们在代码里通过以下三种方式分别指定了Selector：

Type Selector

1	VisualElement labelWithStyle = new Label("USS Using Label Type Selector!");

Class Selctor

VisualElement smallLabelWithStyle = new Label("USS Using SmallLabel Class Selector!");
smallLabelWithStyle.AddToClassList("SmallLabel");
VisualElement bigLabelWithStyle = new Label("USS Using BigLabel Class Selector!");
smallLabelWithStyle.AddToClassList("BigLabel");
VisualElement labelWithStyle = new Label("USS Using Label Type Selector!");
VisualElement boldLabelWithStyle = new Label("USS Using BoldLabel Class Selector!");
boldLabelWithStyle.AddToClassList("BoldLabel");

Name Selector

1
2
3

Button ussCenterButton = new Button();
ussCenterButton.name = "CenterButton";
ussCenterButton.text = "Center USS Button Name Selector";

位置和排版

第一步依然是使用Create->UI Toolkit->Editor WIndow

去掉UXML勾选，这里依然只通过代码和USS文件创建UI显示。

UIPositionAndLayoutEditorWindow.cs

/// <summary>
/// 位置和排版EditorWindow
/// </summary>
public class UIPositionAndLayoutEditorWindow : EditorWindow
{
    /// <summary>
    /// 竖向相对位置根组件
    /// </summary>
    private VisualElement mRootVerticalRelativePosContainer;

    [MenuItem("Window/UI Toolkit/UIToolkitStudy/UIPositionAndLayoutEditorWindow")]
    public static void ShowUIPositionAndLayoutEditorWindow()
    {
        UIPositionAndLayoutEditorWindow wnd = GetWindow<UIPositionAndLayoutEditorWindow>();
        wnd.titleContent = new GUIContent("UIPositionAndLayoutEditorWindow");
    }

    public void CreateGUI()
    {
        CreatePositionAndLayoutUI();
    }

    /// <summary>
    /// 创建位置和排版UI
    /// </summary>
    private void CreatePositionAndLayoutUI()
    {
        CreateRootRelativePosVerticalContainer();
        CreateHorizontalRelativePosContainer();
        CreateHorzintalLayoutContainer();
        CreateVerticalAbsolutePosContainer();
    }

    /// <summary>
    /// 创建竖向相对位置根组件
    /// </summary>
    private void CreateRootRelativePosVerticalContainer()
    {
        // 竖向相对位置排版容器
        mRootVerticalRelativePosContainer = new VisualElement();
        // 设置竖向排版
        mRootVerticalRelativePosContainer.style.flexDirection = FlexDirection.Column;
        // 设置相对位置
        mRootVerticalRelativePosContainer.style.position = Position.Relative;
        // 指定竖向容器Style
        mRootVerticalRelativePosContainer.AddToClassList("unity-box");
        // 设置竖向容器大小位置
        mRootVerticalRelativePosContainer.style.marginLeft = 10;
        mRootVerticalRelativePosContainer.style.marginRight = 10;
        mRootVerticalRelativePosContainer.style.marginTop = 10;
        mRootVerticalRelativePosContainer.style.marginBottom = 10;
        // 设置竖向容器自适应大小
        mRootVerticalRelativePosContainer.style.flexGrow = 1;

        // 添加竖向排版标签
        Label verticalLabel = new Label();
        verticalLabel.text = "竖向相对位置排版容器标题";
        // 设置文本居中显示
        verticalLabel.style.alignSelf = Align.Center;
        mRootVerticalRelativePosContainer.Add(verticalLabel);
        rootVisualElement.Add(mRootVerticalRelativePosContainer);
    }

    /// <summary>
    /// 创建横向相对位置容器
    /// </summary>
    private void CreateHorizontalRelativePosContainer()
    {
        // 横向相对位置容器
        var horizontalRelativePosContainer = new VisualElement();
        // 设置横向排版
        horizontalRelativePosContainer.style.flexDirection = FlexDirection.Row;
        // 设置相对位置
        horizontalRelativePosContainer.style.position = Position.Relative;
        // 指定横向相对位置容器Style
        horizontalRelativePosContainer.AddToClassList("unity-box");
        // 添加横向相对位置标签
        Label horizontalRelativePosLabel = new Label();
        horizontalRelativePosLabel.text = "横向相对位置排版容器标题";
        // 设置文本居中显示
        horizontalRelativePosLabel.style.alignSelf = Align.Center;
        horizontalRelativePosContainer.Add(horizontalRelativePosLabel);

        // 设置横向容器多个按钮
        Button horizontalButton1 = new Button();
        horizontalButton1.text = "横向按钮1";
        horizontalButton1.style.marginLeft = 25;
        Button horizontalButton2 = new Button();
        horizontalButton2.text = "横向按钮2";
        horizontalButton2.style.marginLeft = 50f;
        horizontalRelativePosContainer.Add(horizontalButton1);
        horizontalRelativePosContainer.Add(horizontalButton2);

        mRootVerticalRelativePosContainer.Add(horizontalRelativePosContainer);
    }

    /// <summary>
    /// 创建横向排版容器
    /// </summary>
    private void CreateHorzintalLayoutContainer()
    {
        // 横向排版容器
        var horizontalLayoutContainer = new VisualElement();
        // 设置横向排版
        horizontalLayoutContainer.style.flexDirection = FlexDirection.Row;
        // 设置内容超出后排版Style
        horizontalLayoutContainer.style.flexWrap = Wrap.Wrap;
        // 指定横向排版容器Style
        horizontalLayoutContainer.AddToClassList("unity-box");
        // 添加横向排版标签
        Label horizontalLayoutLabel = new Label();
        horizontalLayoutLabel.text = "横向排版容器标题";
        // 设置文本居中显示
        horizontalLayoutLabel.style.alignSelf = Align.Center;
        horizontalLayoutContainer.Add(horizontalLayoutLabel);

        // 设置横向容器多个按钮
        Button horizontalButton1 = new Button();
        horizontalButton1.text = "横向按钮1";
        // 设置自动扩展系数
        horizontalButton1.style.flexGrow = 1;
        Button horizontalButton2 = new Button();
        horizontalButton2.text = "横向按钮2";
        // 设置自动扩展系数
        horizontalButton2.style.flexGrow = 2;
        // 设置偏移间隔
        horizontalButton2.style.marginLeft = 10;
        Button horizontalButton3 = new Button();
        horizontalButton3.text = "横向按钮3";
        // 设置自动扩展系数
        horizontalButton3.style.flexGrow = 3;
        // 设置偏移间隔
        horizontalButton3.style.marginLeft = 10;
        Button horizontalButton4 = new Button();
        horizontalButton4.text = "横向按钮4";
        // 设置自动扩展系数
        horizontalButton4.style.flexGrow = 4;
        // 设置偏移间隔
        horizontalButton4.style.marginLeft = 10;
        horizontalLayoutContainer.Add(horizontalButton1);
        horizontalLayoutContainer.Add(horizontalButton2);
        horizontalLayoutContainer.Add(horizontalButton3);
        horizontalLayoutContainer.Add(horizontalButton4);

        mRootVerticalRelativePosContainer.Add(horizontalLayoutContainer);
    }

    /// <summary>
    /// 创建竖向绝对位置容器
    /// </summary>
    private void CreateVerticalAbsolutePosContainer()
    {
        // 竖向绝对坐标容器
        var verticalAbsolutePosContainer = new VisualElement();
        // 设置竖向排版
        verticalAbsolutePosContainer.style.flexDirection = FlexDirection.Column;
        // 设置绝对坐标
        verticalAbsolutePosContainer.style.position = Position.Absolute;
        // 指定竖向绝对位置容器Style
        verticalAbsolutePosContainer.AddToClassList("unity-box");
        // 设置竖向容器大小位置
        verticalAbsolutePosContainer.style.left = 100;
        verticalAbsolutePosContainer.style.right = 100;
        verticalAbsolutePosContainer.style.top = 100;
        verticalAbsolutePosContainer.style.bottom = 100;
        // 设置竖向绝对位置容器自适应
        verticalAbsolutePosContainer.style.flexGrow = 1;

        // 添加竖向排版标签
        Label verticalAbsolutePosLabel = new Label();
        verticalAbsolutePosLabel.text = "竖向绝对位置标题";
        // 设置文本居中显示
        verticalAbsolutePosLabel.style.alignSelf = Align.Center;
        verticalAbsolutePosContainer.Add(verticalAbsolutePosLabel);

        // 设置竖向容器多个按钮
        Button verticalButton1 = new Button();
        verticalButton1.text = "竖向按钮1";
        // 设置按钮高度和位置
        verticalButton1.style.height = 20;
        verticalButton1.style.marginLeft = 20;
        verticalButton1.style.marginRight = 20;
        Button verticalButton2 = new Button();
        verticalButton2.text = "竖向按钮2";
        // 设置按钮高度
        verticalButton2.style.height = 20;
        verticalButton2.style.marginLeft = 20;
        verticalButton2.style.marginRight = 20;
        verticalAbsolutePosContainer.Add(verticalButton1);
        verticalAbsolutePosContainer.Add(verticalButton2);

        mRootVerticalRelativePosContainer.Add(verticalAbsolutePosContainer);
    }
}

可以看到通过不断创建需要排版的容器设置对应排版和大小属性，我们成功的创建出了各种排版方向以及相对位置和绝对位置的显示UI。

自定义USS变量

在创建USS文件时，我们很多时候会填充相同值给不同的Selector，而修改时并不想一个一个去修改，这个时候就需要用到类似编程上定义变量公用同一个变量的方式。

第一步依然是使用Create->UI Toolkit->Editor WIndow

去掉UXML勾选，这里依然只通过代码和USS文件创建UI显示。

UICustomUSSVariableEditorWindow.cs


/// <summary>
/// 创建自定义USS变量的Editor Window
/// </summary>
public class UICustomUSSVariableEditorWindow : EditorWindow
{
    [MenuItem("Window/UI Toolkit/UIToolkitStudy/UICustomUSSVariableEditorWindow")]
    public static void ShowUICustomUSSVariableEditorWindow()
    {
        UICustomUSSVariableEditorWindow wnd = GetWindow<UICustomUSSVariableEditorWindow>();
        wnd.titleContent = new GUIContent("UICustomUSSVariableEditorWindow");
    }

    public void CreateGUI()
    {
        CreateCustomUSSVariableUI();
    }

    /// <summary>
    /// 创建自定义USS变量的UI
    /// </summary>
    private void CreateCustomUSSVariableUI()
    {
        // 加载并指定USS的使用
        var customUSSVariable1StyleSheet1 = AssetDatabase.LoadAssetAtPath<StyleSheet>("Assets/Scripts/Editor/UIToolkitStudy/UICustomUSSVariableEditorWindow/UICustomUSSVariableEditorWindow1.uss");
        var customUSSVariable1StyleSheet2 = AssetDatabase.LoadAssetAtPath<StyleSheet>("Assets/Scripts/Editor/UIToolkitStudy/UICustomUSSVariableEditorWindow/UICustomUSSVariableEditorWindow2.uss");
        rootVisualElement.styleSheets.Add(customUSSVariable1StyleSheet1);
        rootVisualElement.styleSheets.Add(customUSSVariable1StyleSheet2);
        
        // 使用UICustomUSSVariableEditorWindow1里的NormalLabel
        Label normalLabel = new Label();
        normalLabel.AddToClassList("NormalLabel");
        normalLabel.text = "NormalLabel1";
        normalLabel.style.left = 10;
        normalLabel.style.right = 10;
        normalLabel.style.height = 20;


        // 使用UICustomUSSVariableEditorWindow2里的NormalLabel2
        Label normalLabel2 = new Label();
        normalLabel2.AddToClassList("NormalLabel2");
        normalLabel2.text = "NormalLabel2";
        normalLabel2.style.left = 10;
        normalLabel2.style.right = 10;
        normalLabel2.style.height = 20;

        rootVisualElement.Add(normalLabel);
        rootVisualElement.Add(normalLabel2);
    }
}

UICustomUSSVariableEditorWindow1.uss

:root {
	--text-color: red;
	--background-color: green;
	--text-color2: yellow;
	--background-color2: blue;
}

.NormalLabel {
	color: red;
	background-color: var(--background-color);
	align-self: center;
}

UICustomUSSVariableEditorWindow2.uss

.NormalLabel2 {
	color: var(--text-color2);
	background-color: var(--background-color2);
	align-self: center;
}

可以看到我们在USS文件里自定义了变量并在Class Selector里使用，通过加载多个USS文件，我们实现了跨USS文件的变量定义访问使用。

UXML创建UI

待添加……

VisualElement Query

VisualElement查询的核心是通过UQuery和Q相关接口进行对象查询(内部是通过UQueryBuilder构建查询条件)

/// <summary>
/// 创建菜单区域
/// </summary>
private void CreateToolbarUI()
{
    var menuHorizontalContainer = new VisualElement();
    *******

    // 创建toolbar
    var menuToolbar = new Toolbar();
    menuToolbar.name = EventHandleElementNames.MenuToolBarName;
    ******
    menuHorizontalContainer.Add(menuToolbar);
    rootVisualElement.Add(menuHorizontalContainer);
}

/// <summary>
/// 创建Toolbar菜单UI
/// </summary>
private void CreateToolbarMenuUI()
{
    // 创建菜单组件
    SelectedMenuData = mToolbarMenuDatas[0];
    var toolbarMenu = new ToolbarMenu();
    toolbarMenu.name = EventHandleElementNames.ToolBarMenuName;
    ******
    var menuToolbar = rootVisualElement.Q<Toolbar>(EventHandleElementNames.MenuToolBarName);
    menuToolbar.Add(toolbarMenu);
}

从上面的代码可以看到，我们创建了一个Toolbar并赋值name为EventHandleElementNames.MenuToolBarName，并将Toolbar组件添加到舞台显示。

接着我们创建菜单组件ToolbarMenu，此时想要把ToolbarMenu加到Toolbar里，这个时候我们需要通过rootVisualElement.Q(EventHandleElementNames.MenuToolBarName);的方式查询到Toolbar组件，然后添加到Toolbar作为子组件显示(Toolbar.Add(ToolbarMenu))即可。

自定义Inspector

待学习

Note:

Unity does not support the use of custom property drawers within default inspectors, as Unity makes default inspectors with IMGUI. If you wish to create a custom property drawer, you must also create a custom inspector for the class that uses that property.(Unity不支持自定义属性绘制使用默认Inspector，因为默认Inspector是用得IMGUI实现。如果编写了Custom Property Drawer，那么也必须编写Custom Inspector)

UI事件响应

UI事件监听核心是通过VisualElement.RegisterCallback()方式去监听不同的事件类型来实现事件响应的。

接下来以节点编辑器左侧配置面板的实现为例，让我们看看，我是如何通过构建不同的VisualElement并且监听不同的事件类型来实现不同事件监听响应的。

这里先直接放一张效果图:

ToolbarMenu(菜单栏)

/// <summary>
/// 菜单栏信息数据列表
/// </summary>
private List<KeyValuePair<string, ToolbarMenuType>> mToolbarMenuDatas = new List<KeyValuePair<string, ToolbarMenuType>>()
{
    new KeyValuePair<string, ToolbarMenuType>("界面1", ToolbarMenuType.PANEL1),
    new KeyValuePair<string, ToolbarMenuType>("界面2", ToolbarMenuType.PANEL2),
    new KeyValuePair<string, ToolbarMenuType>("界面3", ToolbarMenuType.PANEL3),
};

/// <summary>
/// 选择菜单数据
/// </summary>
public KeyValuePair<string, ToolbarMenuType> SelectedMenuData;

/// <summary>
/// 创建Toolbar菜单UI
/// </summary>
private void CreateToolbarMenuUI()
{
    // 创建菜单组件
    SelectedMenuData = mToolbarMenuDatas[0];
    var toolbarMenu = new ToolbarMenu();
    toolbarMenu.name = EventHandleElementNames.ToolBarMenuName;
    toolbarMenu.text = SelectedMenuData.Key;
    toolbarMenu.variant = ToolbarMenu.Variant.Popup;
    toolbarMenu.style.width = 100f;
    foreach (var toolbarData in mToolbarMenuDatas)
    {
        toolbarMenu.menu.AppendAction(toolbarData.Key, OnToolbarMenuChoice, OnToolbarStatusObtain, toolbarData);
    }
    var menuToolbar = rootVisualElement.Q<Toolbar>(EventHandleElementNames.MenuToolBarName);
    menuToolbar.Add(toolbarMenu);
}

/// <summary>
/// 响应菜单栏选择事件
/// </summary>
/// <param name="menuAction"></param>
/// <returns></returns>
private void OnToolbarMenuChoice(DropdownMenuAction menuAction)
{
    var menuData = (KeyValuePair<string, ToolbarMenuType>)menuAction.userData;
    Debug.Log($"菜单显示名:{menuData.Key} 菜单类型:{menuData.Value}选中！");
    SelectedMenuData = menuData;
    var toolbarMenu = rootVisualElement.Q<ToolbarMenu>(EventHandleElementNames.ToolBarMenuName);
    toolbarMenu.text = SelectedMenuData.Key;
}

/// <summary>
/// 响应菜单状态获取
/// </summary>
private DropdownMenuAction.Status OnToolbarStatusObtain(DropdownMenuAction menuAction)
{
    var menuData = (KeyValuePair<string, ToolbarMenuType>)menuAction.userData;
    Debug.Log($"菜单显示名:{menuData.Key} 菜单类型:{menuData.Value}响应菜单状态获取！");
    if (SelectedMenuData.Value == menuData.Value)
    {
        return DropdownMenuAction.Status.Checked;
    }
    return DropdownMenuAction.Status.Normal;
}

ToolbarMenu使用流程：

创建ToolbarMenu组件
通过ToolbarMenu.menu.AppendAction(***)传递ToolbarMenu显示内容，菜单选中以及菜单状态获取回调
菜单选中以及菜单状态获取回调里编写菜单的选中以及显示数据处理

PopupField(下拉框)

/// <summary>
/// Popup弹窗枚举类型
/// </summary>
public enum PopupMenuType
{
    POPUP_1,
    POPUP_2,
    POPUP_3,
}

/// <summary>
/// 创建弹出下拉菜单UI
/// </summary>
private void CreatePopupMenuUI()
{
    // 创建下拉框菜单组件
    var popupMenu = new PopupField<PopupMenuType>(mPopupMenuDatas, mPopupSelectedIndex);
    popupMenu.style.width = 100f;
    popupMenu.RegisterCallback<ChangeEvent<PopupMenuType>>(OnPopupMenuChange);
    var menuToolbar = rootVisualElement.Q<Toolbar>(EventHandleElementNames.MenuToolBarName);
    menuToolbar.Add(popupMenu);
}

/// <summary>
/// 响应弹出菜单变化
/// </summary>
/// <param name="evt"></param>
private void OnPopupMenuChange(ChangeEvent<PopupMenuType> evt)
{
    Debug.Log($"弹出菜单选中:{evt.newValue}");
    var popupMenu = evt.target as PopupField<PopupMenuType>;
    popupMenu.value = evt.newValue;
}

ToolbarMenu使用流程：

创建PopupField组件
通过PopupMenu.RegisterCallback<ChangeEvent>(***)注册下拉框切换回调
在下拉框切换回调里处理下拉框切换数据处理

Button(按钮)

/// <summary>
/// 创建保存路径内容
/// </summary>
private void CreateSavePathContent()
{
    var leftVerticalContentContainer = rootVisualElement.Q<VisualElement>(EventHandleElementNames.LeftVerticalContentContainerName);
    var savePathHorizontalContainer = new VisualElement();
    savePathHorizontalContainer.style.left = 0;
    savePathHorizontalContainer.style.right = 0;
    savePathHorizontalContainer.style.height = 20;
    savePathHorizontalContainer.style.flexDirection = FlexDirection.Row;
    savePathHorizontalContainer.AddToClassList("unity-box");

    var savePathLabelTitle = new Label();
    savePathLabelTitle.style.width = 60;
    savePathLabelTitle.text = "保存路径:";
    savePathHorizontalContainer.Add(savePathLabelTitle);

    var savePathTextField = new TextField();
    savePathTextField.name = EventHandleElementNames.SavePathTextFieldName;
    savePathTextField.style.flexGrow = 1;
    savePathTextField.style.flexShrink = 1;
    savePathTextField.value = GraphSavePath;
    savePathHorizontalContainer.Add(savePathTextField);

    var savePathButton = new Button();
    savePathButton.style.width = 60;
    savePathButton.text = "修改";
    savePathHorizontalContainer.Add(savePathButton);

    // 注册按钮点击
    savePathButton.RegisterCallback<ClickEvent>(OnSavePathButtonClick);
    leftVerticalContentContainer.Add(savePathHorizontalContainer);
}

/// <summary>
/// 相应保存路径按钮点击
/// </summary>
/// <param name="clickEvent"></param>
private void OnSavePathButtonClick(ClickEvent clickEvent)
{
    Debug.Log($"保存路径按钮点击！");
    var newSavePath = EditorUtility.OpenFolderPanel("保存路径", GraphSavePath, string.Empty);
    if(!string.IsNullOrEmpty(newSavePath))
    {
        GraphSavePath = newSavePath;
        Debug.Log($"更新保存路径:{newSavePath}");
        var savePathTextField = rootVisualElement.Q<TextField>(EventHandleElementNames.SavePathTextFieldName);
        savePathTextField.value = GraphSavePath;
    }
}

Button使用流程：

创建Button组件
通过Button.RegisterCallback(***)注册下按钮点击回调
在按钮点击回调处理点击后的响应逻辑

Foldout(折叠)

/// <summary>
/// 创建条件节点UI
/// </summary>
private void CreateConditionNodeUI()
{
    var conditionNodeFoldOut = new Foldout();
    conditionNodeFoldOut.name = EventHandleElementNames.ConditionNodeFoldOutName;
    conditionNodeFoldOut.viewDataKey = EventHandleViewDataKeys.ConditionNodeFoldOutViewDataKeyName;
    conditionNodeFoldOut.text = "条件节点";
    conditionNodeFoldOut.AddToClassList("unity-box");
    
    ******

    // 注册条件节点FoldOut值变化回调
    conditionNodeFoldOut.RegisterValueChangedCallback(OnConditionNodeFoldOutValueChange);
    var nodeVerticalContainer = rootVisualElement.Q<VisualElement>(EventHandleElementNames.NodeVerticalContainerName);
    nodeVerticalContainer.Add(conditionNodeFoldOut);
}

/// <summary>
/// 创建行为节点UI
/// </summary>
private void CreateActionNodeUI()
{
    var actionNodeFoldOut = new Foldout();
    actionNodeFoldOut.name = EventHandleElementNames.ActionNodeFoldOutName;
    actionNodeFoldOut.viewDataKey = EventHandleViewDataKeys.ActionNodeFoldOutViewDataKeyName;
    actionNodeFoldOut.text = "行为节点";
    actionNodeFoldOut.AddToClassList("unity-box");
    
    ******

    // 注册行为节点FoldOut值变化回调
    actionNodeFoldOut.RegisterValueChangedCallback(OnActionNodeFoldOutValueChange);
    var nodeVerticalContainer = rootVisualElement.Q<VisualElement>(EventHandleElementNames.NodeVerticalContainerName);
    nodeVerticalContainer.Add(actionNodeFoldOut);
}

/// <summary>
/// 响应条件节点FoldOut值变化
/// </summary>
/// <param name="changeEvent"></param>
private void OnConditionNodeFoldOutValueChange(ChangeEvent<bool> changeEvent)
{
    Debug.Log($"响应条件节点折叠值更新：{changeEvent.newValue}");
}

/// <summary>
/// 响应行为节点FoldOut值变化
/// </summary>
/// <param name="changeEvent"></param>
private void OnActionNodeFoldOutValueChange(ChangeEvent<bool> changeEvent)
{
    Debug.Log($"响应行为节点折叠值更新：{changeEvent.newValue}");
}

Foldout使用流程：

创建Foldout组件
通过FoldOut.RegisterValueChangedCallback(***)注册折叠变化回调
在折叠变化回调处理折叠变化响应逻辑

ListView(列表)

/// <summary>
/// 行为类型
/// </summary>
public enum ActionType
{
    ACTION1,
    ACTION2,
    ******,
    ACTION20,
}

/// <summary>
/// 条件类型
/// </summary>
public enum ConditionType
{
    CONDITION1,
    CONDITION2,
    ******,
    CONDITION20,
}

/// <summary>
/// 行为类型列表
/// </summary>
private List<ActionType> mActionTypeList = new List<ActionType>();

/// <summary>
/// 条件类型列表
/// </summary>
private List<ConditionType> mConditionTypeList = new List<ConditionType>();

/// <summary>
/// 初始化节点数据
/// </summary>
private void InitNodeDatas()
{
    mActionTypeList.Clear();
    var actionTypes = Enum.GetValues(typeof(ActionType));
    foreach (var actionType in actionTypes)
    {
        mActionTypeList.Add((ActionType)actionType);
    }

    mConditionTypeList.Clear();
    var conditionTypes = Enum.GetValues(typeof(ConditionType));
    foreach (var conditionType in conditionTypes)
    {
        mConditionTypeList.Add((ConditionType)conditionType);
    }
}

/// <summary>
/// 创建条件节点UI
/// </summary>
private void CreateConditionNodeUI()
{
    var conditionNodeFoldOut = new Foldout();
    ******
    var conditionListView = new ListView(mConditionTypeList, 20, OnMakeNodeItem, OnBindConditionItem);
    conditionListView.style.height = 300;
    conditionNodeFoldOut.Add(conditionListView);
	******
}

/// <summary>
/// 创建行为节点UI
/// </summary>
private void CreateActionNodeUI()
{
    var actionNodeFoldOut = new Foldout();
    ******
    var actionListView = new ListView(mConditionTypeList, 20, OnMakeNodeItem, OnBindActionItem);
    actionListView.style.height = 300;
    actionNodeFoldOut.Add(actionListView);
    ******
}

/// <summary>
/// 响应绑定条件节点
/// </summary>
/// <param name="conditionItem"></param>
/// <param name="index"></param>
private void OnBindConditionItem(VisualElement conditionItem, int index)
{
    var conditionButton = conditionItem as Button;
    conditionButton.name = GetConditionItemNameByIndex(index);
    conditionButton.text = mConditionTypeList[index].ToString();
    conditionButton.userData = mConditionTypeList[index];
    conditionButton.RegisterCallback<ClickEvent>(OnBindConditionItemButtonClick);
}

/// <summary>
/// 响应绑定行为节点
/// </summary>
/// <param name="conditionItem"></param>
/// <param name="index"></param>
private void OnBindActionItem(VisualElement conditionItem, int index)
{
    var actionButton = conditionItem as Button;
    actionButton.name = GetActionItemNameByIndex(index);
    actionButton.text = mActionTypeList[index].ToString();
    actionButton.userData = mActionTypeList[index];
    actionButton.RegisterCallback<ClickEvent>(OnBindActionItemButtonClick);
}

/// <summary>
/// 响应节点Item构建
/// </summary>
/// <returns></returns>
private VisualElement OnMakeNodeItem()
{
    return new Button();
}

/// <summary>
/// 响应Condition按钮点击
/// </summary>
/// <param name="clickEvent"></param>
private void OnBindConditionItemButtonClick(ClickEvent clickEvent)
{
    var conditionItemButton = clickEvent.target as Button;
    var clickConditionType = (ConditionType)conditionItemButton.userData;
    Debug.Log($"点击了ConditionType:{clickConditionType}按钮！");
}

/// <summary>
/// 响应Action按钮点击
/// </summary>
/// <param name="clickEvent"></param>
private void OnBindActionItemButtonClick(ClickEvent clickEvent)
{
    var actionItemButton = clickEvent.target as Button;
    var clickActionType = (ActionType)actionItemButton.userData;
    Debug.Log($"点击了ActionType:{clickActionType}按钮！");
}

/// <summary>
/// 获取制定索引的Condition Item名
/// </summary>
/// <param name="index"></param>
/// <returns></returns>
private string GetConditionItemNameByIndex(int index)
{
    return $"{EventHandleElementNames.ConditionItemPrefixName}{mConditionTypeList[index]}";
}

/// <summary>
/// 获取制定索引的Action Item名
/// </summary>
/// <param name="index"></param>
/// <returns></returns>
private string GetActionItemNameByIndex(int index)
{
    return $"{EventHandleElementNames.ActionItemPrefixName}{mActionTypeList[index]}";
}

ListView使用流程：

创建ListView组件
创建ListView组件时传递需要显示的数据，高度，列表组件构造回调以及列表组件绑定回调
在列表组件构造回调里构建我们列表里需要显示的VisualElement
在列表组件绑定回调里处理列表组件的详细逻辑处理

更多的事件响应待添加……

数据绑定

数据绑定组件

通过前面对于属性绑定的基础学习:

SerializedObject Data Binding

可以知道，对于VisualElement和属性的绑定核心通过以下几个接口:

Bind()
Unbind()
bindingPath
BindProperty()

UIPropertyBindEditorWindow.cs

/// <summary>
/// 属性绑定Editor Window
/// </summary>
public class UIPropertyBindEditorWindow : EditorWindow
{
    /// <summary>
    /// 选中的ScriptableObject
    /// </summary>
    private ScriptableObject mSelectedScriptableObject;

    [MenuItem("Window/UI Toolkit/UIToolkitStudy/UIPropertyBindEditorWindow")]
    public static void ShowUIPropertyBindEditorWindow()
    {
        UIPropertyBindEditorWindow wnd = GetWindow<UIPropertyBindEditorWindow>();
        wnd.titleContent = new GUIContent("UIPropertyBindEditorWindow");
    }

    public void CreateGUI()
    {
        CreatePropertyBindUI();
        OnSelectionChange();
    }

    /// <summary>
    /// 选中Asset变化回调
    /// </summary>
    private void OnSelectionChange()
    {
        mSelectedScriptableObject = Selection.activeObject as ScriptableObject;
        var propertyBindAssetNameTextField = rootVisualElement.Q<TextField>(PropertyBindElementNames.PropertyBindTextFieldName);
        var propertyBindInfoContentContainer = rootVisualElement.Q<VisualElement>(PropertyBindElementNames.PropertyBindInfoContentContainerName);
        if(mSelectedScriptableObject != null)
        {
            var selectedSerializedObject = new SerializedObject(mSelectedScriptableObject);
            if(propertyBindAssetNameTextField != null)
            {
                var nameProperty = selectedSerializedObject.FindProperty("m_Name");
                propertyBindAssetNameTextField.BindProperty(nameProperty);
            }
            if(propertyBindInfoContentContainer != null)
            {
                var propertyIterator = selectedSerializedObject.GetIterator();
                propertyIterator.NextVisible(true);
                while(propertyIterator.NextVisible(false))
                {
                    var propertyField = new PropertyField();
                    propertyField.name = propertyIterator.name;
                    propertyField.style.height = 20;
                    propertyField.BindProperty(propertyIterator);
                    propertyBindInfoContentContainer.Add(propertyField);
                }
            }
        }
        else
        {
            if(propertyBindAssetNameTextField != null)
            {
                propertyBindAssetNameTextField.Unbind();
                propertyBindAssetNameTextField.value = string.Empty;
            }
            if(propertyBindInfoContentContainer != null)
            {
                propertyBindInfoContentContainer.Clear();
            }
        }
    }

    /// <summary>
    /// 创建属性绑定UI
    /// </summary>
    private void CreatePropertyBindUI()
    {
        CreatePropertyBindAssetInfoUI();
        CreatePropertyBindPropertyUI();
    }

    /// <summary>
    /// 创建属性绑定Asset信息UI
    /// </summary>
    private void CreatePropertyBindAssetInfoUI()
    {
        var propertyBindAssetInfoHContainer = new VisualElement();
        propertyBindAssetInfoHContainer.style.flexDirection = FlexDirection.Row;
        propertyBindAssetInfoHContainer.style.height = 20;
        rootVisualElement.Add(propertyBindAssetInfoHContainer);

        var propertyBindLabelTitle = new Label();
        propertyBindLabelTitle.text = "绑定Asset名";
        propertyBindLabelTitle.style.width = 80;
        propertyBindAssetInfoHContainer.Add(propertyBindLabelTitle);

        var propertyBindAssetNameTextField = new TextField();
        propertyBindAssetNameTextField.name = PropertyBindElementNames.PropertyBindTextFieldName;
        propertyBindAssetNameTextField.style.flexGrow = 1;
        propertyBindAssetNameTextField.value = string.Empty;
        propertyBindAssetInfoHContainer.Add(propertyBindAssetNameTextField);
    }

    /// <summary>
    /// 创建属性绑定属性UI
    /// </summary>
    private void CreatePropertyBindPropertyUI()
    {
        var propertyBindInfoVContainer = new VisualElement();
        propertyBindInfoVContainer.style.flexDirection = FlexDirection.Column;
        propertyBindInfoVContainer.style.left = 0;
        propertyBindInfoVContainer.style.right = 0;
        propertyBindInfoVContainer.style.top = 0;
        propertyBindInfoVContainer.style.bottom = 0;
        propertyBindInfoVContainer.style.flexGrow = 1;
        propertyBindInfoVContainer.AddToClassList("unity-rect-field");
        rootVisualElement.Add(propertyBindInfoVContainer);

        var propertyBindInfoLabelTitle = new Label();
        propertyBindInfoLabelTitle.text = "绑定Assets绑定属性显示";
        propertyBindInfoLabelTitle.style.alignSelf = Aligh.Center;
        propertyBindInfoLabelTitle.style.height = 20;
        propertyBindInfoVContainer.Add(propertyBindInfoLabelTitle);

        var propertyBindInfoContentContainer = new VisualElement();
        propertyBindInfoContentContainer.name = PropertyBindElementNames.PropertyBindInfoContentContainerName;
        propertyBindInfoContentContainer.style.flexDirection = FlexDirection.Column;
        propertyBindInfoContentContainer.style.flexGrow = 1;
        propertyBindInfoVContainer.Add(propertyBindInfoContentContainer);
    }
}

PropertyBindSO.cs

/// <summary>
/// PropertyBindSO.cs
/// 属性绑定ScriptableObject
/// </summary>
[CreateAssetMenu(fileName = "PropertyBindSO", menuName = "ScriptableObjects/DIY/PropertyBindSO", order = 1)]
public class PropertyBindSO : ScriptableObject
{
    /// <summary>
    /// 自定义枚举
    /// </summary>
    public enum CustomEnum
    {
        ENUM1,
        ENUM2,
        ENUM3,
    }

    /// <summary>
    /// 名字
    /// </summary>
    [Header("名字")]
    public string Name;

    /// <summary>
    /// 颜色
    /// </summary>
    [Header("颜色")]
    public Color Color;

    /// <summary>
    /// 绑定GameObject
    /// </summary>
    [Header("绑定GameObject")]
    public GameObject GO;

    /// <summary>
    /// 自定义枚举
    /// </summary>
    [Header("自定义枚举")]
    public CustonEnum CustonE;

    /// <summary>
    /// Transform列表
    /// </summary>
    [Header("Transform列表")]
    public List<Transform> TransformList;

    /// <summary>
    /// 位置数组
    /// </summary>
    [Header("位置数组")]
    public Vector3[] Positions;

    /// <summary>
    /// 自定义Class
    /// </summary>
    [Header("自定义Class")]
    public CustomBindClass BindClass;
}

从上面截图可以看到，通过Selection.activeObject得到选中的ScriptableObject对象，结合selectedSerializedObject.GetIterator()遍历添加所有可视化属性展示(PropertyField)，同时通过TextField.BindProperty()绑定文本和特定属性显示从而实现属性绑定VisualElement的效果。

当我们未选中任何对象时我们通过Unbind()接口接触VisualElement的属性绑定效果。

数据绑定UI变化回调

数据绑定变化回调核心通过以下几个接口：

TrackPropertyValue()
TrackSerializedObjectValue()

UIPropertyBindCBEditorWindow.cs

/// <summary>
/// UIPropertyBindCBEditorWindow.cs
/// 属性修改绑定窗口
/// </summary>
public class UIPropertyBindCBEditorWindow : EditorWindow
{
    /// <summary>
    /// 选中的ScriptableObject
    /// </summary>
    private ScriptableObject mSelectedScriptableObject;

    [MenuItem("Window/UI Toolkit/UIToolkitStudy/UIPropertyBindCBEditorWindow")]
    public static void ShowUIPropertyBindCBEditorWindow()
    {
        UIPropertyBindCBEditorWindow wnd = GetWindow<UIPropertyBindCBEditorWindow>();
        wnd.titleContent = new GUIContent("UIPropertyBindCBEditorWindow");
    }

    public void CreateGUI()
    {
        CreatePropertyBindCBUI();
        OnSelectionChange();
    }

    /// <summary>
    /// 选中Asset变化回调
    /// </summary>
    private void OnSelectionChange()
    {
        mSelectedScriptableObject = Selection.activeObject as ScriptableObject;
        var propertyBindAssetNameTextField = rootVisualElement.Q<TextField>(PropertyBindCBElementNames.PropertyBindCBTextFieldName);
        var serializedBindAssetNameTextField = rootVisualElement.Q<TextField>(PropertyBindCBElementNames.SerializedBindCBTextFieldName);
        if(mSelectedScriptableObject != null)
        {
            var selectedSerializedObject = new SerializedObject(mSelectedScriptableObject);
            if(propertyBindAssetNameTextField != null)
            {
                var nameProperty = selectedSerializedObject.FindProperty("Name");
                propertyBindAssetNameTextField.TrackPropertyValue(nameProperty, OnNamePropertyChange);
                propertyBindAssetNameTextField.BindProperty(nameProperty);
            }
            if(serializedBindAssetNameTextField != null)
            {
                serializedBindAssetNameTextField.TrackSerializedObjectValue(selectedSerializedObject, OnPropertyChange);
            }
        }
        else
        {
            if(propertyBindAssetNameTextField != null)
            {
                propertyBindAssetNameTextField.Unbind();
                propertyBindAssetNameTextField.value = string.Empty;
            }
            if(serializedBindAssetNameTextField != null)
            {
                serializedBindAssetNameTextField.Unbind();
            }
        }
    }

    /// <summary>
    /// 创建属性绑定回调UI
    /// </summary>
    private void CreatePropertyBindCBUI()
    {
        var propertyBindCBAssetInfoHContainer = new VisualElement();
        propertyBindCBAssetInfoHContainer.style.flexDirection = FlexDirection.Row;
        propertyBindCBAssetInfoHContainer.style.height = 20;
        rootVisualElement.Add(propertyBindCBAssetInfoHContainer);

        var proeprtyBindLabelTitle = new Label();
        proeprtyBindLabelTitle.text = "名字属性值:";
        proeprtyBindLabelTitle.style.width = 160;
        propertyBindCBAssetInfoHContainer.Add(proeprtyBindLabelTitle);

        var propertyBindAssetNameTextField = new TextField();
        propertyBindAssetNameTextField.name = PropertyBindCBElementNames.PropertyBindCBTextFieldName;
        propertyBindAssetNameTextField.style,flexGrow = 1;
        propertyBindAssetNameTextField.value = string.Empty;
        propertyBindCBAssetInfoHContainer.Add(propertyBindAssetNameTextField);

        var serializedObjectBindCBAssetInfoHContainer = new VisualElement();
        serializedObjectBindCBAssetInfoHContainer.style.flexDirection = FlexDirection.Row;
        serializedObjectBindCBAssetInfoHContainer.style.height = 20;
        rootVisualElement.Add(serializedObjectBindCBAssetInfoHContainer);

        var serializedBindLabelTitle = new Label();
        serializedBindLabelTitle.text = "属性变化SerializeObject名:";
        serializedBindLabelTitle.style.width = 160;
        serializedObjectBindCBAssetInfoHContainer.Add(serializedBindLabelTitle);

        var serializedBindAssetNameTextField = new TextField();
        serializedBindAssetNameTextField.name = PropertyBindCBElementNames.SerializedBindCBTextFieldName;
        serializedBindAssetNameTextField.style.flexGrow = 1;
        serializedBindAssetNameTextField.value = string.Empty;
        serializedObjectBindCBAssetInfoHContainer.Add(serializedBindAssetNameTextField);
    }

    /// <summary>
    /// 响应名字属性变化
    /// </summary>
    /// <param name="property"></param>
    private void OnNamePropertyChange(SerializedProperty property)
    {
        Debug.Log($"名字属性发生变化！");
    }

    /// <summary>
    /// 响应属性变化
    /// </summary>
    /// <param name="serializedObject"></param>
    private void OnPropertyChange(SerializedObject serializedObject)
    {
        Debug.Log($"SerializedObject.name:{serializedObject.targetObject.name}属性变化！");
        var serializedBindAssetNameTextField = rootVisualElement.Q<TextField>(PropertyBindCBElementNames.SerializedBindCBTextFieldName);
        if(serializedBindAssetNameTextField != null)
        {
            serializedBindAssetNameTextField.value = serializedObject.targetObject.name;
        }
    }
}

PropertyBindCBSO.cs

/// <summary>
/// PropertyBindCBSO.cs
/// 属性绑定回调ScriptableObject
/// </summary>
[CreateAssetMenu(fileName = "PropertyBindCBSO", menuName = "ScriptableObjects/DIY/PropertyBindCBSO", order = 1)]
public class PropertyBindCBSO : ScriptableObject
{
    /// <summary>
    /// 名字
    /// </summary>
    [Header("名字")]
    public string Name;

    /// <summary>
    /// 位置
    /// </summary>
    [Header("位置")]
    public Vector3 Position;

    /// <summary>
    /// 颜色
    /// </summary>
    [Header("颜色")]
    public Color Color;

    /// <summary>
    /// 绑定GameObject
    /// </summary>
    [Header("绑定GameObject")]
    public GameObject GO;
}

从上面代码可以看到我通过TextField绑定指定属性后调用TrackPropertyValue实现指定属性变化回调监听。

通过TextField调用TrackSerializedObjectValue实现对指定SerializedObject所有属性变化的监听。

知识点

EditorWindow.CreateGUI()方法是用于UIToolkit创建Editor窗口的rootVisualElement显示方法
Editor.CreateInspectorGUI()方法是用于UIToolkit创建自定义Inspector面板的显示方法
UI Toolkit to create Editor UI and synchronize data between a property and a visual element for the Editor UI.(UIToolkit支持在Editor UI上同步属性数据到Visual Element上)

行为树节点编辑器实战

详情参考:行为树节点编辑器

Github

个人Github:

UnityEditor知识

UIToolkit

Reference

Creating user interfaces (UI)

CSS

USS properties reference

IStyle

UXML现有可用Element查询

USS built-in variable references

Event Reference

Graph Tools Foundation 0.11

路点编辑和缓动

By Tony Tang

发表于 2023-04-09

Introduction

游戏开发过程中，我们希望角色物体按固定路线移动，我们一般需要通过路点编辑器工具去预先编辑好所有路点，然后导出路点数据通过数学运算去移动角色物体。

结合以前学习的数学缓动和UnityEditor知识

本章节通过编写纯Editor的路点编辑器，从实战角度去利用数学缓动和UnityEditor知识实现我们需要的路点编辑器工具，以及基于路点编辑器数据的路线插值缓动系统。

觉得好用的可以购买淘宝商店版本支持作者：

PathPointTool路点工具(淘宝)

路点编辑和缓动

实现一个工具，首先第一步，我们还是需要理清需求：

纯Editor非运行时路点编辑器。
路点编辑器需要生成可视化编辑对象和路点路线展示(支持纯Editor绘制和LineRenderer组件绘制两种方式)。
路点编辑器要支持指定起始位置和固定位置偏移的路点编辑自动矫正(方便固定单位间隔的路点配置)。
路点编辑器要支持指定路线移动时长，是否循环和是否自动更新朝向等路线缓动模拟设置。
路点编辑器要支持自定义数据导出自定义格式(比如Json，CSV)数据。
路点编辑器要支持多种路线类型(e.g. 直线，Bezier，CubicBezier等)。
路线移动支持缓动曲线配置。
路点编辑器要支持纯Editor模拟运行路点移动效果。
路点编辑器编辑完成后的数据要支持运行时使用并模拟路线缓动，同时路线缓动要支持纯运行时构建使用。
实现一个纯Editor的Tile可视化绘制脚本(方便路点编辑位置参考)。
不同路点类型要支持DIY数据定义加配置导出。
支持自定义导出的数据加载快速使用触发路点移动表现。
路点移动要支持移动完成，经过路点，循环开始等回调。

Bezier曲线

我们路点编辑器要支持直线和曲线运动，说到曲线运动，这里就不得不提Bezier曲线。

贝塞尔曲线是电脑图形学中相当重要的参数曲线。

个人理解Bezier曲线的核心原理就是多个点(N阶)之间的同时递归插值0-1比例值得出的一系列最终插值位置

线性Bezier曲线

线性Bezier曲线其实就是我们2个点位置的线性插值，公式如下(P0第一个点，P1第二个点)：

B(t) = P0 + (P1 - P0) * t，t∈[0, 1]

一阶Bezier曲线公式简化后:

B(t) = (1 - t) * P0 - t * P1，t∈[0, 1]

从公式可以看出，线性Bezier就是2个点位置通过0-1的比例值插值的过程。

二阶Bezier曲线

同理二阶Beizer曲线是由3个顶点位置递归插值而来的，公式如下(P0第一个点，P1第二个点，P2第三个点)：

首先我们先我们先插值P0和P1：

P0P1 = (1 - t) * P0 + t * P1，t∈[0, 1]

接下来插值P1和P2：

P1P2 = (1 - t) * P1 + t * P2，t∈[0, 1]

三个点之间的插值完成后，接下来我们还要递归插值三个点插值后的两个点(P0P1和P1P2)：

p0p1p2 = (1 - t) * p0p1 + t * p1p2，t∈[0, 1]

二阶Bezier曲线公式简化后:

B(t) = (1 - t)² * P0 + 2 * (1 - t) * t * P1 + t² * P2，t∈[0, 1]

三阶Bezier曲线

同理三阶Beizer曲线是由3个顶点位置递归插值而来的，公式如下(P0第一个点，P1第二个点，P2第三个点，P3第四个点)：

首先我们先我们先插值P0和P1：

P0P1 = (1 - t) * P0 + t * P1，t∈[0, 1]

接下来插值P1和P2：

P1P2 = (1 - t) * P1 + t * P2，t∈[0, 1]

接下来插值P2和P3：

P2P3 = (1 - t) * P2 + t * P3，t∈[0, 1]

以上插值位置动画如下:

P0P1,P1P2,P2P3分别对应动画中的a,b,c三个插值点

四个点之间的插值完成后，接下来我们还要递归插值四个点插值后的三个点(P0P1，P1P2和P2P3)：

插值P0P1和P1P2：

P0P1P2 = (1 - t) * P0P1 + t * P1P2，t∈[0, 1]

插值P1P2和P2P3：

P1P2P3 = (1 - t) * P1P2 + t * P2P3，t∈[0, 1]

以上插值位置动画如下:

P0P1P2和P1P2P3分别对应动画中的d和e两个插值点

最后一步，我们接着把P0P1P2和P1P2P3进行插值就能得到3阶Bezier曲线的最终插值位置了:

插值P0P1P2和P1P2P3：

P0P1P2P3 = (1 - t) * P0P1P2 + t * P1P2P3，t∈[0, 1]

三阶Bezier曲线公式简化后:

B(t) = (1 - t)³ * P0 + 3 * (1 - t)² * t * P1 + 3 * t² * (1 - t) * P2 + t³ * P3，t∈[0, 1]

以上插值位置动画如下:

N阶Bezier曲线公式参考:

N阶Bezier的代码实现请参考:

unity利用高阶贝塞尔曲线进行的轨道移动

由于N阶Bezier的计算复杂度过高，一般来说，路点过多的情况下，我们不会直接采用N阶Bezier曲线进行插值计算，而是采用N个3阶Bezier曲线进行拼接组装成一个N阶Bezier曲线

Catmull-Rom Spline

虽然Bezier已经能实现大部分曲线的需求，但Bezier曲线里移动控制点(无论2阶还是3阶)就会导致整个曲线发生变化，即无法局部控制曲线走向，同时Bezier曲线不能确保通过所有控制点。

Catmull-Rom Spline样条线是一根比较特殊的Bezier曲线，这条Bezier曲线能够保证穿过从控制点的第二个点到控制点的倒数第二点之间的所有点。所以说，Catmull-Rom样条线最少需要4个控制点来进行控制。

Catmull-Rom算法保证两点：

1、点Pi 的一阶导数等于Pi+1 - Pi-1，即点Pi 的切向量和其相邻两点连线的切向量是平行的

2、穿过所有Pi 点。这是与贝塞尔曲线的最大区别，正因为这样的特性，使得Catmull-Rom算法适于用作轨迹线算法。

可以看到Catmull-Rom Spline和三阶Bezier曲线一样需要4个点：

P1点的切线和P0P2一致，P2点的切线和P1P3一致。

值得注意的是虽然输入点有4个，但我们t(0-1)最终绘制的是P1到P2和P2到P3这部分

那么如何确保所有的控制点都连接绘制了？

利用Catmull-Rom Spline曲线会通过中间两个控制点且中间两个点经过时的切线与前后两个控制点连线平行，那么我可以可以通过模拟构造一个P(-1)=2P0-P1(确保P(-1)P1和P0切线平行从而确保从P0处切线平行)，利用P(-1)P0P1P2构造一个CatmullRomSpline曲线即可画出P0开始的P0P1的曲线。最后一段曲线同理，构造一个P(N+1)=2P(N)-P(N-1)，然后绘制P(N-2)P(N-1)P(N)P(N+1)即可绘制出P(N-1)P(N)的曲线。

这里直接给出最终推导公式，详细推导过程参考后续其他博主分享：

P = _point = P0 * (-0.5ttt + tt – 0.5t) + P1 * (1.5ttt - 2.5tt + 1.0) + P2 * (-1.5ttt + 2.0tt + 0.5t) + P3 * (0.5ttt – 0.5t*t);

详细的推导过程博主并没有完全看懂，这里大家可以参考这位博主的推导分析:

Catmull-Rom插值算法

理解了Bezier曲线和Catmull-Rom Spline样条线原理，接下来让我们进入路点编辑器实战。

实战

接下来针对前面提到的需求，我们一一分析我们应该用什么方案和技术来实现。

需求：

纯Editor非运行时路点编辑器。
路点编辑器需要生成可视化编辑对象和路点路线展示(支持纯Editor绘制和LineRenderer组件绘制两种方式)。
路点编辑器要支持指定起始位置和固定位置偏移的路点编辑自动矫正(方便固定单位间隔的路点配置)。
路点编辑器要支持指定路线移动时长，是否循环和是否自动更新朝向等路线缓动模拟设置。
路点编辑器要支持自定义数据导出自定义格式(比如Json)数据。
路点编辑器要支持多种路线类型(e.g. 直线，Bezier，CubicBezier等)。
路点编辑器要支持纯Editor模拟运行路点移动效果。
路线移动支持缓动曲线配置。
路点编辑器编辑完成后的数据要支持运行时使用并模拟路线缓动，同时路线缓动要支持纯运行时构建使用。
实现一个纯Editor的Tile可视化绘制脚本(方便路点编辑位置参考)。
不同路点类型要支持DIY数据定义加配置导出。
支持自定义导出的数据加载快速使用触发路点移动表现。
路点移动要支持移动完成，经过路点，循环开始等回调。

实现思路：

结合自定义Inspector面板(继承Editor)定义的方式实现纯Editor配置和操作
利用Gizmos(Monobehaviour:OnDrawGizmos())，Handles(Editor.OnSceneGUI())和自定义Inspector(Editor)面板编辑操作实现可视化编辑对象生成和展示。LineRenderer通过挂在指定LinRenderer组件将路点细分的点通过LineRenderer:SetPositions()设置显示。
利用自定义Inspector面板支持起始位置和路点间隔配置，然后通过配置数据进行路点位置矫正操作。
自定义Inspecotr面板支持配置即可。
同上，自定义Inspector面板支持导出文件名和导出类型即可，路点数据导出前统一封装然后根据导出类型导出即可。
利用Bezier曲线知识，实现不同路线类型(e.g. 直线，Bezier，CubicBezier等)。
利用InitializeOnLoad，ExecuteInEditMode和InitializeOnLoadMethod标签加EditorApplication.update实现纯Editor初始化和注入Update更新实现纯Editor模拟路点移动效果。
利用缓动曲线去重新计算插值t(0-1)的值作为插值比例即可。
实现一套超级简陋版DoTween支持运行时路线缓动模拟即可(见TPathTweener和TPathTweenerManager)。
利用Gizmos的自定义Mesh绘制+自定义Inspector面板实现Tile网格自定义配置绘制。
通过定义TPathPointType定义路点类型，然后统一在TPathPointData里定义自定义数据成员，在自定义绘制Inspector面板时根据路点类型去决定是否绘制特定自定义数据面板。
通过构造统一导出数据结构，给TPathTweenerManager添加使用导出数据结构作为路点数据表现的接口即可。
通过TPathTweener去根据进度计算对应回调实际触发对应回调即可。

核心思路和技术实现方案都在上面介绍了，这里就不一一介绍代码实现了，这里只放关于Bezier曲线插值相关的代码，让我们直接实战看效果，需要源码的直接在文章末尾Github链接去取即可。

BezierUtilities.cs(Bezier曲线插值相关)

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// BezierUtilities.cs
/// Bezier静态工具类
/// </summary>
public static class BezierUtilities
{
    // Note：
    // 1. 高阶Bezier曲线计算复杂，推荐用N个3阶Bezier曲线模拟

    /// <summary>
    /// 根据t(0-1)计算一阶Bezier曲线上面对应的点
    /// </summary>
    /// <param name="p0">第一个点</param>
    /// <param name="p1">第二个点</param>
    /// <param name="t">插值(0-1)</param>
    /// <returns></returns>
    public static Vector3 CaculateLinerPoint(Vector3 p0, Vector3 p1, float t)
    {
        t = Mathf.Clamp01(t);
        // 原始公式:
        /*
        return (1 - t) * p0 + t * p1;
        */
        return (1 - t) * p0 + t * p1;
    }

    /// <summary>
    /// 根据t(0-1)计算二阶贝塞尔曲线上面对应的点
    /// </summary>
    /// <param name="p0">第一个点</param>
    /// <param name="p1">第二个点</param>
    /// <param name="p2">第三个点</param>
    /// <param name="t">插值(0-1)</param>
    /// <returns></returns>
    public static Vector3 CaculateBezierPoint(Vector3 p0, Vector3 p1, Vector3 p2, float t)
    {
        t = Mathf.Clamp01(t);
        // 原始公式:
        /*
        var p0p1 = (1 - t) * p0 + t * p1;
        var p1p2 = (1 - t) * p1 + t * p2;
        return (1 - t) * p0p1 + t * p1p2;
        */
        // 简化运算:
        var u = 1 - t;
        var tt = t * t;
        var uu = u * u;
        return uu * p0 + 2 * u * t * p1 + tt * p2;
    }

    /// <summary>
    /// 根据t(0-1)计算三阶贝塞尔曲线上面对应的点
    /// </summary>
    /// <param name="p0">第一个点</param>
    /// <param name="p1">第二个点</param>
    /// <param name="p2">第三个点</param>
    /// <param name="p3">第四个点</param>
    /// <param name="t">插值(0-1)</param>
    /// <returns></returns>
    public static Vector3 CaculateCubicBezierPoint(Vector3 p0, Vector3 p1, Vector3 p2, Vector3 p3, float t)
    {
        t = Mathf.Clamp01(t);
        // 原始公式:
        /*
        var p0p1 = (1 - t) * p0 + t * p1;
        var p1p2 = (1 - t) * p1 + t * p2;
        var p2p3 = (1 - t) * p2 + t * p3;
        var p0p1p2 = (1 - t) * p0p1 + t * p1p2;
        var p1p2p3 = (1 - t) * p1p2 + t * p2p3;
        return (1 - t) * p0p1p2 + t * p1p2p3;
        */
        // 简化运算:
        var u = 1 - t;
        var tt = t * t;
        var uu = u * u;
        var ttt = tt * t;
        var uuu = uu * u;
        return uuu * p0 + 3 * uu * t * p1 + 3 * tt * u * p2 + ttt * p3;
    }

    /// <summary>
    /// 根据t(0-1)计算Cutmull-Roll Spline曲线上面对应的点
    /// </summary>
    /// <param name="p0">第一个点</param>
    /// <param name="p1">第二个点</param>
    /// <param name="p2">第三个点</param>
    /// <param name="p3">第四个点</param>
    /// <param name="t">插值(0-1)</param>
    /// <returns></returns>
    public static Vector3 CaculateCRSplinePoint(Vector3 p0, Vector3 p1, Vector3 p2, Vector3 p3, float t)
    {
        t = Mathf.Clamp01(t);
        // 原始公式:
        /*
         Output_point = (-0.5*t*t*t + t*t – 0.5*t) * p0 +
		                (1.5*t*t*t - 2.5*t*t + 1.0) * p1 +
		                (-1.5*t*t*t + 2.0*t*t + 0.5*t) * p2 +
		                (0.5*t*t*t – 0.5*t*t) * p3;
        */
        // 简化运算:
        var tt = t * t;
        var ttt = tt * t;
        return (-0.5f * ttt + tt - 0.5f * t) * p0 +
               (1.5f * ttt - 2.5f * tt + 1) * p1 +
               (-1.5f * ttt + 2 * tt + 0.5f * t) * p2 +
               (0.5f * ttt - 0.5f * tt) * p3;
    }

    /// <summary>
    /// 获取存储的一阶Bezier曲线细分顶点的数组
    /// </summary>
    /// <param name="p0">第一个点</param>
    /// <param name="p1">第二个点</param>
    /// <param name="segmentNum">细分段数</param>
    /// <returns>存储贝塞尔曲线点的数组</returns>
    public static Vector3[] GetLinerList(Vector3 p0, Vector3 p1, int segmentNum)
    {
        segmentNum = Mathf.Clamp(segmentNum, 1, Int32.MaxValue);
        var pathPointNum = segmentNum + 1;
        Vector3[] path = new Vector3[pathPointNum];
        for (int i = 0; i < pathPointNum; i++)
        {
            float t = i / (float)segmentNum;
            Vector3 pathPoint = CaculateLinerPoint(p0, p1, t);
            path[i] = pathPoint;
        }
        return path;
    }

    /// <summary>
    /// 获取存储的二次贝塞尔曲线细分顶点的数组
    /// </summary>
    /// <param name="p0">起始点</param>
    /// <param name="p1">控制点</param>
    /// <param name="p2">目标点</param>
    /// <param name="segmentNum">细分段数</param>
    /// <returns>存储贝塞尔曲线点的数组</returns>
    public static Vector3[] GetBeizerList(Vector3 p0, Vector3 p1, Vector3 p2, int segmentNum)
    {
        segmentNum = Mathf.Clamp(segmentNum, 1, Int32.MaxValue);
        var pathPointNum = segmentNum + 1;
        Vector3[] path = new Vector3[pathPointNum];
        for (int i = 0; i < pathPointNum; i++)
        {
            float t = i / (float)segmentNum;
            Vector3 pathPoint = CaculateBezierPoint(p0, p1, p2, t);
            path[i] = pathPoint;
        }
        return path;
    }

    /// <summary>
    /// 获取存储的三次贝塞尔曲线细分顶点的数组
    /// </summary>
    /// <param name="p0">起始点</param>
    /// <param name="p1">控制点1</param>
    /// <param name="p2">控制点2</param>
    /// <param name="p3">目标点</param>
    /// <param name="segmentNum">细分段数</param>
    /// <returns>存储贝塞尔曲线点的数组</returns>
    public static Vector3[] GetCubicBeizerList(Vector3 p0, Vector3 p1, Vector3 p2, Vector3 p3, int segmentNum)
    {
        segmentNum = Mathf.Clamp(segmentNum, 1, Int32.MaxValue);
        var pathPointNum = segmentNum + 1;
        Vector3[] path = new Vector3[pathPointNum];
        for (int i = 0; i < pathPointNum; i++)
        {
            float t = i / (float)segmentNum;
            Vector3 pathPoint = CaculateCubicBezierPoint(p0, p1, p2, p3, t);
            path[i] = pathPoint;
        }
        return path;
    }

    /// <summary>
    /// 获取存储的Cutmull-Rom Spline曲线细分顶点的数组
    /// </summary>
    /// <param name="p0">起始点</param>
    /// <param name="p1">控制点1</param>
    /// <param name="p2">控制点2</param>
    /// <param name="p3">目标点</param>
    /// <param name="segmentNum">细分段数</param>
    /// <returns>存储Cutmull-Rom Spline曲线点的数组</returns>
    public static Vector3[] GetCRSplineList(Vector3 p0, Vector3 p1, Vector3 p2, Vector3 p3, int segmentNum)
    {
        segmentNum = Mathf.Clamp(segmentNum, 1, Int32.MaxValue);
        var pathPointNum = segmentNum + 1;
        Vector3[] path = new Vector3[pathPointNum];
        for (int i = 0; i < pathPointNum; i++)
        {
            float t = i / (float)segmentNum;
            Vector3 pathPoint = CaculateCRSplinePoint(p0, p1, p2, p3, t);
            path[i] = pathPoint;
        }
        return path;
    }
}

TPath.cs(M个点换算成P个N阶Bezier曲线插值)

/// <summary>
/// 获取线性路线指定比例路点位置
/// </summary>
/// <param name="t"></param>
/// <returns></returns>
private Vector3 GetLinerPoinAt(float t)
{
    var pointNum = CaculatePathPointList.Count;
    var maxPointIndex = pointNum - 1;
    TSegment currentUnderSegment;
    float currentUnderSegmentPercent;
    GetRadioSegmentAndPercent(t, out currentUnderSegment, out currentUnderSegmentPercent);
    if(currentUnderSegment == null)
    {
        return Vector3.zero;
    }
    var firstPointIndex = currentUnderSegment.StartPointIndex;
    var secondPointIndex = Mathf.Clamp(currentUnderSegment.StartPointIndex + 1, 0, maxPointIndex);
    return BezierUtilities.CaculateLinerPoint(CaculatePathPointList[firstPointIndex], CaculatePathPointList[secondPointIndex], currentUnderSegmentPercent);
}

/// <summary>
/// 获取二阶贝塞尔路线指定比例路点位置
/// </summary>
/// <param name="t"></param>
/// <returns></returns>
private Vector3 GetBezierPointAt(float t)
{
    var pointNum = CaculatePathPointList.Count;
    var maxPointIndex = pointNum - 1;
    TSegment currentUnderSegment;
    float currentUnderSegmentPercent;
    GetRadioSegmentAndPercent(t, out currentUnderSegment, out currentUnderSegmentPercent);
    if (currentUnderSegment == null)
    {
        return Vector3.zero;
    }
    var firstPointIndex = currentUnderSegment.StartPointIndex;
    var secondPointIndex = Mathf.Clamp(currentUnderSegment.StartPointIndex + 1, 0, maxPointIndex);
    var thirdPointIndex = Mathf.Clamp(currentUnderSegment.StartPointIndex + 2, 0, maxPointIndex);
    return BezierUtilities.CaculateBezierPoint(CaculatePathPointList[firstPointIndex],
                                               CaculatePathPointList[secondPointIndex],
                                               CaculatePathPointList[thirdPointIndex],
                                               currentUnderSegmentPercent);
}

/// <summary>
/// 获取三阶贝塞尔路线指定比例路点位置
/// </summary>
/// <param name="t"></param>
/// <returns></returns>
private Vector3 GetCubicBezierPointAt(float t)
{
    var pointNum = CaculatePathPointList.Count;
    var maxPointIndex = pointNum - 1;
    TSegment currentUnderSegment;
    float currentUnderSegmentPercent;
    GetRadioSegmentAndPercent(t, out currentUnderSegment, out currentUnderSegmentPercent);
    if (currentUnderSegment == null)
    {
        return Vector3.zero;
    }
    var firstPointIndex = currentUnderSegment.StartPointIndex;
    var secondPointIndex = Mathf.Clamp(currentUnderSegment.StartPointIndex + 1, 0, maxPointIndex);
    var thirdPointIndex = Mathf.Clamp(currentUnderSegment.StartPointIndex + 2, 0, maxPointIndex);
    var fourthPointIndex = Mathf.Clamp(currentUnderSegment.StartPointIndex + 3, 0, maxPointIndex);
    return BezierUtilities.CaculateCubicBezierPoint(CaculatePathPointList[firstPointIndex],
                                                    CaculatePathPointList[secondPointIndex],
                                                    CaculatePathPointList[thirdPointIndex],
                                                    CaculatePathPointList[fourthPointIndex],
                                                    currentUnderSegmentPercent);
}

/// <summary>
/// 获取Cutmull-Roll Spline路线指定比例路点位置
/// </summary>
/// <param name="t"></param>
/// <returns></returns>
private Vector3 GetCRSplinePointAt(float t)
{
    var pointNum = CaculatePathPointList.Count;
    var maxPointIndex = pointNum - 1;
    TSegment currentUnderSegment;
    float currentUnderSegmentPercent;
    GetRadioSegmentAndPercent(t, out currentUnderSegment, out currentUnderSegmentPercent);
    if (currentUnderSegment == null)
    {
        return Vector3.zero;
    }
    var firstPointIndex = currentUnderSegment.StartPointIndex;
    var secondPointIndex = Mathf.Clamp(currentUnderSegment.StartPointIndex + 1, 0, maxPointIndex);
    var thirdPointIndex = Mathf.Clamp(currentUnderSegment.StartPointIndex + 2, 0, maxPointIndex);
    var fourthPointIndex = Mathf.Clamp(currentUnderSegment.StartPointIndex + 3, 0, maxPointIndex);
    return BezierUtilities.CaculateCRSplinePoint(CaculatePathPointList[firstPointIndex],
                                                 CaculatePathPointList[secondPointIndex],
                                                 CaculatePathPointList[thirdPointIndex],
                                                 CaculatePathPointList[fourthPointIndex],
                                                 currentUnderSegmentPercent);
}

/// <summary>
/// 获取指定比例路点所处分段和分段所占比例
/// </summary>
/// <param name="t"></param>
/// <param name="segment"></param>
/// <param name="segmentPercent"></param>
private void GetRadioSegmentAndPercent(float t, out TSegment segment, out float segmentPercent)
{
    var pointNum = PathPointList.Count;
    if (pointNum == 0)
    {
        segment = null;
        segmentPercent = 0f;
        return;
    }
    else if (pointNum == 1)
    {
        segment = SegmentList[0];
        segmentPercent = 1f;
        return;
    }
    t = Mathf.Clamp01(t);
    // 缓动公式对路线插值的影响
    var easeFunc = EasingFunction.GetEasingFunction(Ease);
    t = easeFunc(0, 1, t);
    var distance = t * Length;
    segment = SegmentList[0];
    for (int i = 0, length = SegmentList.Count - 1; i < length; i++)
    {
        distance -= SegmentList[i].Length;
        segment = SegmentList[i];
        if (distance < 0)
        {
            break;
        }
    }
    segmentPercent = (segment.Length + distance) / segment.Length;
}

自定义路点数据编辑面板：

自定义Tile绘制配置面板:

可视化路点路线展示:

自定义路线数据导出：

LineRenderer可视化展示：

Ease插值类型：

$EaseLerpFunction$

M个点的N个3阶Bezier插值计算思路如下：

N个3阶Bezier曲线的组合插值是通过将M个点分成N段3阶Bezier，计算出总长度且每段Bezier存储起始点索引和Bezier类型(影响当前Bezier的采样点数)和路段长度
当我们要计算一个插值比例t(0-1)进度插值计算时，首先根据总距离和进度映射计算出在哪一段Bezier路段
映射计算到对应3阶Bezier段后，再进行单个3阶Bezier曲线比例插值从而得到我们M个点的插值比例t(0-1)的最终插值位置

Cutmull-Rom Spline曲线经过首尾两个控制点思路：

利用Catmull-Rom Spline曲线会通过中间两个控制点且中间两个点经过时的切线与前后两个控制点连线平行，那么我可以可以通过模拟构造一个P(-1)=2P0-P1(确保P(-1)P1和P0切线平行从而确保从P0处切线平行)，利用P(-1)P0P1P2构造一个CatmullRomSpline曲线即可画出P0开始的P0P1的曲线。最后一段曲线同理，构造一个P(N+1)=2P(N)-P(N-1)，然后绘制P(N-2)P(N-1)P(N)P(N+1)即可绘制出P(N-1)P(N)的曲线。

路点类型数据配置

路点类型的自定义数据配置是通过统一定义在TPathPointData结构里，然后结合Inspector绘制决定路点类型是否绘制特定字段决定的。

TPathPointType.cs

/// <summary>
/// TPathPointType.cs
/// 路点类型
/// </summary>
public enum TPathPointType
{
    Invalide = 1,       // 无效路点
    Normal,             // 普通路点类型
    Wait,               // 等待路点类型
    Jump,               // 跳跃路点类型
}

TPathPointData.cs

/// <summary>
/// TPathPointData.cs
/// 路点数据组件
/// </summary>
[Serializable]
public class TPathPointData
{
    /// <summary>
    /// 坐标位置
    /// </summary>
    [Header("坐标位置")]
    public Vector3 Position;

    /// <summary>
    /// 路点类型
    /// </summary>
    [Header("路点类型")]
    public TPathPointType PathPointType = TPathPointType.Normal;

    /// <summary>
    /// 等待路点的等待时长
    /// </summary>
    [Header("等待路点的等待时长")]
    public float WaitTime = 0f;

    /// <summary>
    /// 跳跃路点的跳跃动画名称
    /// </summary>
    [Header("跳跃路点的跳跃动画名称")]
    public string JumpAnimName = string.Empty;
    
    ******
}

TPathDataEditor.cs

 /// <summary>
/// 绘制单个PathPointData属性
/// </summary>
/// <param name="pathPointDataIndex"></param>
private void DrawOnePathPointDataPropertyByIndex(int pathPointDataIndex)
{
    var pathPointDataProperty = mPathPointDataListProperty.GetArrayElementAtIndex(pathPointDataIndex);
    DrawPathPointPositionProperty(pathPointDataIndex, pathPointDataProperty);
    DrawPathPointTypeProperty(pathPointDataIndex, pathPointDataProperty);
    DrawPathPointCustomProperties(pathPointDataIndex, pathPointDataProperty);
}

******

/// <summary>
    /// 绘制指定路点数据索引和路点数据属性的自定义属性
    /// </summary>
    /// <param name="pathPointDataIndex"></param>
    /// <param name="pathPointDataProperty"></param>
    private void DrawPathPointCustomProperties(int pathPointDataIndex, SerializedProperty pathPointDataProperty)
{
    if (pathPointDataProperty == null)
    {
        return;
    }
    var pathPointTypeProperty = pathPointDataProperty.FindPropertyRelative("PathPointType");
    if(pathPointTypeProperty == null)
    {
        return;
    }
    var pathPointType = (TPathPointType)pathPointTypeProperty.intValue;
    switch (pathPointType)
    {
        case TPathPointType.Wait:
            DrawWaitPathPointProperties(pathPointDataIndex, pathPointDataProperty);
            break;
        case TPathPointType.Jump:
            DrawJumpPathPointProperties(pathPointDataIndex, pathPointDataProperty);
            break;
        default:
            break;
    }
}

/// <summary>
/// 绘制指定路点数据索引和路点数据属性的等待路点属性
/// </summary>
/// <param name="pathPointDataIndex"></param>
/// <param name="pathPointDataProperty"></param>
private void DrawWaitPathPointProperties(int pathPointDataIndex, SerializedProperty pathPointDataProperty)
{
    var waitTimeProperty = pathPointDataProperty.FindPropertyRelative("WaitTime");
    if(waitTimeProperty == null)
    {
        return;
    }
    EditorGUILayout.LabelField("等待时长:", GUILayout.Width(60f));
    waitTimeProperty.floatValue = EditorGUILayout.FloatField(waitTimeProperty.floatValue, GUILayout.Width(60f));
}

/// <summary>
/// 绘制指定路点数据索引和路点数据属性的跳跃路点属性
/// </summary>
/// <param name="pathPointDataIndex"></param>
/// <param name="pathPointDataProperty"></param>
private void DrawJumpPathPointProperties(int pathPointDataIndex, SerializedProperty pathPointDataProperty)
{
    var jumpAnimNameProperty = pathPointDataProperty.FindPropertyRelative("JumpAnimName");
    if (jumpAnimNameProperty == null)
    {
        return;
    }
    EditorGUILayout.LabelField("跳跃动画:", GUILayout.Width(60f));
    jumpAnimNameProperty.stringValue = EditorGUILayout.TextField(jumpAnimNameProperty.stringValue, GUILayout.Width(60f));
}

自定义路点类型数据绘制如下:

自定义数据导出

自定义数据导出是通过在TPathData的Inspector面板支持导出类型和自定义导出名字(默认不填取GameObject名，方便制作多个关卡的路点数据)。

在自定义导出数据之前，我通过统一导出结构为TPathDataExport类，然后在通过对应序列化方式实现自定义导出类型支持：

TPathDataExport.cs

/// <summary>
/// TPathDataExport.cs
/// 统一导出数据结构
/// </summary>
[Serializable]
public class TPathDataExport
{
    /// <summary>
    /// 路线类型
    /// </summary>
    [Header("路线类型")]
    public TPathType PathType = TPathType.Normal;

    /// <summary>
    /// 路线绘制类型
    /// </summary>
    [Header("路线绘制类型")]
    public TPathwayType PathwayType = TPathwayType.Liner;

    /// <summary>
    /// 缓动类型
    /// </summary>
    [Header("缓动类型")]
    public EasingFunction.Ease Ease = EasingFunction.Ease.Linear;

    /// <summary>
    /// 是否循环
    /// </summary>
    [Header("是否循环")]
    public bool IsLoop = false;

    /// <summary>
    /// 是否更新朝向
    /// </summary>
    [Header("是否更新朝向")]
    public bool UpdateForward = false;

    /// <summary>
    /// 持续时长
    /// </summary>
    [Header("持续时长")]
    public float Duration = 0f;

    /// <summary>
    /// 每段顶点细分数量
    /// </summary>
    [Header("每段顶点细分数量")]
    [Range(1, 100)]
    public int Segment = 15;

    /// <summary>
    /// 路点数据列表
    /// </summary>
    [Header("路点数据列表")]
    public List<TPathPointData> PathPointDatas = new List<TPathPointData>();

    ******
}

TPathDataEditor.cs

/// <summary>
/// 构建导出统一数据结构
/// </summary>
/// <returns></returns>
private TPathDataExport ConstructPathDataExport()
{
    var pathDataExport = new TPathDataExport();
    pathDataExport.PathType = (TPathType)mPathTypeProperty.intValue;
    pathDataExport.PathwayType = (TPathwayType)mPathwayTypeProperty.intValue;
    pathDataExport.Ease = (EasingFunction.Ease)mEaseProperty.intValue;
    pathDataExport.IsLoop = mIsLoopProperty.boolValue;
    pathDataExport.UpdateForward = mUpdateForwardProperty.boolValue;
    pathDataExport.Duration = mDurationProperty.floatValue;
    pathDataExport.Segment = mSegmentProperty.intValue;
    for (int i = 0, length = mPathPointDataListProperty.arraySize; i < length; i++)
    {
        var pathPointDataProperty = mPathPointDataListProperty.GetArrayElementAtIndex(i);
        var pathPointData = pathPointDataProperty.managedReferenceValue as TPathPointData;
        pathDataExport.AddPathPointData(pathPointData);
    }
    return pathDataExport;
}

/// <summary>
/// 导出路点数据
/// </summary>
private bool ExportPathPointDatas()
{
    if(!CheckCanExportPathPointDatas())
    {
        Debug.LogError($"不满足导出条件，导出路点数据失败！");
        return false;
    }
    CorrectPathPointPositions();
    var exportFileName = mExportFileNameProperty.stringValue;
    if(string.IsNullOrEmpty(exportFileName))
    {
        // 导出文件名为空则用GameObject名
        exportFileName = mTarget.gameObject.name;
    }
    var exportType = (TPathExportType)mExportTypeProperty.intValue;
    var pathType = (TPathType)mPathTypeProperty.intValue;
    var pathDataExport = ConstructPathDataExport();

    var exportFileFullPath = TPathUtilities.GetExportFileFullPath(exportFileName, exportType, pathType);
    var exportFileFolderFullPath = Path.GetDirectoryName(exportFileFullPath);
    FolderUtilities.CheckAndCreateSpecificFolder(exportFileFolderFullPath);

    if(exportType == TPathExportType.Json)
    {
        return DoExportJsonPathPointDatas(exportFileFullPath, pathDataExport, pathType);
    }
    Debug.LogError($"不支持的导出类型:{exportType.ToString()}数据导出！");
    return false;
}

/// <summary>
/// 导出Json格式路点数据
/// </summary>
/// <param name="exportFileFullPath"></param>
/// <param name="pathDataExport"></param>
/// <returns></returns>
private bool DoExportJsonPathPointDatas(string exportFileFullPath, TPathDataExport pathDataExport, TPathType pathType)
{
    if(pathDataExport == null)
    {
        Debug.LogError($"导出Json数据失败，导出数据结构为空！");
        return false;
    }
    var jsonStr = JsonUtility.ToJson(pathDataExport, true);
    File.WriteAllText(exportFileFullPath, jsonStr);
    Debug.Log($"导出Json数据文件全路径:{exportFileFullPath}成功！");
    return true;
}

目前导出的类型只支持了Json，导出后内容如下:

自定义数据导出使用

自定义数据统一导出结构并导出后，我们如何快速使用这个结构进行路点数据模拟移动了？

首先我们要反序列化加载对应导出路点数据：

TPathUtilities.cs

/// <summary>
/// 加载指定导出文件名，导出类型和路点路线类型的TPathDataExport
/// </summary>
/// <param name="exportFileName"></param>
/// <param name="exportType"></param>
/// <param name="pathType"></param>
/// <returns></returns>
public static TPathDataExport LoadTPathDataExport(string exportFileName, TPathExportType exportType = TPathExportType.Json,
                                                  TPathType pathType = TPathType.Normal)
{
    // 不同的资源加载方式请自行封装
    var exportFileFullPath = GetExportFileFullPath(exportFileName, exportType, pathType);
    var exportAssetFileRelativePath = PathUtilities.GetAssetsRelativeFolderPath(exportFileFullPath);
    var pathDataExportAsset = AssetDatabase.LoadAssetAtPath<TextAsset>(exportAssetFileRelativePath);
    var pathDataExport = JsonUtility.FromJson<TPathDataExport>(pathDataExportAsset.text);
    if(pathDataExport == null)
    {
        Debug.LogError($"加载导出文件:{exportAssetFileRelativePath}失败，无法获取有效的TPathDataExport！");
        return null;
    }
    return pathDataExport;
}

然后使用封装好的TPathTweenerManager.DoPathTweenByTPathDataExport()接口快速使用：

/// <summary>
/// 相应开始路线移动按钮点击
/// </summary>
private void OnBtnStartPathMove()
{
    Debug.Log($"GameLaucher:OnBtnStartPathMove()");
    if(mPathTweener != null)
    {
        TPathTweenerManager.Singleton.RemovePathTween(mPathTweener);
        mPathTweener = null;
    }
    if(mLoadedPathDataExport == null)
    {
        Debug.LogError($"没有加载有效的路点数据，无法开始路线缓动！");
        return;
    }
    mPathTweener = TPathTweenerManager.Singleton.DoPathTweenByTPathDataExport(PathMoveGo.transform, mLoadedPathDataExport, ***)
}

路点运行回调

目前路点运行回调支持了移动完成，经过路点，循环开始三个回调时机。

完成和循环开始主要是通过比较进度判定完成，经过路点的判定是通过一开始记录了所有的路点对应进度数据，然后结合当前进度去比较是否跨过下一个路点的进度来判定的。

TPathTeewner.cs

/// <summary>
/// 更新
/// </summary>
/// <param name="deltaTime"></param>
public void Update(float deltaTime)
{
    if(IsPaused)
    {
        return;
    }
    var preProgress = GetTimeProgress(mTimePassed);
    mTimePassed += deltaTime;
    var newProgress = GetTimeProgress(mTimePassed);
    // 先修改位置，后触发循环开始和路点经过相关事件
    UpdateTargetByPercent(newProgress);
    if(IsLoop && newProgress < preProgress)
    {
        // 触发循环
        OnPathLoopStart();
    }
    if (CheckPathPointReached(preProgress, newProgress, out int reachedIndex))
    {
        OnPassPathPoint(reachedIndex);
    }
    if (!IsLoop && Mathf.Approximately(newProgress, 1))
    {
        OnPathTweenComplete();
    }
}

/// <summary>
/// 检查路点抵达的情况
/// </summary>
/// <param name="newProgress"></param>
/// <param name="reachedIndex"></param>
/// <returns></returns>
private bool CheckPathPointReached(float newProgress, out int reachedIndex)
{
    reachedIndex = -1;
    if(mPath == null)
    {
        return false;
    }
    var pointNum = mPath.GetPointNum();
    if(pointNum <= 0)
    {
        return false;
    }
    for(int i = mNextPathPointIndex; i < pointNum; i++)
    {
        var pointRatio = mPath.GetPointRatioByIndex(i);
        if(newProgress >= pointRatio)
        {
            reachedIndex = i;
            return true;
        }
        else
        {
            break;
        }
    }
    return false;
}

运行时加载导出路点数据进行路点移动播放就会得到如下结果：

GameLauncher.cs

/// <summary>
/// 相应开始路线移动按钮点击
/// </summary>
private void OnBtnStartPathMove()
{
    Debug.Log($"GameLaucher:OnBtnStartPathMove()");
    if(mPathTweener != null)
    {
        TPathTweenerManager.Singleton.RemovePathTween(mPathTweener);
        mPathTweener = null;
    }
    if(mLoadedPathDataExport == null)
    {
        Debug.LogError($"没有加载有效的路点数据，无法开始路线缓动！");
        return;
    }
    mPathTweener = TPathTweenerManager.Singleton.DoPathTweenByTPathDataExport(PathMoveGo.transform, mLoadedPathDataExport,
                                                                              () =>
                                                                              {
                                                                                  Debug.Log($"运行时路线缓动完成！");
                                                                                  mPathTweener = null;
                                                                              },
                                                                              (index) =>
                                                                              {
                                                                                  Debug.Log($"经过路点:{index}");
                                                                                  var pathPointData = mLoadedPathDataExport.GetPathPointData(index);
                                                                                  if(pathPointData != null)
                                                                                  {
                                                                                      Debug.Log($"路点数据:{pathPointData.ToString()}");
                                                                                  }
                                                                              },
                                                                              () =>
                                                                              {
                                                                                  Debug.Log($"路线缓动循环开始！");
                                                                              });
}

可以看到通过对应回调我们访问对应路点数据已经可以拿到路点类型+自定义路点数据了，如果未来想根据路点类型进行DIY逻辑编写，则可以直接在回调里访问数据编写对应逻辑即可。

TODO:

将运行时使用TPathTweenerManager运动的曲线支持可配置化可视化绘制

学习总结

Bezier曲线是一个N个点之间递归插值计算的过程
复杂的很多点路线插值一般不会采用N阶Bezier曲线插值而是采用换算成N个3阶Bezier曲线插值的方式降低计算复杂度
Catmull-Rom Spline确保通过首尾控制点是通过插入头尾两个虚拟点的方式实现的。
缓动结合Bezier曲线的使用主要体现在最后一步插值时对t值的运算替换上
纯Editor模拟更新驱动需要InitializeOnLoad，ExecuteInEditMode和InitializeOnLoadMethod标签加EditorApplication.update实现即使代码编译后也能正确注入和取消EditorApplication.update的流程
LineRenerer默认useWorldSpace为true，表示设置的SetPositions是世界坐标。
LineRenderer有两种朝向显示模式Alignment.View和Alignment.TransformZ，前者是类似BillBoard朝向摄像机，后者是朝向Z轴，一般纯3D路线个人觉得应该是后者加上旋转的方式。
LineRenderer的纹理渲染(Texture Mode)方式有四种，Stretch(使用单次纹理拉伸铺满的方式)，Tile(重复显示，渲染里Tile的概念，基于世界单位长度细分，使用Material.SetTextureScale来设置重复多少次纹理填充)，DistributePerSegment(好像是每个顶点间映射一次纹理，默认假设顶点间间距已经平均好了)，RepeatPerSegment(重复显示纹理，使用Material.SetTextureScale来设置重复多少次纹理填充)。
LineRenderer修改Width后如果细分的点不够多，可能出现即使连接的是直线也在拐角处显示有问题，需要细分更多的点来解决此问题。

Github

个人Github:

数学缓动

UnityEditor知识

Reference

Unity 之贝塞尔曲线介绍和实际使用

unity利用高阶贝塞尔曲线进行的轨道移动

Bezier Curve 贝塞尔曲线 - 在Unity中实现路径编辑

bezier-curves-unity-package-included

贝塞尔曲线

Bezier Curves

Catmull-Rom插值算法

插值技术之Catmull-Rom Spline Interpolating(2)

EmmyLua注释生成工具

By Tony Tang

发表于 2023-03-10

前言

本章节是为了记录Lua开发过程中，关于EmmyLua插件的CSharp注释生成工具的编写和使用介绍。

项目需求需要用到Lua作为开发语言，众所周知Lua是弱类型解析执行语言，所以即使在IDE的加持下，开发和协同效率都会比较低。从而为了提高Lua开发效率，EmmyLua这个第三方插件诞生了，他提供了Lua调试以及Lua注释编写解析后类型推断提示等功能。

正是因为EmmyLua的类型推断是基于我们的代码注释而来的，所以我们在Lua开发过程中，想要快速得到CSharp等代码类的访问提示，那我们就需要生成对应的CS的Lua注释代码，此工具正是为了生成项目里CSharp代码的EmmyLua注释而生的。

目标

高度可配置化的CSharp代码EmmyLua注释生成工具

需求

自定义配置需求:

支持配置不同导出类型输出目录
支持配置指定Assemble不参与导出(加入黑名单)
支持配置指定Assemble的导出分类**
支持配置指定Assemble，Namespace，Type是否导出EmmyLua注释
支持勾选一键嵌套勾选导出设置

CSharp导出需求:

类(e.g. 普通类, 抽象类)
接口
值类型(含枚举)
成员，属性，方法，event

Note:

不支持匿名类，泛型类，代码生成类和代码生成类内部类
不支持泛型成员，泛型属性，泛型方法，泛型*

设计

基于项目CS代码，通过反射获取访问所有Assemble以及相关类型信息数据统计读取，结合Unity Editor窗口工具实现可视化自定义勾选类型注释导出的高度可配置工具。

知识点主要是反射和简单的EditorGUI编写。

设计代码就不详细讲解了，源代码链接:

EmmyLuaGenerator

这里主要提一下在判定哪些类型需要参与导出时的一些核心类型判定代码：

判定是否是委托

/// <summary>
/// 委托类型
/// </summary>
private static Type DelegateType = typeof(Delegate);

/// <summary>
/// 指定类型是否是委托相关类型
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
private static bool IsDelegateAssignableType(Type type)
{
    return DelegateType.IsAssignableFrom(type);
}

判定是否是编译生成类型(e.g. 匿名类)

/// <summary>
/// 编译类型属性类型
/// </summary>
private static Type CompilerGeneratedAttributeType = typeof(CompilerGeneratedAttribute);

/// <summary>
/// 指定类型是否是编译生成类型(e.g. 匿名类)
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
private static bool IsCompilerType(Type type)
{
    return Attribute.GetCustomAttribute(type, CompilerGeneratedAttributeType) != null;
}

判定是否是嵌套在编译生成类型里的类型(e.g. 匿名内部类)

/// <summary>
/// 指定类型是否是编译生成类型(e.g. 匿名类)
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
private static bool IsCompilerType(Type type)
{
    return Attribute.GetCustomAttribute(type, CompilerGeneratedAttributeType) != null;
}

/// <summary>
/// 指定类型是否嵌套在编译生成类型里的类型(e.g. 匿名类)
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
private static bool IsNestedCompilerType(Type type)
{
    if(!type.IsNested || type.DeclaringType == null)
    {
        return false;
    }
    if(IsCompilerType(type.DeclaringType))
    {
        return true;
    }
    else
    {
        return IsNestedCompilerType(type.DeclaringType);
    }
}

判定是否是可空类型

/// <summary>
/// 是否是Nullable类型
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
private static bool IsNullableType(Type type)
{
    return Nullable.GetUnderlyingType(type) != null;
}

判定是否是数值类型

/// <summary>
/// 数值类型HashSet
/// </summary>
private static HashSet<Type> NumericHashSet = new HashSet<Type>
{
    typeof(Byte), typeof(SByte), typeof(Int16), typeof(Int32), typeof(Int64),
    typeof(uint), typeof(UInt16), typeof(UInt32), typeof(UInt64), typeof(BigInteger),
    typeof(float), typeof(double), typeof(decimal), typeof(Single),
};

/// <summary>
/// 是否是数值类型
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
private static bool IsNumericType(Type type)
{
    return NumericHashSet.Contains(type);
}

判定是否是Unity遗弃数据(类，成员，方法…….)

1 2	// Unity标记遗弃的成员 var isObsoleteField = Attribute.GetCustomAttribute(fieldInfo, ObsoleteAttributeType);

实战使用

工具入口
EmmyLua注释生成器编辑窗口
自定义导出Assemble，Namespace和Class勾选
生成EmmyLua注释

从上面可以看到，我把项目代码的导出分类，归为5类:

Unity代码
DotNet代码
项目代码
FGUI代码
第三方代码

通过给每一个Assemble配置导出分类可以实现指定Assemble的EmmyLua注释导出到指定输出目录。

最后让我们来看看导出的EmmyLua代码:

项目PathUtilities注释生成

---@class CS.PathUtilities : CS.System.Object
local PathUtilities = {}
---@param path string @
---@return string @
function PathUtilities.GetRegularPath(path) end

---@param path string @
---@return string @
function PathUtilities.GetFolderName(path) end

---@param folderFullPath string @
---@return string @
function PathUtilities.GetAssetsRelativeFolderPath(folderFullPath) end

---@return string @
function PathUtilities.GetProjectPath() end

---@return string @
function PathUtilities.GetProjectFullPath() end

---@param folderfullpath string @
---@return string @
function PathUtilities.GetProjectRelativeFolderPath(folderfullpath) end

---@param assetpath string @
---@return string @
function PathUtilities.GetAssetFullPath(assetpath) end

---@param path string @
---@param postFix string @
---@return string @
function PathUtilities.GetPathWithoutPostFix(path, postFix) end

return PathUtilities

C#的System.Object注释生成

---@class CS.System.Object
local Object = {}
---@param obj CS.System.Object @
---@return boolean @
function Object:Equals(obj) end

---@return number @
function Object:GetHashCode() end

---@return CS.System.Type @
function Object:GetType() end

---@return string @
function Object:ToString() end

---@param objA CS.System.Object @
---@param objB CS.System.Object @
---@return boolean @
function Object.Equals(objA, objB) end

---@param objA CS.System.Object @
---@param objB CS.System.Object @
---@return boolean @
function Object.ReferenceEquals(objA, objB) end

return Object

Unity的UnityEngine.Object注释生成

---@class CS.UnityEngine.Object : CS.System.Object
local Object = {}
---@field public name string @
---@field public hideFlags number @
---@return number @
function Object:GetInstanceID() end

---@return number @
function Object:GetHashCode() end

---@param other CS.System.Object @
---@return boolean @
function Object:Equals(other) end

---@return string @
function Object:ToString() end

---@param original CS.UnityEngine.Object @
---@param position CS.UnityEngine.Vector3 @
---@param rotation CS.UnityEngine.Quaternion @
---@return CS.UnityEngine.Object @
function Object.Instantiate(original, position, rotation) end

---@param original CS.UnityEngine.Object @
---@param position CS.UnityEngine.Vector3 @
---@param rotation CS.UnityEngine.Quaternion @
---@param parent CS.UnityEngine.Transform @
---@return CS.UnityEngine.Object @
function Object.Instantiate(original, position, rotation, parent) end

---@param original CS.UnityEngine.Object @
---@return CS.UnityEngine.Object @
function Object.Instantiate(original) end

---@param original CS.UnityEngine.Object @
---@param parent CS.UnityEngine.Transform @
---@return CS.UnityEngine.Object @
function Object.Instantiate(original, parent) end

---@param original CS.UnityEngine.Object @
---@param parent CS.UnityEngine.Transform @
---@param instantiateInWorldSpace boolean @
---@return CS.UnityEngine.Object @
function Object.Instantiate(original, parent, instantiateInWorldSpace) end

---@param obj CS.UnityEngine.Object @
---@param t number @
function Object.Destroy(obj, t) end

---@param obj CS.UnityEngine.Object @
function Object.Destroy(obj) end

---@param obj CS.UnityEngine.Object @
---@param allowDestroyingAssets boolean @
function Object.DestroyImmediate(obj, allowDestroyingAssets) end

---@param obj CS.UnityEngine.Object @
function Object.DestroyImmediate(obj) end

---@param type CS.System.Type @
---@return CS.UnityEngine.Object[] @
function Object.FindObjectsOfType(type) end

---@param type CS.System.Type @
---@param includeInactive boolean @
---@return CS.UnityEngine.Object[] @
function Object.FindObjectsOfType(type, includeInactive) end

---@param target CS.UnityEngine.Object @
function Object.DontDestroyOnLoad(target) end

---@param type CS.System.Type @
---@return CS.UnityEngine.Object @
function Object.FindObjectOfType(type) end

---@param type CS.System.Type @
---@param includeInactive boolean @
---@return CS.UnityEngine.Object @
function Object.FindObjectOfType(type, includeInactive) end

return Object

更多的注释生成就不一一展示了，可以看到通过EmmyLua注释生成工具，我已经成功的实现了导出EmmyLua注释的高度自由的自定义配置，并且基于该配置成功生成了符合EmmyLua注释规则的Lua代码，有了这个工具，我们就可以根据项目的自定义需求快速实现导出相关类型EmmyLua注释代码了。从而实现利用EmmyLua的注释类型推断功能帮助我们高效的编写Lua代码了。

Note:

以上我只选了一些常规的Assemble和类型参与导出，需要更多的自定义导出可自行配置。
上述我只支持了5种导出类型分类，想要自定义更多分类可自行修改源码。
为了GUI显示效率，这里最大Assemble分析数量限制了75，大部分项目Assemble数量会远超75，但真正需要导出的Assemble数量一般不会超过75，也就是说设置完Assemble黑名单后，75最大Assemble显示数量是满足使用需求的，不足的话自行修改。
想触发CS脚本代码分析可保存配置后重新打开EmmyLua代码生成窗口即可。

Reference

EmmyLua注释编写规范

GitHub

EmmyLua

EmmyLuaGenerator

异步编程

By Tony Tang

发表于 2022-10-12

前言

游戏开发过程中为了无论资源加载异步还是逻辑异步，异步都是不可或缺的一部分。本章节是为了深入理解C#的异步编程以及Unity里异步编程使用而编写。

异步编程

Unity里最初的模拟异步编程概念的当之无愧是携程，但携程实际上是单线程通过每帧等待实现异步模拟运行的而非真正的异步编程。

异步编程的过程中我们往往会采用回调式的方式来编写代码，这回导致回调地狱，导致代码理解起来比较困难，有了Task异步编程我们可以实现类似同步式的代码编写来编写异步代码。

而本章节的重点是真正深入了解异步编程，C#里的最新的异步编程主要是通过Task

Task-based Asynchronous Pattern(TAP)

The core of async programming is the Task and Task objects, which model asynchronous operations. They are supported by the async and await keywords.

TAP uses a single method to represent the initiation and completion of an asynchronous operation.

从上面的介绍可以看出异步编程的核心是Task实现了异步操作，并且支持async和await关键词，其次TAP通过方法定义就完成了所有的异步操作初始化和方法定义。

注意事项

await can only be used inside an async method.(await只能用在async标记的方法内)
async methods need to have an await keyword in their body or they will never yield!(async标记的方法需要一个await关键词在方法定义内，不然这个异步方法不会暂停会同步执行)

Task

The Task class represents a single operation that does not return a value and that usually executes asynchronously. Task objects are one of the central components of the task-based asynchronous pattern first introduced in the .NET Framework 4. Because the work performed by a Task object typically executes asynchronously on a thread pool thread rather than synchronously on the main application thread, you can use the Status property, as well as the IsCanceled, IsCompleted, and IsFaulted properties, to determine the state of a task.

从介绍可以看出，异步编程主要是通过Task类的抽象，而Task的异步编程底层伴随着线程池，我们使用的人可以不用关心底层线程池的优化调度问题。通过Task抽象异步编程，Task可以返回异步运行状态IsCanceled,IsCompleted,IsFaulted等来查看异步运行状态。

通过实战使用，了解下Task的基础使用以及底层跨线程的设计:

Task基础使用

/// <summary>
/// 响应基础Task使用按钮点击
/// </summary>
public void OnBtnBasicTaskUsingClick()
{
    // 创建一个Task1但不开始
    Task task1 = new Task(mTaskActionDelegate, "Task1");
    // 通过Task工厂创建一个Task2并等待完成
    Task task2 = Task.Factory.StartNew(mTaskActionDelegate, "Task2");
    task2.Wait();
    // Task1开始
    task1.Start();
    Debug.Log($"Task1 has been launched. Main Thread:{Thread.CurrentThread.ManagedThreadId}");
    // 等待Task1完成
    task1.Wait();
    // 通过Task.Run创建Task3并等待完成
    Task task3 = Task.Run(()=>
                          {
                              Debug.Log($"ActionName:Task3");
                              Debug.Log($"Task:{Task.CurrentId} Thread:{Thread.CurrentThread.ManagedThreadId}");
                          });
    Debug.Log($"Task3 has been launched. Main Thread:{Thread.CurrentThread.ManagedThreadId}");
    task3.Wait();
}

/// <summary>
/// Task使用方法
/// </summary>
/// <param name="actionName"></param>
private void TaskAction(object actionName)
{
    Debug.Log($"ActionName:{actionName}");
    Debug.Log($"Task:{Task.CurrentId} Thread:{Thread.CurrentThread.ManagedThreadId}");
}

从上面的Task尝试可以看出，Task是在不同线程开启的，其次Task如果是单独的New是不会自动开始的，Task.Run和Task.Factory.StartNew才会直接开始一个Task。

Task使用Async和Await实现异步方法定义和等待

/// <summary>
/// 响应Task等待按钮点击 
/// </summary>
private async void OnBtnAwaitTaskUsingClick()
{
    var awaitTask = Task.Run(AwaitTaskAction);
    Debug.Log($"AwaitTaskAction has been launched. Main Thread:{Thread.CurrentThread.ManagedThreadId}");
    var sumResult = await awaitTask;
    Debug.Log($"sumResult:{sumResult}");
    Debug.Log($"DateTime.Now.Millisecond:{DateTime.Now.Millisecond}");
}

/// <summary>
/// 等待的Task方法
/// </summary>
/// <returns></returns>
private async Task<int> AwaitTaskAction()
{
    Debug.Log($"AwaitTaskAction Start");
    Debug.Log($"DateTime.Now.Millisecond:{DateTime.Now.Millisecond}");
    await Task.Delay(1000);
    Debug.Log($"AwaitTaskAction After Task.Delay(1)");
    Debug.Log($"DateTime.Now.Millisecond:{DateTime.Now.Millisecond}");
    int sum = 0;
    for(int i = 0; i < 1000000000; i++)
    {
        sum++;
    }
    await Task.Delay(2000);
    Debug.Log($"AwaitTaskAction End");
    Debug.Log($"DateTime.Now.Millisecond:{DateTime.Now.Millisecond}");
    return sum;
}

通过Async关键词，我把OnBtnAwaitTaskUsingClick和AwaitTaskAction方法都定义成了异步方法(既可以通过Task异步调用的方法)。然后结合Await关键词实现了等待异步方法AwaitTaskAction执行完后返回运算结果并打印的效果，可以看到这样一来我们的异步代码编写结合Await关键词就跟同步代码一般是一个线性流程，同时异步方法内通过Task.Delay等类似携程的等待方法实现指定时间指定条件的等待。

那么Async和Await关键词是如何实现异步等待效果的了，让我们结合反编译看一下底层实现:

[AsyncStateMachine(typeof (GameLauncher.<OnBtnAwaitTaskUsingClick>d__9))]
[DebuggerStepThrough]
private void OnBtnAwaitTaskUsingClick()
{
    GameLauncher.<OnBtnAwaitTaskUsingClick>d__9 stateMachine = new GameLauncher.<OnBtnAwaitTaskUsingClick>d__9();
    stateMachine.<>4__this = this;
    stateMachine.<>t__builder = AsyncVoidMethodBuilder.Create();
    stateMachine.<>1__state = -1;
    stateMachine.<>t__builder.Start<GameLauncher.<OnBtnAwaitTaskUsingClick>d__9>(ref stateMachine);
}

[AsyncStateMachine(typeof (GameLauncher.<AwaitTaskAction>d__10))]
[DebuggerStepThrough]
private Task<int> AwaitTaskAction()
{
    GameLauncher.<AwaitTaskAction>d__10 stateMachine = new GameLauncher.<AwaitTaskAction>d__10();
    stateMachine.<>4__this = this;
    stateMachine.<>t__builder = AsyncTaskMethodBuilder<int>.Create();
    stateMachine.<>1__state = -1;
    stateMachine.<>t__builder.Start<GameLauncher.<AwaitTaskAction>d__10>(ref stateMachine);
    return stateMachine.<>t__builder.Task;
}

[CompilerGenerated]
private sealed class <OnBtnAwaitTaskUsingClick>d__9 : IAsyncStateMachine
{
    public int <>1__state;
    public AsyncVoidMethodBuilder <>t__builder;
    public GameLauncher <>4__this;
    private Task<int> <awaitTask>5__1;
    private int <sumResult>5__2;
    private int <>s__3;
    private TaskAwaiter<int> <>u__1;

    public <OnBtnAwaitTaskUsingClick>d__9()
    {
        base..Ector();
    }

    void IAsyncStateMachine.MoveNext()
    {
        int num1 = this.<>1__state;
        try
        {
            TaskAwaiter<int> awaiter;
            int num2;
            if (num1 != 0)
            {
                this.<awaitTask>5__1 = Task.Run<int>(new Func<Task<int>>((object) this.<>4__this, __methodptr(AwaitTaskAction)));
                Debug.Log((object) string.Format("AwaitTaskAction has been launched. Main Thread:{0}", (object) Thread.CurrentThread.ManagedThreadId));
                awaiter = this.<awaitTask>5__1.GetAwaiter();
                if (!awaiter.IsCompleted)
                {
                    this.<>1__state = num2 = 0;
                    this.<>u__1 = awaiter;
                    GameLauncher.<OnBtnAwaitTaskUsingClick>d__9 stateMachine = this;
                    this.<>t__builder.AwaitUnsafeOnCompleted<TaskAwaiter<int>, GameLauncher.<OnBtnAwaitTaskUsingClick>d__9>(ref awaiter, ref stateMachine);
                    return;
                }
            }
            else
            {
                awaiter = this.<>u__1;
                this.<>u__1 = new TaskAwaiter<int>();
                this.<>1__state = num2 = -1;
            }
            this.<>s__3 = awaiter.GetResult();
            this.<sumResult>5__2 = this.<>s__3;
            Debug.Log((object) string.Format("sumResult:{0}", (object) this.<sumResult>5__2));
            Debug.Log((object) string.Format("DateTime.Now.Millisecond:{0}", (object) DateTime.Now.Millisecond));
        }
        catch (Exception ex)
        {
            this.<>1__state = -2;
            this.<awaitTask>5__1 = (Task<int>) null;
            this.<>t__builder.SetException(ex);
            return;
        }
        this.<>1__state = -2;
        this.<awaitTask>5__1 = (Task<int>) null;
        this.<>t__builder.SetResult();
    }

    [DebuggerHidden]
    void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine)
    {
    }
}

[CompilerGenerated]
private sealed class <AwaitTaskAction>d__10 : IAsyncStateMachine
{
    public int <>1__state;
    public AsyncTaskMethodBuilder<int> <>t__builder;
    public GameLauncher <>4__this;
    private int <sum>5__1;
    private int <i>5__2;
    private TaskAwaiter <>u__1;

    public <AwaitTaskAction>d__10()
    {
        base..Ector();
    }

    void IAsyncStateMachine.MoveNext()
    {
        int num1 = this.<>1__state;
        int sum51;
        try
        {
            TaskAwaiter awaiter1;
            int num2;
            TaskAwaiter awaiter2;
            if (num1 != 0)
            {
                if (num1 != 1)
                {
                    Debug.Log((object) "AwaitTaskAction Start");
                    Debug.Log((object) string.Format("DateTime.Now.Millisecond:{0}", (object) DateTime.Now.Millisecond));
                    awaiter1 = Task.Delay(1000).GetAwaiter();
                    if (!awaiter1.IsCompleted)
                    {
                        this.<>1__state = num2 = 0;
                        this.<>u__1 = awaiter1;
                        GameLauncher.<AwaitTaskAction>d__10 stateMachine = this;
                        this.<>t__builder.AwaitUnsafeOnCompleted<TaskAwaiter, GameLauncher.<AwaitTaskAction>d__10>(ref awaiter1, ref stateMachine);
                        return;
                    }
                }
                else
                {
                    awaiter2 = this.<>u__1;
                    this.<>u__1 = new TaskAwaiter();
                    this.<>1__state = num2 = -1;
                    goto label_12;
                }
            }
            else
            {
                awaiter1 = this.<>u__1;
                this.<>u__1 = new TaskAwaiter();
                this.<>1__state = num2 = -1;
            }
            awaiter1.GetResult();
            Debug.Log((object) "AwaitTaskAction After Task.Delay(1)");
            DateTime now = DateTime.Now;
            Debug.Log((object) string.Format("DateTime.Now.Millisecond:{0}", (object) now.Millisecond));
            this.<sum>5__1 = 0;
            for (this.<i>5__2 = 0; this.<i>5__2 < 1000000000; ++this.<i>5__2)
                ++this.<sum>5__1;
            awaiter2 = Task.Delay(2000).GetAwaiter();
            if (!awaiter2.IsCompleted)
            {
                this.<>1__state = num2 = 1;
                this.<>u__1 = awaiter2;
                GameLauncher.<AwaitTaskAction>d__10 stateMachine = this;
                this.<>t__builder.AwaitUnsafeOnCompleted<TaskAwaiter, GameLauncher.<AwaitTaskAction>d__10>(ref awaiter2, ref stateMachine);
                return;
            }
            label_12:
            awaiter2.GetResult();
            Debug.Log((object) "AwaitTaskAction After Task.Delay(2)");
            now = DateTime.Now;
            Debug.Log((object) string.Format("DateTime.Now.Millisecond:{0}", (object) now.Millisecond));
            Debug.Log((object) "AwaitTaskAction End");
            now = DateTime.Now;
            Debug.Log((object) string.Format("DateTime.Now.Millisecond:{0}", (object) now.Millisecond));
            sum51 = this.<sum>5__1;
        }
        catch (Exception ex)
        {
            this.<>1__state = -2;
            this.<>t__builder.SetException(ex);
            return;
        }
        this.<>1__state = -2;
        this.<>t__builder.SetResult(sum51);
    }

    [DebuggerHidden]
    void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine)
    {
    }
}

上面的代码是通过dotPeek(NetReflector也可以是付费软件，使用结束后就用不了了)才反编译出来的，之前试过ILSpy和DnSpy都得不到d__9类定义相关反编译代码。

通过上面的代码可以看到，通过async定义异步方法后，编译器帮我们生成了继承至IAsyncStateMachine的d__9和d__10类，这个两个类正是实现异步的一个关键抽象(个人理解有点像携程里的迭代器封装逻辑代码调用)。

触发OnBtnAwaitTaskUsingClick()方法调用
构建d__9类实例对象状态机，初始化<>t_builder()(AsyncVoidMethodBuilder类型–异步任务构建器，用于保存异步任务结果相关)，这里因为OnBtnAwaitTaskUsingClick是void返回类型，所以构建的是AsyncVoieMethodBuilder类对象。初始化状态机<>1__state值为-1
调用stateMachine.<>t__builder.Start<GameLauncher.d__9>(ref stateMachine)触发状态机的MoveNext()的代码执行。
因为<>1__state状态值为-1，所以执行构建5__1(Task类型)的异步AwaitTaskAction执行(默认Task.Run走线程池，所以会运行在不同线程)
这一步AwaitTaskAction异步代码就开始执行了，首先构建d__10类实例对象状态机，初始化<>t__builder(AsyncTaskMethodBuilder类型–异步任务构造器，用于保存异步任务结果相关)，这里是因为AwaitTaskAction是Task返回类型，所以构建的是AsyncTaskMethodBuilder类型对象。初始化状态机<>1__state值为-1
调用stateMachine.<>t__builder.Start<GameLauncher.d__10>(ref stateMachine)触发状态机的MoveNext()的代码执行，然后通过d__10.<>t__builder.Task返回AwaitTaskAction的异步任务对象
因为<>1___state状态值为-1，所以首先执行**”AwaitTaskAction Start”**打印，然后获取延迟1秒Task.Delay(1).GetAwaiter()的异步等待完成对象awaiter1
因为Task.Run默认走线程池，所以这里可能回到主线程执行，触发**”AwaitTaskAction has been launched. Main Thread:{Thread.CurrentThread.ManagedThreadId}”**的打印
接着5__1.GetAwaiter()获取AwaitTaskAction的异步等待完成对象(TaskAwaiter类型继承至ICriticalNotifyCompletion)，5__1.IsCompleted判定异步没有完成，将<>1__state状态机值设置成0,并保存5__1(AwaitTaskAction的异步任务)到<>u__1
然后调用d__9.<>t__builder.AwaitUnsafeOnCompleted(ref awaiter, ref statemachine)触发等待AwaitTaskAction等待异步任务完成(异步任务完成后会自动触发状态机的MoveNext()触发状态机继续执行)
主线程d__9状态机在等待AwaitTaskAction异步任务完成，所以Task.Run在另一个线程运行的d__10状态机又得到机会运行
d__10.awaiter1.IsCompleted判定异步没有完成，状态机<>1__state值设置为0，d__10的异步等待完成对象<>u__1设置成awaiter1(即Task.Delay(1)的异步任务等待完成对象)，然后调用<>t__builder.AwaitUnsafeOnCompleted(ref awaiter1, ref statemachine)触发等待一秒等待异步任务完成(异步任务完成后会自动触发状态机的MoveNext()触发状态机继续执行)
等待一秒过后，Task.Delay(1)异步任务完成，触发__d__10状态机的MoveNext执行，此时状态机<>1__state值为0，将Task.Delay(1).GetAwaiter()对象保存到awaiter1，<>u__1构建一个新的TaskAwaiter()对象，<>1__state状态机值设置成-1，然后调用awaiter1.GetResult()结束异步任务完成等待(因为是Task.Delay(1)所以没有结果需要保存)，此时打印**”AwaitTaskAction After Task.Delay(1)**
然后开始计算for循环累加的代码，初始化5__1为0，执行5__1的循环累加
累加执行完成后执行Task.Delay(2)，此时保存Task.Delay(2).GetAwaiter()的异步等待完成对象到awaiter2，awaiter2.IsCompleted判定异步没有完成，将<>1__state状态机值设置成1,并保存Task.Delay(2).GetAwaiter()到<>u__1，然后调用<>t__builder.AwaitUnsafeOnCompleted(ref awaiter2, ref statemachine)触发等待两秒等待异步任务完成(异步任务完成后会自动触发状态机的MoveNext()触发状态机继续执行)
等待两秒过后，Task.Delay(2)异步任务完成，触发__d__10状态机的MoveNext执行，此时状态机<>1__state值为1，执行awaiter2保存<>u__1(Task.Delay(2).GetAwaiter()的异步任务等待完成对象)，同时构建一个新的TaskAwaiter()赋值给<>u__1，并设置**<>1__stat状态机值到-1**
然后直接跳转到代码label_12标签片段，此时Task.Delay(2)异步任务已经完成，调用awaiter.GetResult()直接触发异步任务完成等待
紧接着打印**”AwaitTaskAction After Task.Delay(2)”并将累加结果5__1保存到sum51成员变量，然后将状态机<>1__state值设置成-2**同时将累加结果sum51通过<>t__builder(**AsyncTaskMethodBuilder类型)调用SetResult(sum51)将AwaitTaskAction()方法调用的返回结果设置到异步任务构建器里
上面一套流程下来，AwaitTaskAction的异步代码就算是执行完成了(即d__9状态机里Task.Run(new Func<Task>((object) this.<>4__this, __methodptr(AwaitTaskAction)))的异步方法执行完成了)，d__9.<>t__builder.AwaitUnsafeOnCompleted()监听到异步任务完成，触发d__9的MoveNext()执行
此时d__9.<>1__state状态机值为0，执行awaiter保存<>u__1(AwaitTaskAction的异步任务等待完成对象)，新创建一个TaskAwaiter异步任务等待完成对象并设置给<>u__1，同时<>1__state状态机值设置成-1
调用awaiter.GetResult()获取AwaitTaskAction异步任务结果并存储到d__9.<>s__3和d__9.5__2
打印**”sumResult:{sumResult}”**，将<>1__state状态机值设置成-2，5__1存储的AwaitTaskAction异步任务置空
最后通过d__9.<>t__builder:SetResult()标记OnBtnAwaitTaskUsingClick的异步任务完成和设置结果(因为OnBtnAwaitTaskUsingClick是void返回所以无需设置结果值)

就这样我们所有的异步线性流程都通过代码生成状态机运行的方式，变成了一个一个的状态按顺序执行。

可以看到异步线性流程和核心由两部分组成:

Task异步运行机制
异步状态机代码生成

On the C# side of things, the compiler transforms your code into a state machine that keeps track of things like yielding execution when an await is reached and resuming execution when a background job has finished.

Task异步取消

Task异步的取消是通过Cancellation Token来完成的。

/// <summary>
/// 响应开启等待取消Task按钮点击
/// </summary>
private async void OnBtnWaitCancelTaskUsingClick()
{
    mTaskCancelTokenSource = new CancellationTokenSource();
    var taskToken = mTaskCancelTokenSource.Token;
    var awaitTask = Task.Run(() =>
                             {
                                 return AwaitCancelTaskAction(taskToken);
                             }, taskToken);
    Debug.Log($"AwaitCancelTaskAction has been launched. Main Thread:{Thread.CurrentThread.ManagedThreadId}");
    try
    {
        var sumResult = await awaitTask;
        Debug.Log($"AwaitCancelTaskAction sumResult:{sumResult}");
        Debug.Log($"AwaitCancelTaskAction DateTime.Now.Millisecond:{DateTime.Now.Millisecond}");
    }
    catch (OperationCanceledException e)
    {
        Debug.Log(e);
        Debug.Log($"e.CancelLlationToken.Equals(taskCancelToken):{e.CancellationToken.Equals(taskToken}");
    }
    finally
    {
        mTaskCancelTokenSource.Dispose();
    }
}

/// <summary>
/// 等待取消的Task方法
/// </summary>
/// <param name="taskToken"></param>
/// <returns></returns>
private async Task<int> AwaitCancelTaskAction(CancellationToken taskToken)
{
    // 检测异步Task是否已经取消
    taskToken.ThrowIfCancellationRequested();
    Debug.Log($"AwaitCancelTaskAction Start");
    Debug.Log($"DateTime.Now.Millisecond:{DateTime.Now.Millisecond}  Thread Id:{Thread.CurrentThread.ManagedThreadId}");
    await Task.Delay(1000);
    // 检测异步Task是否已经取消
    taskToken.ThrowIfCancellationRequested();
    Debug.Log($"AwaitCancelTaskAction After Task.Delay(1)");
    Debug.Log($"DateTime.Now.Millisecond:{DateTime.Now.Millisecond}");
    int sum = 0;
    for(int i = 0; i < 10000000; i++)
    {
        sum++;
    }
    await Task.Delay(2000);
    // 检测异步Task是否已经取消
    taskToken.ThrowIfCancellationRequested();
    Debug.Log($"AwaitCancelTaskAction After Task.Delay(2)");
    Debug.Log($"DateTime.Now.Millisecond:{DateTime.Now.Millisecond}");
    Debug.Log($"AwaitCancelTaskAction End");
    return sum;
}

/// <summary>
/// 响应Task取消按钮点击
/// </summary>
private void OnBtnCancelTaskUsingClick()
{
    mTaskCancelTokenSource?.Cancel();
    Debug.Log($"取消异步Task");
}

上面的代码可以看到，我们在开启一个需要支持取消的异步Task时需要以下步骤:

申请创建了一个CancellationTokenSource对象，这个对象会包含我们异步Task取消所需的token。
将CancellationTokenSource.token传递给需要异步执行的Task(多层调用要一直传递下去，确保Task正确异步取消)
在需要异步打断的Task里判定token是否已经取消(token.ThrowIfCancellationRequested())
try catch异步await，确保释放token source(CancellationTokenSource.Dispose())

在上面的使用中可以看到，Task异步是多线程的，通过Task.Run()我们启用了一个新的线程执行任务，所以打印出的Thread Id和Main Thread Id不一样。

为了确保Task取消后异步逻辑能正确停止，我们在异步逻辑里关键地方都在判定taskToken.ThrowIfCancellationRequested()通知Task进入取消状态。

Task总结

以下总结来源:深入解析C#异步编程：await 关键字背后的实现原理

深入理解 AsyncTaskMethodBuilder

AsyncTaskMethodBuilder 是一个辅助类，用于构建和管理异步方法的任务。它提供了以下方法：

Create：创建一个新的 AsyncTaskMethodBuilder 实例。
Start：开始执行异步方法，调用状态机的 MoveNext 方法。
AwaitUnsafeOnCompleted：注册回调函数，当任务完成时触发回调。
SetResult：设置任务的结果。
SetException：设置任务的异常。

异步方法的生命周期

初始化：创建状态机实例，初始化状态和任务构建器。
开始执行：调用 Start 方法开始执行异步方法。
执行方法体：在 MoveNext 方法中，根据当前状态执行相应的代码。
遇到 await：检查任务是否完成，如果未完成则注册回调并暂停方法执行。
任务完成：回调被触发，重新调用 MoveNext 方法，恢复异步方法的执行。
方法完成：所有异步操作完成，设置任务的结果或异常。

总结

异步方法的基本概念：async 和 await 关键字用于编写异步代码。
状态机的生成：编译器为每个异步方法生成一个状态机，包含所有局部变量和状态信息。
MoveNext 方法的执行：MoveNext 方法是状态机的核心，负责管理和执行异步操作。
回调函数的注册和触发：
- 当遇到 await 关键字时，编译器会生成代码来检查任务是否已经完成。
- 如果任务未完成，注册回调并暂停方法执行。
- 当任务完成时，回调函数会被触发，重新调用状态机的 MoveNext 方法，从而恢复异步方法的执行。
AwaitUnsafeOnCompleted 方法的作用：在任务完成时注册一个回调函数，回调函数会在任务完成后被触发，从而恢复异步方法的执行。

使用体验

通过上面的学习使用，这里个人讲讲个人Task的使用心得。

好处:

通过Task异步我们能将异步逻辑跟同步逻辑一样方便的线性流程编写，不再需要编写回调嵌套(回调地狱)的代码。

不方便处:

Task异步需要定义async关键字，导致所有异步方法都需要加上async关键字(async传染)
Task异步取消时，使用者在异步逻辑里需要关心 taskToken是否已经取消(taskToken.ThrowIfCancellationRequested())，这样代码写起来还是比较麻烦
开启一个异步Task需要通过Task.Run或者Task.Factory.StartNew方法，这样导致我们嵌套调用异步方法传递token时被迫用上闭包这种方式
Task异步是多线程，需要考虑数据多线程访问问题，对开发者多线程相关知识要求更高

自定义Task

通过上面的学习我们了解了Task和async，await关键词是如何组合起来实现异步等待的。但Task默认相关都是带线程池的，如果我们想实现一个单线程的异步Task(好比UniTask)应该如何实现了？

核心需求如下:

支持async和await的自定义Task
类似UniTask的单线程Task
支持常规的单帧等待，指定时长等待Task
支持Unity不同Update模式的更新驱动选择
支持异步任务取消
支持带返回T类型数据和void返回类型的异步任务

以下实现思路参考来源:

每个人都能写UniTask!!!自定义一个TaskLike并完成一个简单的Delay延时教程

在开始实现自定义Task之前，我们首先先设计好类图，明确各个类的功能。

CustomVoidTask

自定义void返回类型的Task
CustomAsyncVoidMethodBuilder

用于生成返回void类型的Task结构体的自定义异步任务构造器(struct)，通过在对应Task定义添加[AsyncMethodBuilder(typeof(CustomAsyncVoidMethodBuilder))]标签标记指定异步任务构造器
CustomTaskAwaiter

抽象自定义void返回类型的异步任务等待器
ICustomTaskSource

抽象一层任务数据，通过依赖反转实现上层DIY的自定义任务void类型(比如CustomDelayTask)不影响整体自定义Task框架。
**CustomVoidTaskCompletionSource **

自定义返回void类型的任务完成数据抽象(CustomAsyncVoidMethodBuilder会构建)，这个类很重要，是我们包装每一个async函数都要生成的一个类，它用来记录整个async函数的完成情况（注意是整个，这个很重要），完成后的回调，以及异常、取消等实现。
CustomTaskLoopManager

自定义任务循环管理单例类，负责需要注入Update驱动的统一管理(比如实现CustomTask.Delay()和CustomTask.Yield()等效果)
CustomTaskLoopType

自定义任务循环枚举，用于支持类似Unity里不同Update的定义

CustomTaskStatus

自定义异步任务状态枚举

CancellationTokenSource和CancellationToken

采用原生定义的结构辅助设计异步任务取消，ICustomTaskSource子类通过定义SetCanceled方法实现自定义相关的异步任务取消逻辑，CancellationTokenSource和CancellationToken主要用于解决异步嵌套的一系列义务任务打断判定和回调注入

CustomTask

自定义T返回类型的Task
CustomAsyncMethodBuilder

用于生成返回T类型的Task结构体的自定义异步任务构造器(struct)，通过在对应Task定义添加[AsyncMethodBuilder(typeof(CustomAsyncMethodBuilder))]标签标记指定异步任务构造器
CustomTaskAwaiter

抽象自定义T返回类型的异步任务等待器
ICustomTaskSource

抽象一层任务数据，通过依赖反转实现上层DIY的自定义任务返回T类型不影响整体自定义Task框架。
CustomTaskCompletionSource

自定义返回T类型的任务完成数据抽象(CustomAsyncMethodBuilder会构建)，这个类很重要，是我们包装每一个async函数都要生成的一个类，它用来记录整个async函数的完成情况（注意是整个，这个很重要），完成后的回调，以及异常、取消等实现。
CustomDelayTask

自定义延迟指定毫秒Task
CustomYieldTask

自定义延迟指定帧数Task

进阶(UniTask)

了解Task异步的基础使用和设计，接下来让我们看看UniTask是如何实现Unity内更优的异步框架设计的。

官网介绍:

UniTask的特点

为 Unity 提供有效的无GC async/await集成。
基于Struct UniTask<T> 的自定义 AsyncMethodBuilder，实现零GC,使所有Unity的异步操作和协程可以await
基于PlayerLoop的Task（ UniTask.Yield、 UniTask.Delay、 UniTask.DelayFrame 等）这使得能够替换所有协程操作
MonoBehaviour 消息事件和 uGUI 事件为可使用Await/AsyncEnumerable
完全在 Unity 的 PlayerLoop 上运行，因此不使用线程，可在 WebGL、wasm 等平台上运行。
异步 LINQ，具有Channel和 AsyncReactiveProperty
防止内存泄漏的 TaskTracker (Task追踪器)窗口
与Task/ValueTask/IValueTaskSource 的行为高度兼容

上面提到UniTask没有使用多线程，这一点对于Unity单线程开发理念更加适合。

更多学习使用待添加……(TODO)

重点知识

Unity子线程内不可访问游戏对象或者组件以及相关方法，只用于处理数据或者逻辑，任何要与主线程发生关系的地方都必须进行回调和上下文切换。
await和async关键词并不一定触发多线程，是否多线程是与使用的具体方式而定(比如Task.Run)

Reference

Asynchronous programming

Task-based Asynchronous Pattern(TAP)

深入解析C#异步编程：await 关键字背后的实现原理

每个人都能写UniTask!!!自定义一个TaskLike并完成一个简单的Delay延时教程

Github

UniTask

网络对时

By Tony Tang

发表于 2022-07-16

前言

游戏开发过程中经常会设计到时间的运算判定，比如开服时间，触发时间，倒计时时间等，所有的这些时间都要基于和服务器或网络对时后的网络时间为基准来计算。单纯采用本地客户端时间的话会导致通过修改本地客户端时间就能达到加速和调时间的目的。本章节通过深入学习网络对时，实现一套没有服务器也能正确网络对时的对时框架(如果有后端的话以后端时间对时为准即可,本人是出于不懂服务器开发所以才采用网络对时的方案)，为未来自己的独立游戏的网络对时打基础。

需求

通过网络实现对时，确保本地计算用的时间是准确无误不会受本地调时间影响的

时间

UTC时间

在了解同步时间之前，让我们先来了解下什么是时间。

平时我们说的时间年月日时分秒，这个时间是从哪里来的了？为什么不同的国家有不同的时间了？为什么要区分时区了？

带着这些疑问来看以下这篇文章介绍:

网络时间同步是怎么实现的？怎样消除延迟带来的影响？

这里我直接跳到重要的理论知识和结论上来。

世界标准时间:

世界时：基于天文现象 + 钟表计时，永远与地球自转时间相匹配
国际原子时：基于原子钟计时，每一秒的周期完全等长且固定

原子时非常稳定，但世界时随着地球自转变慢，会越来越慢. 科学家通过「闰秒」的方式来矫正这个误差，从而实现世界时+国际原子时混合的方式得到准确的计时。

上面说的**基于原子时 + 世界时「协调」**得出的时间就是我们通常说的UTC时间。有了UTC标准时间，各个国家的时间就是基于UTC+-*的方式的出来的，也就是我们通常说的时区时间(e.g. 北京时间，巴黎时间……)。当我们开发多个国家的游戏的时候，为了确保时间的统一，这个时候我们就可以采用UTC时间作为时间标准，每个国家的时间戳计算标准都是统一的(不需要考虑时区问题)。

在了解了UTC(统一标准时间)的来路后，那么接下来就是本文的重点如何同步网络时间。

Unix时间戳

时间戳适用于表示一个时间从固定时间点到当前时间的总秒数(或微秒数不同编程语言有不同)。

而编程里常用的则是Unix时间戳。

Unix时间戳是从UTC1970年1月1日0时0分0秒起至现在的总秒数，不考虑闰秒。

Note:

时间戳没有时区之分
Unix时间戳是从1970年1月1日0点0分0秒作为基准算起

网络对时

网络对时顾名思义需要通过网络进行对时访问，而网络的访问我们都知道会有网络延时，那么我们如何在网络延时的基础上做到正确的网络对时了？

前人已经为此提供了解决方案，那就是NTP(Network Time Protocol)(网络对时服务)

这里简单了解下NTP是如何做到网络时间同步的。

通过在网络报文上打「时间戳」的方式，然后配合计算网络延迟，从而修正本机的时间。

根据图示可以计算出网络「传输延迟」，以及客户端与服务端的「时间差」：

网络延时 = (t4 - t1) - (t3 - t2)

时间差 = t2 - t1 - 网络延时 / 2

这个计算过程假设网络来回路径是对称的，并且时延相同。

可以看到通过包含发送，接收，返回和返回接收时间戳的方式，我们可以计算出网络延迟从而做到正确的同步的网络时间

为了确保逻辑正确，时间严格意义上是不允许倒退的。那通过NTP同步的时间会出现时光倒流的情况吗？

NTP为此提供了两种方式:

在了解了NTP的对时原理后，接下来让我们通过实战Socket网络请求利用NTP实现网络对时功能。

实战

在实现通过Socket访问网络请求时，先让我们了解一下NTP的报文格式:

了解了NTP的报文格式我们就能编写Socket代码请求访问获取对时相关信息:

对时NTP网址，我采用的是阿里云提供的地址:

/*
 * Description:             NTPHostConfig.cs
 * Author:                  TonyTang
 * Create Date:             2022/07/21
 */

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// NTPHostConfig.cs
/// NTP网址配置
/// </summary>
public static class NTPHostConfig
{
    /// <summary>
    /// NTP网址列表
    /// </summary>
    public static List<string> NTPHostList = new List<string>
    {
        "ntp2.aliyun.com",
        "ntp3.aliyun.com",
        "ntp4.aliyun.com",
        "ntp5.aliyun.com",
        "ntp6.aliyun.com",
        "ntp7.aliyun.com",
    };
}

/*
 * Description:             NTPClient.cs
 * Author:                  TonyTang
 * Create Date:             2022/07/15
 */

using System;
using System.Collections;
using System.Collections.Generic;
using System.Net;
using System.Net.Sockets;
using UnityEngine;

/// <summary>
/// NTPClient.cs
/// NTP客户端
/// </summary>
public class NTPClient : SingletonTemplate<NTPClient>
{
    /// <summary>
    /// 对时网络地址(直接传IP地址时无值)
    /// </summary>
    public string Host
    {
        get;
        private set;
    }

    /// <summary>
    /// 对时IP连接地址
    /// </summary>
    public IPEndPoint IPEnd
    {
        get;
        private set;
    }

    /// <summary>
    /// NTP连接端口号
    /// </summary>
    private const int PortNumber = 123;

    /// <summary>
    /// NTP Socket
    /// </summary>
    private Socket mNTPSocket;

    /// <summary>
    /// NTP请求数据
    /// </summary>
    private byte[] mNtpSendData;

    /// <summary>
    /// NTP接受数据
    /// </summary>
    private byte[] mNtpReceiveData;

    /// <summary>
    /// <summary>
    /// 服务器接收客户端时间请求时间起始位置
    /// </summary>
    private const int ServerReceivedTimePos = 32;

    /// <summary>
    /// 服务器回复时间起始位置
    /// </summary>
    private const int ServerReplyTimePos = 40;

    /// <summary>
    /// UTC时间戳基准时间
    /// </summary>
    private readonly DateTime UTCBaseTime = new DateTime(1900, 1, 1, 0, 0, 0, DateTimeKind.Utc);

    /// <summary>
    /// NTP网址列表
    /// </summary>
    private List<string> mNTPHostList;

    /// <summary>
    /// 时间同步是否成功
    /// </summary>
    private bool IsTimeSyncSuccess;

    public NTPClient()
    {
        mNtpSendData = new byte[48];
        // Setting the Leap Indicator, Version Number and Mode values
        // LI = 0 (no warning), VN = 3 (IPv4 only), Mode = 3 (Client Mode)
        mNtpSendData[0] = 0x1B;
        mNtpReceiveData = new byte[48];
        IsTimeSyncSuccess = false;
    }

    /// <summary>
    /// 设置NTP网址列表
    /// </summary>
    /// <param name="ntpHostList"></param>
    public bool SetHostList(List<string> ntpHostList)
    {
        mNTPHostList = ntpHostList;
        if (!HasHost())
        {
            Debug.LogError($"请勿设置空NTP网址列表!");
            return false;
        }
        return true;
    }

    /// <summary>
    /// 同步网络时间
    /// </summary>
    /// <returns></returns>
    public bool SyncTime()
    {
        // 未来有服务器的话，改为和服务器对时
        if(!HasHost())
        {
            Debug.Log($"没有有效NTP网址,对时失败!");
            return false;
        }
        DateTime? syncDateTime = null;
        for (int i = 0, length = mNTPHostList.Count; i < length; i++)
        {
            InitByHost(mNTPHostList[i]);
            if (SyncTime(out syncDateTime))
            {
                IsTimeSyncSuccess = true;
                TimeHelper.SetNowUTCTime((DateTime)syncDateTime);
                return true;
            }
        }
        IsTimeSyncSuccess = false;
        Debug.LogError($"所有NTP地址都同步时间失败!");
        return false;
    }

    /// <summary>
    /// 网络对时是否成功
    /// </summary>
    /// <returns></returns>
    public bool IsSyncTimeSuccess()
    {
        return IsTimeSyncSuccess;
    }

    /// <summary>
    /// 初始化对时地址
    /// </summary>
    /// <param name="host"></param>
    private bool InitByHost(string host)
    {
        Host = host;
        IPEnd = null;
        var ipAdresses = Dns.GetHostAddresses(Host);
        if(ipAdresses != null && ipAdresses.Length > 0)
        {
            IPEnd = new IPEndPoint(ipAdresses[0], PortNumber);
            return true;
        }
        else
        {
            Debug.LogError($"网络地址:{host}的IP解析错误!");
            return false;
        }
    }

    /// <summary>
    /// 初始化对时IP地址
    /// </summary>
    /// <param name="ip"></param>
    private bool InitByIP(string ip)
    {
        Host = null;
        IPEnd = null;
        var ipAdress = IPAddress.Parse(ip);
        if (ipAdress != null)
        {
            IPEnd = new IPEndPoint(ipAdress, PortNumber);
            return true;
        }
        else
        {
            Debug.LogError($"IP地址:{ip}解析错误!");
            return false;
        }
    }

    /// <summary>
    /// 网络对时
    /// </summary>
    /// <param name="syncDateTime"></param>
    /// <returns></returns>
    private bool SyncTime(out DateTime? syncDateTime)
    {
        syncDateTime = null;
        if (IPEnd != null)
        {
            try
            {
                mNTPSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
                Debug.Log($"网址:{Host} IP地址:{IPEnd.ToString()}");
                mNTPSocket.Connect(IPEnd);
                mNTPSocket.ReceiveTimeout = 3000;
                // 客户端发送时间
                ulong clientSendTime = (ulong)DateTime.UtcNow.Millisecond;
                Debug.Log($"客户端发送时间:{clientSendTime}");
                mNTPSocket.Send(mNtpSendData);
                Array.Clear(mNtpReceiveData, 0, mNtpReceiveData.Length);
                var recceiveByteNumbers = mNTPSocket.Receive(mNtpReceiveData);
                Debug.Log($"接受返回字节数:{recceiveByteNumbers}");
                // 客户端接收时间
                ulong clientReceiveTime = (ulong)DateTime.UtcNow.Millisecond;
                Debug.Log($"客户端接收时间:{clientReceiveTime}");
                mNTPSocket.Shutdown(SocketShutdown.Both);
                // 服务器接受消息时间
                var serverReceivedTime = GetMilliSeconds(mNtpReceiveData, ServerReceivedTimePos);
                Debug.Log($"服务器接受消息时间:{serverReceivedTime}");
                // 服务器返回消息时间
                var serverReplyTime = GetMilliSeconds(mNtpReceiveData, ServerReplyTimePos);
                Debug.Log($"服务器返回消息时间:{serverReplyTime}");
                // 网路延时 = (客户端接收时间 - 客户端发送时间) - (服务器返回消息时间 - 服务器接受消息时间)
                // 时间差 = 服务器接受消息时间 - 客户端发送时间 - 网络延时 / 2 = ((服务器接受消息时间 - 客户端发送时间) + (服务器返回消息时间 - 客户端接收时间)) / 2
                // 当前同步服务器时间 = 客户端接收时间 + 时间差
                var offsetTime = ((serverReceivedTime - clientSendTime) + (serverReplyTime - clientReceiveTime)) / 2;
                var syncTime = clientReceiveTime + offsetTime;
                syncDateTime = UTCBaseTime.AddMilliseconds(syncTime);
                Debug.Log($"IP地址:{IPEnd.ToString()},当前同步UTC时间:{syncDateTime.ToString()}");
                return true;
            }
            catch(SocketException e)
            {
                Debug.LogError($"IP地址:{IPEnd.ToString()}连接异常:{e.Message},ErrorCode:{e.ErrorCode}!");
            }
            finally
            {
                //关闭Socket并释放资源
                mNTPSocket.Close();
            }
            return false;
        }
        else
        {
            Debug.LogError($"未初始化IP地址,网络对时失败!");
            return false;
        }
    }

    /// <summary>
    /// 是否有NTP网址
    /// </summary>
    /// <returns></returns>
    private bool HasHost()
    {
        return mNTPHostList != null && mNTPHostList.Count > 0;
    }

    /// <summary>
    /// 获取指定偏移的时间戳
    /// </summary>
    /// <param name="byteDatas"></param>
    /// <param name="byteOffset"></param>
    /// <returns></returns>
    private ulong GetMilliSeconds(byte[] byteDatas, int byteOffset)
    {
                // Note:
        // 64bit时间戳，高32bit表示整数部分，低32bit表示小数部分
        // 默认网络获取的时间戳是大端
        ulong intPart = BitConverter.ToUInt32(mNtpReceiveData, ServerReplyTimePos);
        ulong fractPart = BitConverter.ToUInt32(mNtpReceiveData, ServerReplyTimePos + 4);
        // 转换成小端
        if(ByteUtilities.IsLittleEndian)
        {
            // 注意只转换64里的低32位
            intPart = ByteUtilities.SwapEndianU32(intPart);
            fractPart = ByteUtilities.SwapEndianU32(fractPart);
        }
        return (intPart * 1000) + ((fractPart * 1000) / 0x100000000UL);
    }
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// 二进制辅助静态工具类
/// </summary>
public static class ByteUtilities
{
    /// <summary>
    /// 是否是小端
    /// </summary>
    public static bool IsLittleEndian = CheckLittleEndian();

    /// <summary>
    /// 当前设备是否是小端
    /// </summary>
    /// <returns></returns>
    public static unsafe bool CheckLittleEndian()
    {
        int i = 1;
        byte* b = (byte*)&i;
        return b[0] == 1;
    }

    /// <summary>
    /// UInt16大小端转换
    /// </summary>
    /// <param name="value"></param>
    /// <returns></returns>
    public static ushort SwapEndianU16(ushort value)
    {
        return (ushort)((value & 0xFFU) << 8 | (value & 0xFF00U) >> 8);
    }

    /// <summary>
    /// UInt32大小端转换
    /// </summary>
    /// <param name="value"></param>
    /// <returns></returns>
    public static uint SwapEndianU32(uint value)
    {
        return (value & 0x000000FFU) << 24 | (value & 0x0000FF00U) << 8 |
               (value & 0x00FF0000U) >> 8 | (value & 0xFF000000U) >> 24;
    }

    /// <summary>
    /// UInt64大小端32位转换
    /// </summary>
    /// <param name="value"></param>
    /// <returns></returns>
    public static ulong SwapEndianU32(ulong value)
    {
        return (value & 0x000000FFU) << 24 | (value & 0x0000FF00U) << 8 |
               (value & 0x00FF0000U) >> 8 | (value & 0xFF000000U) >> 24;
    }

    /// <summary>
    /// UInt64大小端64位转换
    /// </summary>
    /// <param name="value"></param>
    /// <returns></returns>
    public static ulong SwapEndianU64(ulong value)
    {
        return (value & 0x00000000000000FFUL) << 56 | (value & 0x000000000000FF00UL) << 40 |
               (value & 0x0000000000FF0000UL) << 24 | (value & 0x00000000FF000000UL) << 8 |
               (value & 0x000000FF00000000UL) >> 8 | (value & 0x0000FF0000000000UL) >> 24 |
               (value & 0x00FF000000000000UL) >> 40 | (value & 0xFF00000000000000UL) >> 56;
    }
}

从上面的代码可以看出，我们为了确保对时的快速，选择了UDP而非TCP。

其次通过解析NTP网址返回的NTP报文信息(e.g. 服务器接受消息时间和服务器返回消息时间)，我们可以计算出客户端和服务器的时间差，从而计算出正确的网络UTC时间。

网路延时 = (客户端接收时间 - 客户端发送时间) - (服务器返回消息时间 - 服务器接受消息时间)

时间差 = 服务器接受消息时间 - 客户端发送时间 - 网络延时 / 2 = ((服务器接受消息时间 - 客户端发送时间) + (服务器返回消息时间 - 客户端接收时间)) / 2

当前同步服务器时间 = 客户端接收时间 + 时间差

对时成功后，我们把对时的UTC时间设置到我们本地时间工具类里供访问使用:

/*
 * Description:             TimeHelper.cs
 * Author:                  TonyTang
 * Create Date:             2022/07/16
 */

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// 时间静态类
/// </summary>
public static class TimeHelper
{
    /// <summary>
    /// 同步网络UTC时间
    /// </summary>
    private static DateTime? mSyncUTCTime;

    /// <summary>
    /// 同步网络本地时间
    /// </summary>
    private static DateTime? mSyncLocalTime;
    
    /// <summary>
    /// 设置当前UTC时间
    /// </summary>
    /// <param name="nowDateTime"></param>
    public static void SetNowUTCTime(DateTime? nowDateTime)
    {
        mSyncUTCTime = nowDateTime;
        mSyncLocalTime = nowDateTime != null ? ((DateTime)nowDateTime).ToLocalTime() : nowDateTime;
        if (mSyncUTCTime != null)
        {
            Debug.Log($"同步当前UTC时间:{mSyncUTCTime.ToString()}");
            Debug.Log($"同步当前时区时间:{mSyncLocalTime.ToString()}");
        }
        else
        {
            Debug.Log($"清空当前同步时间!");
        }
    }

    /// <summary>
    /// 获取当前同步UTC时间(没有成功同步返回本地UTC时间)
    /// </summary>
    /// <returns></returns>
    public static DateTime GetNowUTCTime()
    {
        return mSyncUTCTime != null ? (DateTime)mSyncUTCTime : GetLocalNowUTCTime();
    }

    /// <summary>
    /// 获取当前同步本地时区时间(没有成功同步返回本地时区时间)
    /// </summary>
    /// <returns></returns>
    public static DateTime GetNowLocalTime()
    {
        return mSyncUTCTime != null ? ((DateTime)mSyncUTCTime).ToLocalTime() : GetLocalNowTime();
    }

    /// <summary>
    /// 获取本地当前UTC时间
    /// </summary>
    /// <returns></returns>
    public static DateTime GetLocalNowUTCTime()
    {
        return DateTime.UtcNow;
    }

    /// <summary>
    /// 获取本地当前时间
    /// </summary>
    /// <returns></returns>
    public static DateTime GetLocalNowTime()
    {
        return DateTime.Now;
    }
}

来看看实战效果:

我把本地时间同步关闭，并修改时间从2022/07/22 00:06到2022/07/24/03:06时间

同步时间前:

同步时间后:

从上面可以看到通过NTP的对时后，我们成功获取到了网络的UTC时间。

但上面的代码还有一个问题，对时后的UTC时间是固定的，我们无法向DateTime.Now或DateTime.UtcNow的方式实时访问同步的UTC时间。

这个时候我们需要通过网络同步时间+本地运行时间=本地最新网络同步时间的方式计算出最新的本地网络同步时间，毕竟我们整个游戏开发过程中并不想一直去通过短连接同步网络时间。

关于本地运行时间Unity给我们提供了一个无关Time.scale变化的一个运行时间，那就是Time.realtimeSinceStartup(标识游戏启动开始算起经历的时间s,不受Time.scale影响)

当前同步网络时间公式:

当前同步网络时间 = 网络对时 + (本地运行时长 - 对时时本地运行时长)

最终代码如下:

/*
 * Description:             TimeHelper.cs
 * Author:                  TonyTang
 * Create Date:             2022/07/16
 */

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// 时间静态类
/// </summary>
public static class TimeHelper
{
    /// <summary>
    /// 同步网络UTC时间
    /// </summary>
    private static DateTime? mSyncUTCTime;

    /// <summary>
    /// 同步网络本地时间
    /// </summary>
    private static DateTime? mSyncLocalTime;

    /// <summary>
    /// 同步时间时的本地运行时间
    /// </summary>
    private static float mSyncRealtime;

    /// <summary>
    /// 设置当前UTC时间
    /// </summary>
    /// <param name="nowDateTime"></param>
    public static void SetNowUTCTime(DateTime? nowDateTime)
    {
        mSyncUTCTime = nowDateTime;
        mSyncLocalTime = nowDateTime != null ? ((DateTime)nowDateTime).ToLocalTime() : nowDateTime;
        if (mSyncUTCTime != null)
        {
            mSyncRealtime = Time.realtimeSinceStartup;
            Debug.Log($"同步时间时本地运行时间:{mSyncRealtime}");
            Debug.Log($"同步当前UTC时间:{mSyncUTCTime.ToString()}");
            Debug.Log($"同步当前时区时间:{mSyncLocalTime.ToString()}");
        }
        else
        {
            Debug.Log($"清空当前同步时间!");
        }
    }

    /// <summary>
    /// 获取当前同步UTC时间(没有成功同步返回本地UTC时间)
    /// </summary>
    /// <returns></returns>
    public static DateTime GetNowUTCTime()
    {
        if(mSyncUTCTime != null)
        {
            var syncUTCTime = (DateTime)mSyncUTCTime;
            return syncUTCTime.AddSeconds(Time.realtimeSinceStartup - mSyncRealtime);
        }
        else
        {
            return GetLocalNowUTCTime();
        }
    }

    /// <summary>
    /// 获取当前同步本地时区时间(没有成功同步返回本地时区时间)
    /// </summary>
    /// <returns></returns>
    public static DateTime GetNowLocalTime()
    {
        if (mSyncLocalTime != null)
        {
            var syncLocalTime = (DateTime)mSyncLocalTime;
            return syncLocalTime.AddSeconds(Time.realtimeSinceStartup - mSyncRealtime);
        }
        else
        {
            return GetLocalNowTime();
        }
    }

    /// <summary>
    /// 获取本地当前UTC时间
    /// </summary>
    /// <returns></returns>
    public static DateTime GetLocalNowUTCTime()
    {
        return DateTime.UtcNow;
    }

    /// <summary>
    /// 获取本地当前时间
    /// </summary>
    /// <returns></returns>
    public static DateTime GetLocalNowTime()
    {
        return DateTime.Now;
    }
}

可以看到我们通过记录同步网络时间时的本地真实运行时间，在下一次获取当前网络时间时通过当前真实运行时间 - 同步网络时本地真实运行时间得出同步时间后真实运行的时间，从而计算出当前网络最新时间。

成功同步时间以后，如果我们制作的游戏要支持多个国家的话，我们需要统一游戏里的时间计算，这个时候我们会用到UTC时间和时间戳的概念。结合前面时间戳的介绍，我知道Unix时间戳是基于1970年1月1日0点0分0秒，那么通过网络UTC对时后，我们可以成功计算出网络对时的时间戳:

当前时间戳 = 当前同步网络时间 - Unix时间戳基准时间(1970/1/1)

/// <summary>
/// Unix时间戳基准时间
/// </summary>
private static DateTime UnixBaseTime = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);

var offsetTimeSpan = (DateTime)mSyncUTCTime - UnixBaseTime;
mSyncUTCTimeStamp = (long)offsetTimeSpan.TotalSeconds;
Debug.Log($"同步时间UTC时间戳:{mSyncUTCTimeStamp}");

/// <summary>
/// 获取当前同步UTC时间戳(没有成功同步返回本地UTC时间戳)
/// </summary>
/// <returns></returns>
public static long GetNowUTCTimeStamp()
{
    var nowUTCTime = GetNowUTCTime();
    var offsetSeconds = nowUTCTime - UnixBaseTime;
    return (long)offsetSeconds.TotalSeconds;
}

/// <summary>
/// 获取本地当前UTC时间戳
/// </summary>
/// <returns></returns>
public static long GetLocalNowUTCTimeStamp()
{
    return DateTimeOffset.UtcNow.ToUnixTimeSeconds();
}

同步UTC时间前时间戳:

同步UTC时间后时间戳:

可以看到我们通过和Unix时间戳基准时间(1970年1月1月0时0分0秒)成功计算出了当前对时的UTC时间戳

重点知识

同步网络对网络要求不高，可以采用UDP
NTP报文里有服务器相关获得请求时间和服务求返回请求时间，通过这些数据的解析我们能计算出真实的网络时间
NTP里的时间戳是基于1900年1月1日，而非像Unix时间戳基于1970年1月1日
本地最新网络时间需要通过记录对时时的运行时间来计算最新的当前网络时间
网络时间同步没必要一直同步，可以采用短连接在必要的时候同步一次

引用

网络时间同步是怎么实现的？怎样消除延迟带来的影响？

统一标准时间(UTC)

网络时间协议(Network Time Protocol, 缩写NTP)

Github

SyncTime

可配置Asset管线系统

By Tony Tang

发表于 2022-07-16

前言

日常项目中，我们对于Unity资源导入会做一些自动化的设置和检查，确保导入到项目里的资源是正确符合要求的，确保游戏资源最优化。而这些自动化检查和处理离不开AssetPostProcess接口，常规的方式是通过重写AssetPostProcess相关接口进行硬编码的方式实现资源导入自动化检查和设置。但这样的实现方式显得不灵活，当我们需要改变或新增一些资源时，我们需要硬编码去实现需求。

为了寻求高效高度扩展性的Asset管线系统，从而引出了本篇文章实现的可配置化Asset管线系统。

Asset管线设计

使用ScriptableObject实现自定义配置数据存储，结合导出Json实现无需等待配置Asset导入就可读取数据进行Asset管线系统初始化
使用EditorWindow实现自定义配置窗口
使用AssetPostProcess实现Asset后处理系统流程接入
设计AssetPipeline和AssetPipelineSystem实现Asset管线系统流程初始化(利用InitializeOnLoadMethodAttribute标签实现Asset管线提前初始化)
设计AssetProcessorSystem和AssetCheckSystem实现Asset管线的2大系统(Asset处理系统和Asset检查系统)
支持配置多个Asset管线策略以及不同平台选用不同策略来实现平台各异化的管线系统配置
支持Asset管线预处理，后处理，移动处理和删除处理器配置
支持全局和局部两种大的类型处理器和检查器配置
支持Asset管线预检查和后检查检查器配置
支持局部Asset处理器和检查器黑名单目录配置
处理器和检查器支持指定Asset类型级别设置
处理器和检查器支持指定Asset管线处理类型(AssetPostProcess相关流程接口)级别设置
支持所有处理器和检查器UI预览查看

Note:

Asset管线先执行全局后局部,局部Asset处理由外到内执行(覆盖关系)
Asset管线移动Asset当做重新导入Asset处理，确保Asset移动后得到正确的Asset管线处理
Asset管线不满足条件的不会触发(比如: 1. 不在目标资源目录下 2. 在黑名单列表里)
配置符合的触发顺序如下: 触发Asset导入全局预检查 -> 触发Asset导入局部预检查 -> 触发Asset导入全局预处理 -> 触发Asset导入局部预处理 -> 触发Asset导入全局后处理 -> 触发Asset导入局部后处理 -> 触发Asset导入全局后检查 -> 触发Asset导入局部后检查
处理器和检查器支持指定需要处理的Asset类型组合，但Asset管线处理类型只能选择一个
通用后处理类型包含后处理，移动处理和删除处理

类说明

Asset管线核心框架部分:

AssetType – Asset类型定义
AssetProcessType – Asset管线处理类型定义
AssetPipeline – Asset管线入口(负责接入Asset后处理流程以及Asset管线系统初始化)
AssetPipelineSystem – Asset管线系统(负责初始化Asset管线里各系统以及各系统调用)
AssetProcessorSystem – Asset处理系统(负责Asset自动化后处理相关配置)
AssetCheckSystem – Asset检查系统(负责Asset自动化检查相关配置)
AssetPipelineSettingData – Asset管线系统配置相关数据(非ScriptableObject)(比如Asset管线开关，Log开关等配置)
ProcessorSettingData – Asset处理器设置数据(AssetPipelineWindow 窗口配置)
ProcessorConfigData – Asset处理器配置数据(AssetPipelineWindow 窗口配置)
AssetCheckSettingData – Asset检查设置数据(AssetPipelineWindow 窗口配置)
AssetCheckConfigData – Asset检查配置数据(AssetPipelineWindow 窗口配置)
BaseProcessor – Asset处理器抽象类(负责抽象Asset处理器流程和数据，继承至ScriptableObject实现自定义数据配置处理)
BaseProcessorJson – Asset处理器Json抽象类(负责抽象Asset处理器流程和数据定义(和BaseProcessor保持一致用于Json反序列化构造)，实现自定义数据配置处理)
BasePreProcessor – Asset预处理器抽象类(负责抽象Asset预处理器流程和数据，继承至BaseProcessor )
BasePreProcessorJson – Asset预处理器Json抽象类(负责抽象Asset预处理器流程和数据定义(和BasePreProcessor保持一致用于Json反序列化构造)，继承至BaseProcessorJson)
BasePostProcessor – Asset预处理器抽象类(负责抽象Asset后处理器流程和数据，继承至BaseProcessor )
BasePostProcessJson – Asset预处理器Json抽象类(负责抽象Asset后处理器流程和数据定义(和BasePostProcessor保持一致用于Json反序列化构造)，继承至BaseProcessorJson)
BaseCheck – Asset检查抽象类(负责抽象Asset检查器流程和数据，继承至ScriptableObject实现自定义数据配置处理)
BaseCheckJson – Asset检查器Json抽象类(负责抽象Asset检查器流程和数据定义(和BaseCheck保持一致用于Json反序列化构建)，实现自定义数据配置处理)
BasePreCheck – Asset预检查抽象类(负责抽象Asset预检查器流程和数据，继承至BaseCheck )
BasePreCheckJson – Asset预检查器Json抽象类(负责抽象Asset预检查器流程和数据定义(和BasePreCheck保持一致用于Json反序列化构建)，继承至BaseCheckJson)
BasePostCheck – Asset后检查抽象类(负责抽象Asset后检查器流程和数据，继承至BaseCheck )
BasePostCheckJson – Asset后检查器Json抽象类(负责抽象Asset后检查器流程和数据定义(和BasePostCheck保持一致用于Json反序列化构建)，继承至BaseCheckJson)
AssetInfo – 用于记录处理器和检查器相关的路径信息和类型信息(用于后续Json反序列依据)
AssetProcessorInfoData – 所有处理器AssetInfo信息集合(用于后续Json反序列化构造处理器依据)
AssetCheckInfoData – 所有检查器AssetInfo信息集合(用于后续Json反序列化构造检查器依据)
更多的数据定义这里就不一一列举了

窗口部分:

AssetPipelineWindow – Asset管线可配置化配置窗口
AssetPipelinePanel – Asset管线面板
AssetProcessorPanel – Asset处理器面板
AssetCheckPanel – Asset检查器面板
LocaDetailWindow – Asset管线局部数据详情配置窗口(用于配置局部数据黑名单路径配置)

其他部分:

AssetPipelineUtilities – Asset管线工具类(负责提供Asset管线相关工具方法)
AssetPipelineStyles – Asset管线用到的GUI显示风格定义
AssetPipelineGUIContent – Asset管线用到的显示图标定义
AssetPipelineConst – Asset管线用到的常量定义
AssetPipelineLog – Asset管线自定义Log
AssetPipelinePrefKey – Asset管线本地存储Key定义

实战实现

在了解详细的细节实现之前，先了解下Asset管线是如何定义Asset类型和Asset管线处理类型的，这个对于后续实战配置理解会有帮助。

Asset类型定义

/// <summary>
/// AssetType.cs
/// Asset类型
/// </summary>
[Flags]
public enum AssetType : Int64
{
    None = 0,                         // 无效类型
    Texture = 1 << 0,                 // 图片
    Material = 1 << 1,                // 材质
    SpriteAtlas = 1 << 2,             // 图集
    FBX = 1 << 3,                     // 模型文件
    AudioClip = 1 << 4,               // 音效
    Font = 1 << 5,                    // 字体
    Shader = 1 << 6,                  // Shader
    Prefab = 1 << 7,                  // 预制件
    ScriptableObject = 1 << 8,        // ScriptableObject
    TextAsset = 1 << 9,               // 文本Asset
    Scene = 1 << 10,                  // 场景
    AnimationClip = 1 << 11,          // 动画文件
    Mesh = 1 << 12,                   // Mesh文件
    Script = 1 << 13,                 // 脚本(e.g. cs, dll等)
    Video = 1 << 14,                  // 视频
    Folder = 1 << 15,                 // 文件夹
    Other = 1 << 16,                  // 其他
    All = Int32.MaxValue,             // 所有类型
}

上面的Asset类型只所以定义成Flags是为了处理器和检查器可以定义需要支持的Asset类型组合

Asset管线处理类型定义

/// <summary>
/// AssetProcessorType.cs
/// Asset管线处理类型
/// </summary>
public enum AssetProcessType
{
    CommonPreprocess = 1,               // 通用预处理
    PreprocessAnimation,                // 动画预处理
    PreprocessAudio,                    // 音效预处理
    PreprocessModel,                    // 模型预处理
    PreprocessTexture,                  // 纹理预处理
    CommonPostprocess,                  // 通用后处理
    PostprocessAnimation,               // 动画后处理
    PostprocessModel,                   // 模型后处理
    PostprocessMaterial,                // 材质后处理
    PostprocessPrefab,                  // 预制件后处理
    PostprocessTexture,                 // 纹理后处理
    PostprocessAudio,                   // 音效后处理
}

上面的类型分别对应AssetPostprocessor里的Asset处理接口，这里就不详细介绍了，具体看代码。

配置窗口

此窗口主要负责配置Asset管线策略以及不同平台Asset管线策略的使用。同时也负责选择当前配置的策略和设置全局的资源处理目录。

全局后处理器，移动处理器和删除处理器配置面板类似就不一一截图了，他们分别对应通用后处理里的imported，moved和deleted流程。

从上面可以看到我们对于局部处理器的配置方式，是通过制定目录，选择处理器列表的方式实现的，同时每个处理器还支持制定黑名单目录(用于部分处理器子目录不生效的配置)

通过点击数量(*)我们可以打开指定局部处理器配置指定处理器的黑名单详情设置窗口

通过上面的黑名单目录配置结合前面的局部预处理配置我们可以看出，我们希望ASTC6X6的设置对于Assets/Res/textures/TestBlackList目录生效但不希望对Assets/Res/textures/TestBlackList/BlackList目录生效，对于TestBlackList目录我们单独设置了ASTC处理器设置。

关于移动处理器和删除处理器和预处理器和后处理器配置类似的，只是对应不同处理流程，这里就不一一截图举例了。

检查器窗口配置和处理器窗口配置是类似的，只是检查器只支持了预检查器和后检查器，这里我就只简单截一张效果图看看，就不详细说明了

了解了配置窗口，接下来看看我们是如何在Asset管线框架基础上，实现定义这些自定义的处理器和检查器的。

自定义处理器和检查器

自定义的检查器需要通过继承BasePreProcessor或BasePostProcessor或BasePreCheck或BasePostCheck来实现的

CheckFileName.cs预检查器ScriptableObject数据定义:

/// <summary>
/// CheckFileName.cs
/// 检查文件名
/// </summary>
[CreateAssetMenu(fileName = "CheckFileName", menuName = "ScriptableObjects/AssetPipeline/AssetCheck/PreCheck/CheckFileName", order = 2001)]
public class CheckFileName : BasePreCheck
{
    /// <summary>
    /// 检查器名
    /// </summary>
    public override string Name
    {
        get
        {
            return "检查文件名";
        }
    }

    /// <summary>
    /// 目标Asset类型
    /// </summary>
    public override AssetType TargetAssetType
    {
        get
        {
            return AssetType.All;
        }
    }

    /// <summary>
    /// 目标Asset管线处理类型
    /// </summary>
    public override AssetProcessType TargetAssetProcessType
    {
        get
        {
            return AssetProcessType.CommonPreprocess;
        }
    }
}

CheckFileNameJson.cs预检查器Json处理流程和数据定义:

/// <summary>
/// CheckFileSizeJson.cs
/// 检查文件大小检查器Json
/// </summary>
[Serializable]
public class CheckFileSizeJson : BasePreCheckJson
{
    /// <summary>
    /// 检查器名
    /// </summary>
    public override string Name
    {
        get
        {
            return "检查文件大小";
        }
    }

    /// <summary>
    /// 目标Asset类型
    /// </summary>
    public override AssetType TargetAssetType
    {
        get
        {
            return AssetPipelineSystem.GetAllCommonAssetType();
        }
    }

    /// <summary>
    /// 目标Asset管线处理类型
    /// </summary>
    public override AssetProcessType TargetAssetProcessType
    {
        get
        {
            return AssetProcessType.CommonPreprocess;
        }
    }

    /// <summary>
    /// 处理器触发排序Order
    /// </summary>
    public override int Order
    {
        get
        {
            return 2;
        }
    }

    /// <summary>
    /// 文件大小限制
    /// </summary>
    public int FileSizeLimit = 1024 * 1024 * 8;

    /// <summary>
    /// 执行检查器处理
    /// </summary>
    /// <param name="assetPostProcessor"></param>
    /// <param name="paramList">不定长参数</param>
    protected override bool DoCheck(AssetPostprocessor assetPostProcessor, params object[] paramList)
    {
        return DoCheckFileSize(assetPostProcessor.assetPath);
    }

    /// <summary>
    /// 执行指定路径的检查器处理
    /// </summary>
    /// <param name="assetPath"></param>
    protected override bool DoCheckByPath(string assetPath, params object[] paramList)
    {
        return DoCheckFileSize(assetPath);
    }

    /// <summary>
    /// 执行文件大小检查
    /// </summary>
    /// <param name="assetPath"></param>
    /// <returns></returns>
    private bool DoCheckFileSize(string assetPath)
    {
        var assetFullPath = PathUtilities.GetAssetFullPath(assetPath);
        using (FileStream fs = File.Open(assetFullPath, FileMode.Open))
        {
            var overSize = fs.Length > FileSizeLimit;
            if (!overSize)
            {
                AssetPipelineLog.Log($"AssetPath:{assetPath}文件大小检查,实际大小:{fs.Length / 1024f / 1024f}M,限制大小:{FileSizeLimit / 1024f / 1024f}M".WithColor(Color.yellow));
            }
            else
            {
                AssetPipelineLog.LogError($"AssetPath:{assetPath}文件大小检查,实际大小:{fs.Length / 1024f / 1024f}M,限制大小:{FileSizeLimit / 1024f / 1024f}M".WithColor(Color.yellow));
            }
            return !overSize;
        }
    }
}

从上面可以看到我们通过CheckFileName继承BasePreCheck表明我们是实现一个预检查器。通过声明AssetType为AssetType.All表明我们要支持的所有的Asset类型处理。通过声明TargetAssetProcessType为AssetProcessType.CommonPreprocess表示我们要支持通用预处理流程。

同时为了支持在InitializeOnLoadMethodAttribute方法里读取非Asset相关类型信息和数据进行初始化(后续会讲到为什么)，我们定义了对应的CheckFileNameJson类来实现处理流程和数据定义。因为CheckFileNameJson和CheckFileName的序列化数据定义一致，所以通过CheckFileName的ScriptableObject导出的Json数据是可以成功反序列化读取的。最终我们使用*Json类实现了对配置数据的反序列化从而填充到我们的Asset管线系统里作为后处理数据依据。

平台纹理格式设置预处理器ScriptableObeject数据定义:

/// <summary>
/// PlatformTextureFormatSet.cs
/// 平台纹理格式设置预处理器
/// </summary>
[CreateAssetMenu(fileName = "PlatformASTCSet", menuName = "ScriptableObjects/AssetPipeline/AssetProcessor/PreProcessor/Texture/PlatformTextureFormatSet", order = 1001)]
public class PlatformTextureFormatSet : BasePreProcessor
{
    /// <summary>
    /// 处理器名
    /// </summary>
    public override string Name
    {
        get
        {
            return "平台纹理格式设置";
        }
    }

    /// <summary>
    /// 目标Asset类型
    /// </summary>
    public override AssetType TargetAssetType
    {
        get
        {
            return AssetType.Texture;
        }
    }

    /// <summary>
    /// 目标Asset管线处理类型
    /// </summary>
    public override AssetProcessType TargetAssetProcessType
    {
        get
        {
            return AssetProcessType.PreprocessTexture;
        }
    }

    /// <summary>
    /// 处理器触发排序Order
    /// </summary>
    public override int Order
    {
        get
        {
            return 1;
        }
    }

    /// <summary>
    /// 目标平台
    /// </summary>
    [Header("目标平台")]
    public BuildTarget BuildTarget = BuildTarget.StandaloneWindows64;

    /// <summary>
    /// 目标纹理格式
    /// </summary>
    [Header("目标纹理格式")]
    public TextureImporterFormat TargetTextureFormat = TextureImporterFormat.RGBA32;
}

平台纹理格式设置预处理器对应*Json的处理流程和数据定义:

/// <summary>
/// PlatformTextureFormatSetJson.cs
/// 平台纹理格式设置预处理器Json
/// </summary>
[Serializable]
public class PlatformTextureFormatSetJson : BasePreProcessorJson
{
    /// <summary>
    /// 处理器名
    /// </summary>
    public override string Name
    {
        get
        {
            return "平台纹理格式设置";
        }
    }

    /// <summary>
    /// 目标Asset类型
    /// </summary>
    public override AssetType TargetAssetType
    {
        get
        {
            return AssetType.Texture;
        }
    }

    /// <summary>
    /// 目标Asset管线处理类型
    /// </summary>
    public override AssetProcessType TargetAssetProcessType
    {
        get
        {
            return AssetProcessType.PreprocessTexture;
        }
    }

    /// <summary>
    /// 处理器触发排序Order
    /// </summary>
    public override int Order
    {
        get
        {
            return 1;
        }
    }

    /// <summary>
    /// 目标平台
    /// </summary>
    public BuildTarget BuildTarget = BuildTarget.StandaloneWindows64;

    /// <summary>
    /// 目标纹理格式
    /// </summary>
    public TextureImporterFormat TargetTextureFormat = TextureImporterFormat.RGBA32;

    /// <summary>
    /// 执行处理器处理
    /// </summary>
    /// <param name="assetPostProcessor"></param>
    /// <param name="paramList">不定长参数列表</param>
    protected override void DoProcessor(AssetPostprocessor assetPostProcessor, params object[] paramList)
    {
        var assetImporter = assetPostProcessor.assetImporter;
        DoASTCSet(assetImporter);
    }

    /// <summary>
    /// 执行指定路径的处理器处理
    /// </summary>
    /// <param name="assetPath"></param>
    /// <param name="paramList">不定长参数列表</param>
    protected override void DoProcessorByPath(string assetPath, params object[] paramList)
    {
        var assetImporter = AssetImporter.GetAtPath(assetPath);
        DoASTCSet(assetImporter);
    }

    /// <summary>
    /// 执行ASTC设置
    /// </summary>
    /// <param name="assetImporter"></param>
    private void DoASTCSet(AssetImporter assetImporter)
    {
        // 如果设置的目标格式是ETC2，则通过判定是否有alpha决定设置ETC2_RGBA8还是ETC2_RGB4
        var textureImporter = assetImporter as TextureImporter;
        var platformName = EditorUtilities.GetPlatformNameByTarget(BuildTarget);
        var platformTextureSettings = textureImporter.GetPlatformTextureSettings(platformName);
        var textureFormat = TargetTextureFormat;
        var isTargetETC2 = ResourceUtilities.IsETC2Format(TargetTextureFormat);
        platformTextureSettings.overridden = true;
        if(isTargetETC2)
        {
            textureFormat = textureImporter.DoesSourceTextureHaveAlpha() ? TextureImporterFormat.ETC2_RGBA8 : TextureImporterFormat.ETC2_RGB4;
        }
        platformTextureSettings.format = textureFormat;
        textureImporter.SetPlatformTextureSettings(platformTextureSettings);
        AssetPipelineLog.Log($"设置平台:{platformName}AssetPath:{assetImporter.assetPath}纹理压缩格式:{textureFormat}".WithColor(Color.yellow));
    }
}

ASTC设置预处理器和检查文件名预处理器类似，这里就不一一说明了。

但从上面都可以看到每一个处理器和检查器我们都定义了CreateAssetMenu和一些自定义序列化属性，这样我们就可以通过右键创建指定处理器和检查器Asset了。

从上面可以看到同一个类型定义的处理器，我们可以通过创建多个然后改变处理器参数实现细节不同处理效果的处理器需求。

Asset管线处理

接下来让我们看看根据实际Asset管线配置，我们的Asset导入是如何触发一系列配置的。

可以看到通过配置好的Asset管线流程，我们导入到Mix文件夹的纹理图片，成功触发了一系列的处理器和检查器配置，并最终实现了可配置化检查和处理Asset后处理设置的需求。

重点知识

在DoProcessor和DoProcessorByPath流程接口里有params object[] paramList参数，这个参数就是为了兼容不同Asset管线处理流程数据传递问题的。指定处理器流程的处理器或检查器可以通过强转paramList得到Asset管线流程一开始传递的原始数据。
Asset类型是通过后缀名和类型映射硬编码实现的，如有不支持的文件后置和文件类型，请自行添加。
检查器只支持了预检查器和后检查器，如果未来有移动和删除检查器的需求也是可以支持的
检查器目前检查不符合只是打印日志警告，未来想做更多的处理(e.g. 不满足检查设置的自动移动到指定目录去)

注意事项

默认Editor/AssetPipeline/Config/AssetProcessors和Editor/AssetPipeline/Config/AssetChecks目录下才会生成预览，请创建在这两个目录下
生成AB名处理器会在后处理设置完成后导致Asset处理未保存状态，导致相同Asset设置AB名会重复触发Post Import流程，暂时通过判定AB名是否相同避免重复设置AB名避免重复进入Post Import流程

设计实现难点

问题：

原设计全部是基于ScriptableObejct作为数据存储媒介，导致各电脑同步时配置数据也处于导入状态导致无法正确加载最新的后处理配置(更坏的情况可能加载失败)。(2022/8/31)
InitializeOnLoadMethodAttribute标记的方法里无法使用跟Asset相关的类型(比如ScriptableObject相关类)信息也不允许加载Asset相关资源，如果加载Asset相关类型信息会在触发后处理接口的时候发现Asset相关的类型信息发生了Type Exception(类型丢失)(2023/10/19)
InitializeOnLoadMethodAttribute标签只能确保部分流程重新初始化AssetPipeline系统，但只有Asset导入(比如协同更新AssetPipeline配置文件时)时并不会触发InitializeOnLoadMethodAttribute，导致Asset未能按最新的AssetPipeline配置执行后处理(2024/12/19)
最初设计对于相同目录相同处理器不允许重复配置，后来考虑到最好的配置方式是单策略多平台公用，所以相同处理器被重复配置不同平台是有必要的（比如多平台纹理格式设置使用通用的平台纹理格式设置处理器）(2026/1/5)
因为ScriptableObject和Json序列化类都指向了原始的ScriptableObject对象，导致Json导出时每次都会出现InstanceID变化问题(2026/7/13)

解决方案:

所有ScriptableObject配置导出一份Json(基于ScritableObject的引用改存AssetPath)，保存时基于ScriptableObject配置生成最新的Json数据。Asset管线系统加载配置数据基于导出的Json，ScriptableObject只作为可视化配置读取的数据来源以及导出Json的数据依据。(2022/8/31)
通过拆分配置数据(比如ASTCSet相关的ScriptableObject只负责数据定义)和处理流程(比如ASTCSetJson负责定义和ASTCSet一致的数据实现配置数据反序列化构建+处理流程定义)实现在InitializeOnLoadMethodAttribute标记的方法里读取Asset管线配置数据进行Asset管线系统数据初始化，作为我们Asset管线后处理数据依据(2023/10/19)
通过FileSystemWatcher进行对AssetPipeline配置文件保存目录的json文件变化监听，实现AssetPipeline配置文件协同更新时重新初始化AssetPipeline系统(如果用户更新时直接待在Unity界面提前触发Asset导入会导致部分Asset导入时还未加载最新的AssetPipeline配置文件，这个问题暂时没有好的解决方案，欢迎提供好的解决方案)(InitializeOnLoadMethodAttribute+FileSystemWatcher解决99.99%使用情况)
放开单个目录相同处理器配置限制，改为打印警告。（2026/1/5）
序列化导出Json前手动清除Json无效导出数据，避免导出ScriptableObject的InstanceID，从而解决每次Json导出都有InstanceID变化问题(2026/7/13)

Github地址

AssetPipeline

Excel深入学习

By Tony Tang

发表于 2022-06-01

前言

游戏开发过程中用到的数据我们通常会采用Excel进行配置，这个归功于Excel强大的数据处理和表达能力。无论是Excel的自带的公式计算还是Excel内嵌支持的VBA自定义编程都使得Excel成为了数据配置的一大利器，用好Excel也是数值策划必备的技能之一。本章节通过深入学习Excel的使用，为未来自己的独立游戏的数据配置数值搭建打好基础。

需求

单表之间数值计算公式编写
跨表数据关联公式计算编写
自定义程序功能VBA编写(e.g. 导表)

Excel介绍

Excel is the world’s most used spreadsheet program

Excel is a powerful tool to use for mathematical functions

Excel is pronounced “Eks - sel” It is a spreadsheet program developed by Microsoft. Excel organizes data in columns and rows and allows you to do mathematical functions. It runs on Windows, macOS, Android and iOS.

从上面教程的Excel简单介绍可以看出Excel的强大和运用广泛，本人用Excel主要用于游戏开发，核心目的是实现数值系统(即数据管理)。接下来我会跟着教程一步一步深入学习Excel，从基础的Excel使用到Excel公式，甚至自定义VBA编写程序来实现我们在游戏开发过程中的种种需求。

Excel基础学习

Excel自带功能

一个简单的数学运算运用
Excel主要由标题栏和Sheet组成

标题栏为Excel工具栏，可以实现各种Excel操作。而Sheet为Excel数据部分主要有多行多列组成，我们平时编写的行列数据都在Sheet里，一个Excel可以包含多个Sheet。
Excel公式运算

Excel公式用于数学运算，通常由=符号开始。

用一个比较现实的问题举例，我们通常用Excel记账时，通过填入物品名称，单价和数量，我们会需要算出总价，这个时候我们可以利用公式实现总价根据前面数据进行自动计算的功能。

可以看到在总价那一列编写公式:=B2*C2我们成功利用商品单价和数量自动计算出了商品总价。

接下来我们利用Excel自带提供的函数计算所有价格，数量以及总价的总数。
Excel引用

Excel的引用分为两种(Relative Reference和Absolute Reference)
- Relative Reference(相对引用 e.g. A1)
  The relative reference makes the cells reference free. It gives the fill function freedom to continue the order without restrictions.
  从上面的介绍来看，相对引用在拖拽填充时更加自由，会保持原有公式的相对计算规则。
  好比前面我们通过SUM函数实现了总价总数的计算，然后我通过拖拽填充的方式自动实现了价格总数和数量总数的计算。
- Absolute Reference(绝对引用 e.g. $A$1)
  Absolute reference is when a reference has the dollar sign ($). It locks a reference in the formula.
  从上面的介绍来看，绝对引用是通过加$符号标识的，加了$符号的绝对引用不会再拖拽填充的过程中变化，会一直保持原有定义。
  接下来让我们把价格固定，然后利用绝对引用的方式，实现每个人不同购买数量的总价自动计算。
  
  从上面可以看到，虽然我们通过拖拽填充的方式填充了C3到C5，但我们单价引用的$B$7是保持不变的，核心原因就是我们用的绝对引用。
Excel自带函数
Excel的强大不单单是简单的加减乘除运算，更多的是Excel支持类似编程方式的函数库+VBA语言编写，从而使得Excel能实现很多强大的自定义功能。
接下来让我们学习几个Excel里常见的自带函数：
- AND(The AND function is a premade function in Excel, which returns TRUE or FALSE based on two or more conditions.)(可以看出AND类似编程语言Lua里的And运算符，但Excel里的AND运算符区别是用于返回true和false)
- IF(The IF function is a premade function in Excel, which returns values based on a true or false condition.)(可以看到IF类似编程语言里的IF，通过我们给出的条件的判定结果返回我们指定的两种情况的值)
  接下来让我们结合前面的例子，通过Excel自带函数IF和AND实现自动判定总价超过10和(总价超过10+数量超过5)的数据统计。
  
  从上面可以看到IF通过编写逻辑判定成功返回了我们自定义的YES和NO,而AND通过编写两个条件成功返回了TRUE和FALSE。
- SUMIF(The SUMIF function is a premade function in Excel, which calculates the sum of values in a range based on a true or false condition.)(可以看出SUMMIF是一个带范围带条件匹配的总和运算)
- COUNTIF(The COUNTIF function is a premade function in Excel, which counts cells as specified.)(可以看出COUNTIF是一个带条件的统计符合条件数量的函数)
  需求：
  - 纵向代表每个人，横向表示每天，✔️表示吃了，✘表示没吃，每天吃了要出3元，不吃要出1.5元，最后统计每个月每人餐饮伙食费
    
    可以看到通过SUMIF我们成功统计出了指定单元格到指定单元格里包含✔️和✘的数量，然后乘以对应的单价再相加即得到我们要的统计总和。
    更多的自带函数学习参考:Excel Function

Excel VBA

常规的功能需求，Excel自带的函数和功能就能满足，但涉及到复杂的逻辑运算规则时，Excel自带的函数和功能就力不从心了，这时就需要VBA这样的编程语言的东西出马了。

那么什么是VBA了？
VBA stands for Visual Basic for Applications, an event-driven programming language from Microsoft.
我个人的理解，VBA就是内嵌到Excel的VB，支持了Excel常规需求的一些API接口，我们可以利用这些API实现自定义功能。

待学习……

重点知识

学习连接

Excel Tutorial

VBA Tutorial

Github

ExcelStudy

数学知识

By Tony Tang

发表于 2022-02-21

Introduction

Unity游戏开发过程中我需要掌握一些常规的数学知识(比如线性代数)，游戏开发接触的比较多的就是向量和矩阵，本章节用于记录和学习数学相关的知识，好让自己对于平时用到的数学知识有一个归纳和深入的学习总结，避免每次都是久了不用就忘。

推荐书籍:

《3D数学基础:图形与游戏开发》

此书记讲到了游戏开发中需要用到的大部分数学基础知识，以前看这个书的时候是为了学习而学习，没有深入实战，而今天重拾此书，一边实战(结合Unity)一边记录的方式，深入学习游戏开发的数学基础知识，避免出现久了不用就忘的情况，也方便以后温故而知新。

Note:

为了减少重复的代码展示，后续相同代码展示会采用***代替

3D数学

什么是3D数学？

坐标系

笛卡尔坐标系在数学中是一种正交坐标系，由法国数学家勒内·笛卡尔引入而得名。二维的直角坐标系是由两条相互垂直、相交于原点的数线构成的。在平面内，任何一点的坐标是根据数轴上对应的点的坐标设定的。在平面内，任何一点与坐标的对应关系，类似于数轴上点与坐标的对应关系。

$3DCartesian$

笛卡尔坐标系就是我们以前学习平面几何时学习的坐标系，通过笛卡尔坐标系，我们可以通过x,y,z定义1D,2D或3D等空间的点。

坐标系从大的类型上来分分为两类:

左手坐标系
右手坐标系

如何区分左手还是右手坐标系了？

通过将大拇指指向Z轴正方向，如果其余四指握起是从X轴往Y轴那么就是左手坐标系，反之则是右手坐标系

Note:

大拇指指向X轴，食指指向Y轴，中指指向Z轴
Unity是左手坐标系
OpenGL是右手坐标系

多坐标系

坐标系不止一种，使用多种坐标系的原因是某些信息只能在特定的上下文环境中获得

比如以前学习OpenGL的时候，就了解到一个三角形要想渲染到屏幕上，需要经历MVP的矩阵变换。

M – Model -> World(模型坐标系到世界坐标系)

变换目的:3D模型是基于自身的坐标系存储的。计算模型各顶点在世界空间的位置，以便将模型摆放到世界空间中。

这里的世界坐标系，就是Unity里我们访问Transform.position时访问到的世界坐标所处的坐标系。

$WorldCoordinateSystem$

而物体坐标系是相对物体自身而言的坐标系，通过勾选Local，我们可以看到物体自身的坐标系:

$LocalCoordinateSystem$

通过Model -> World我们就得到了物体在世界坐标系里的位置表达信息。

V – World -> View(世界坐标系到相机坐标系)

变换目的:计算物体对相机的相对位置，以便进行后续变换

P – View -> Projection(摄像机坐标系到投影坐标系)

因为摄像机的投影方式有多种(比如透视投影和正交投影)，所以从摄像机坐标系到投影坐标系也存在着不同的计算方式。

详情参考以前的学习记录:

Coordinate Transformations & Perspective Projection

后续我们学习矩阵概念的时候再深入理解，核心就是通过矩阵执行坐标系转换。

Note:

矩阵变换是由M = S(scale) × R(rotation) × T(translation)组成，且不满足交换律，因为S和R都是针对坐标系原点进行的，一旦先执行T，那么相对于坐标系原点的位置就会有所变化，这之后再做S和R就会出现不一样的表现。

实战

接下来通过使用Unity来更深入的理解坐标系变化:

/*
 * Description:             CoordinateStudy.cs
 * Author:                  TONYTANG
 * Create Date:             2022/03/11
 */

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

/// <summary>
/// CoordinateStudy.cs
/// 坐标系学习
/// </summary>
public class CoordinateStudy : MonoBehaviour
{
    /// <summary>
    /// 提示文本
    /// </summary>
    [Header("提示文本")]
    public Text TipTxt;

    /// <summary>
    /// Cube1
    /// </summary>
    [Header("Cube1")]
    public GameObject Cube1;

    /// <summary>
    /// Cube2
    /// </summary>
    [Header("Cube2")]
    public GameObject Cube2;

    private void Start()
    {
        var cube1RelativeCube2Pos = Cube2.transform.InverseTransformPoint(Cube1.transform.position);
        var cube2RelativeCube1Pos = Cube1.transform.InverseTransformPoint(Cube2.transform.position);
        TipTxt.text = $"红色表示Cube1,绿色表示Cube2\n" +
                        $"Cube1世界坐标:{Cube1.transform.position.ToString()} 旋转角度:{Cube1.transform.eulerAngles.ToString()}\n" +
                        $"Cube2世界坐标系:{Cube2.transform.position.ToString()} 旋转角度:{Cube2.transform.eulerAngles.ToString()}\n" +
                        $"Cube1相对Cube2的坐标为:{cube1RelativeCube2Pos.ToString()}\n" +
                        $"Cube2相对Cube1的坐标为:{cube2RelativeCube1Pos.ToString()}";
    }
}

$Cube2LocalCoordinateSystem$

$WorldAndLocalCoordinateCaculate$

可以看到我通过调用**transform.InverseTransformPoint()**接口实现了将物体世界坐标转换到另一个物体的局部坐标的转换。因为Cube1在坐标原点且没有旋转，所以Cube2在Cube1物体坐标系里的位置也就是Cube2的世界坐标系位置。而Cube2因为有旋转，所以Cube1在Cube2物体坐标系的位置就需要根据Cube2的本地坐标系来计算了。

考虑到世界坐标系到视口坐标系转换后平时用不上，所以这里就不可视化结果了，通过Camera.WorldToViewportPoint()接口可以把世界坐标转换到摄像机视口坐标。同理Camera.WorldToScreenPoint()可以把世界坐标转换到屏幕坐标，这个接口相对而言更常用些(比如3D映射2D UI显示的时候)。

Note:

如果想查看物体本地坐标系和世界坐标系的转换矩阵，Unity里可以通过Transform.localToWorldMatrix()和Transform.worldToLocalMatrix()接口拿到变换的矩阵

向量

向量有两种不同但相关相关的意义，一种是纯抽象的数学意义，另一种是几何意义。

数学定义

向量就是一个数字列表，对程序员而言则是另一种类似的概念–数组

行向量(1行3列):

[1, 2, 3]

列向量(一列三行):

[ 1 ]

[ 2 ]

[ 3 ]

向量中的数表达了每个维度上的有向位移。比如上面的向量在坐标系里表达的是相对[0,0,0]原点的X,Y,Z轴分别位移1,2,3

Note:

注意区分向量和标量，标量是平时用的数字的技术称谓

几何定义

向量是有大小和方向的线段。

向量的大小就是向量的长度(模)。向量有非负的长度。

向量的方向描述了空间中向量的指向。

向量模 = Sqrt(VX * VX + VY * VY + VZ * VZ)

向量里有一个比较重要的定义:

单位向量，单位向量可以用来表示方式，但单位向量的大小(模)为1

单位向量 = 向量 / 向量的模

这里简单说一下向量加法的概念：

A + B = C

几何解释是向量A通过向量B的平移得到向量C(A向量头连接B向量尾的向量)

接下来让我通过可视化绘制世界坐标系和可视化绘制两个Cube的连线来看看向量是如何表达出两个物体之间的方向和大小的。

/*
 * Description:             HandlesUtilities.cs
 * Author:                  TONYTANG
 * Create Date:             2022/03/17
 */

using System.Collections;
using System.Collections.Generic;
using UnityEditor;
using UnityEngine;

/// <summary>
/// HandlesUtilities.cs
/// Handles辅助工具
/// </summary>
public static class HandlesUtilities
{
    /// <summary>
    /// 绘制有颜色的文本
    /// </summary>
    /// <param name="pos">坐标</param>
    /// <param name="text">文本</param>
    /// <param name="color">颜色</param>
    public static void DrawColorLable(Vector3 pos, string text, Color color)
    {
        Color preColor = GUI.color;
        GUI.color = color;
        Handles.Label(pos, text);
        GUI.color = preColor;
    }
}

/*
 * Description:             VectorStudy.cs
 * Author:                  TONYTANG
 * Create Date:             2022/03/17
 */

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

/// <summary>
/// VectorStudy.cs
/// 向量学习
/// </summary>
public class VectorStudy : MonoBehaviour
{
    ******

    private void Start()
    {
        var cube1ToCube2Vector = Cube2.transform.position - Cube1.transform.position;
        var cube2ToCube3Vector = Cube3.transform.position - Cube2.transform.position;
        var vectorAdd = cube1ToCube2Vector + cube2ToCube3Vector;
        TipTxt.text = $"红色表示Cube1,绿色表示Cube2,蓝色表示Cube3\n" +
                        $"Cube1世界坐标:{Cube1.transform.position.ToString()} 朝向:{Cube1.transform.forward.ToString()}\n" +
                        $"Cube2世界坐标系:{Cube2.transform.position.ToString()} 朝向:{Cube2.transform.forward.ToString()}\n" +
                        $"Cube3世界坐标系:{Cube3.transform.position.ToString()} 朝向:{Cube3.transform.forward.ToString()}\n" +
                        $"Cube1到Cube2的向量:{cube1ToCube2Vector.ToString()}\n" +
                        $"Cube1到Cube2的向量长度:{cube1ToCube2Vector.magnitude}\n"+
                        $"Cube2到Cube3的向量:{cube1ToCube2Vector.ToString()}\n" +
                        $"1->2 + 2->3 = {vectorAdd.ToString()}";
    }
}

/*
 * Description:             VectorStudyEditor.cs
 * Author:                  TONYTANG
 * Create Date:             2022/03/17
 */

using System.Collections;
using System.Collections.Generic;
using UnityEditor;
using UnityEngine;

/// <summary>
/// VectorStudyEditor.cs
/// VectorStudy的Editor绘制
/// </summary>
[CustomEditor(typeof(VectorStudy))]
public class VectorStudyEditor : Editor
{
    /// <summary>
    /// Cube1属性
    /// </summary>
    SerializedProperty mCube1Property;

    /// <summary>
    /// Cube2属性
    /// </summary>
    SerializedProperty mCube2Property;

    /// <summary>
    /// Cube3属性
    /// </summary>
    SerializedProperty mCube3Property;

    /// <summary>
    /// 坐标系长度属性
    /// </summary>
    SerializedProperty mCoordinateSystemLengthProperty;

    /// <summary>
    /// Z轴颜色属性
    /// </summary>
    SerializedProperty mForwardAxisColorProperty;

    /// <summary>
    /// X轴颜色属性
    /// </summary>
    SerializedProperty mRightAxisColorProperty;

    /// <summary>
    /// Y轴颜色
    /// </summary>
    SerializedProperty mUpAxisColorProperty;

    /// <summary>
    /// 向量颜色
    /// </summary>
    SerializedProperty mVectorColorProperty;

    /// <summary>
    /// Cube1
    /// </summary>
    private GameObject mCube1;

    /// <summary>
    /// Cube2
    /// </summary>
    private GameObject mCube2;

    /// <summary>
    /// Cube3
    /// </summary>
    private GameObject mCube3;

    protected void OnEnable()
    {
        mCube1Property = serializedObject.FindProperty("Cube1");
        mCube2Property = serializedObject.FindProperty("Cube2");
        mCube3Property = serializedObject.FindProperty("Cube3");
        mCoordinateSystemLengthProperty = serializedObject.FindProperty("CoordinateSystemLength");
        mForwardAxisColorProperty = serializedObject.FindProperty("ForwardAxisColor");
        mRightAxisColorProperty = serializedObject.FindProperty("RightAxisColor");
        mUpAxisColorProperty = serializedObject.FindProperty("UpAxisColor");
        mVectorColorProperty = serializedObject.FindProperty("VectorColor");
    }

    protected virtual void OnSceneGUI()
    {
        InitData();
        DrawCubeInfo();
        DrawWorldCoordinateSystem();
        DrawVectorInfo();
    }

    /// <summary>
    /// 初始化数据
    /// </summary>
    private void InitData()
    {
        mCube1 = mCube1Property?.objectReferenceValue != null ? mCube1Property.objectReferenceValue as GameObject : null;
        mCube2 = mCube2Property?.objectReferenceValue != null ? mCube2Property.objectReferenceValue as GameObject : null;
        mCube3 = mCube3Property?.objectReferenceValue != null ? mCube3Property.objectReferenceValue as GameObject : null;
    }

    /// <summary>
    /// 绘制Cube信息
    /// </summary>
    private void DrawCubeInfo()
    {
        HandlesUtilities.DrawColorLable(mCube1.transform.position, "Cube1", Color.red);
        HandlesUtilities.DrawColorLable(mCube2.transform.position, "Cube2", Color.red);
        HandlesUtilities.DrawColorLable(mCube3.transform.position, "Cube3", Color.red);
    }

    /// <summary>
    /// 绘制世界坐标系
    /// </summary>
    private void DrawWorldCoordinateSystem()
    {
        HandlesUtilities.DrawColorLable(Vector3.zero, "世界坐标系", Color.red);
        if (Event.current.type == EventType.Repaint)
        {
            Handles.color = mForwardAxisColorProperty.colorValue;
            Handles.ArrowHandleCap(1, Vector3.zero,
                                    Quaternion.LookRotation(Vector3.forward),
                                    mCoordinateSystemLengthProperty.floatValue, EventType.Repaint);

            Handles.color = mRightAxisColorProperty.colorValue;
            Handles.ArrowHandleCap(1, Vector3.zero,
                                    Quaternion.LookRotation(Vector3.right),
                                    mCoordinateSystemLengthProperty.floatValue, EventType.Repaint);

            Handles.color = mUpAxisColorProperty.colorValue;
            Handles.ArrowHandleCap(1, Vector3.zero,
                                    Quaternion.LookRotation(Vector3.up),
                                    mCoordinateSystemLengthProperty.floatValue, EventType.Repaint);
        }
    }

    /// <summary>
    /// 绘制相关向量
    /// </summary>
    private void DrawVectorInfo()
    {
        if (Event.current.type == EventType.Repaint)
        {
            if (mCube1 != null && mCube2 != null && mCube3 != null)
            {
                var cube1ToCube2Vector = mCube2.transform.position - mCube1.transform.position;
                var cube2ToCube3Vector = mCube3.transform.position - mCube2.transform.position;
                var vectorAdd = cube1ToCube2Vector + cube2ToCube3Vector;
                Handles.color = mVectorColorProperty.colorValue;
                Handles.ArrowHandleCap(1, mCube1.transform.position,
                                        Quaternion.LookRotation(cube1ToCube2Vector),
                                        cube1ToCube2Vector.magnitude, EventType.Repaint);
                Handles.ArrowHandleCap(1, mCube2.transform.position,
                                        Quaternion.LookRotation(cube2ToCube3Vector),
                                        cube2ToCube3Vector.magnitude, EventType.Repaint);
                Handles.ArrowHandleCap(1, mCube1.transform.position,
                                        Quaternion.LookRotation(vectorAdd),
                                        vectorAdd.magnitude, EventType.Repaint);
                Handles.Label(mCube1.transform.position + cube1ToCube2Vector / 2, "1->2");
                Handles.Label(mCube2.transform.position + cube2ToCube3Vector / 2, "2->3");
                Handles.Label(mCube1.transform.position + vectorAdd / 2, "1->2 + 2->3");
            }
        }
    }
}

$ObjectConnectVectorAndCoordinateSystem$

通过Handles相关接口，我们成功绘制出了以下东西:

世界坐标系
Cube1到Cube2的向量
Cube2到Cube3的向量
1->2 + 2->3的向量

可以看到Cube2坐标-Cube1坐标=从Cube1位置指向Cube2位置的向量，也就是说B - A = A->B

同时上面的可视化也显示了，A->B + B->C = A->C的向量加法规则，减法反向理解即可。

接下来我们要学习了解向量里比较重要的两个运算概念:

点乘
叉乘

Note:

方向并不完全和方位相同
数学中专门研究向量的分支称作线性代数
向量加法满足交换律，但向量减法不满足交换律。因为得到的向量方向相反。

点乘

点乘(也称为内积)，记做a.b

a.b = a1 * b1 + a2 * b2 + a3 * b3 … + an * bn

几何解释:

点乘等于向量大小与向量夹角的cosθ值的积。点乘结果描述了两个向量的”相似”程度，点乘结果越大，两向量越相近。

a.b = |a| * |b| * cosθ

$VectorDotGeometric$

根据上面的公式和图我们可以看出，点乘在几何里的可以理解成a向量在b向量上的投影乘以b向量的模

通过上面的公式我们反向推到夹角的计算公式如下:

θ = arccor(a.b / |a| * |b|)

如果我们不关心点乘的大小，那么从点乘的值我们可以判定两个向量之间的夹角情况:

a.b > 0 –> 方向基本相同，夹角在0到90度之间
a.b = 0 –> 正交，两向量垂直
a.b < 0 –> 方向基本相反，夹角在90-180度之间

接下来让我们通过Unity实战可视化辅助我们学习向量点乘:

/*
 * Description:             VectorStudyEditor.cs
 * Author:                  TONYTANG
 * Create Date:             2022/03/17
 */

using System.Collections;
using System.Collections.Generic;
using UnityEditor;
using UnityEngine;

/// <summary>
/// VectorStudyEditor.cs
/// VectorStudy的Editor绘制
/// </summary>
[CustomEditor(typeof(VectorDotStudy))]
public class VectorDotStudyEditor : Editor
{
    ******


    /// <summary>
    /// 绘制相关向量
    /// </summary>
    private void DrawVectorInfo()
    {
        if (Event.current.type == EventType.Repaint)
        {
            if (mCube1 != null && mCube2 != null && mCube3 != null)
            {
                var cube1ToCube2Vector = mCube2.transform.position - mCube1.transform.position;
                var cube1ToCube3Vector = mCube3.transform.position - mCube1.transform.position;
                var vectorDot = Vector3.Dot(cube1ToCube2Vector, cube1ToCube3Vector);
                var radians = Mathf.Acos(vectorDot / (cube1ToCube2Vector.magnitude * cube1ToCube3Vector.magnitude));
                var angle = Mathf.Rad2Deg * radians;
                Handles.color = mVectorColorProperty.colorValue;
                Handles.ArrowHandleCap(1, mCube1.transform.position,
                                        Quaternion.LookRotation(cube1ToCube2Vector),
                                        cube1ToCube2Vector.magnitude, EventType.Repaint);
                Handles.ArrowHandleCap(1, mCube1.transform.position,
                                        Quaternion.LookRotation(cube1ToCube3Vector),
                                        cube1ToCube3Vector.magnitude, EventType.Repaint);
                Handles.Label(mCube1.transform.position + cube1ToCube2Vector / 2, "1->2");
                Handles.Label(mCube1.transform.position + cube1ToCube3Vector / 2, "1->3");
                HandlesUtilities.DrawColorLable(mCube1.transform.position, $"夹角:{angle}", Color.green);
            }
        }
    }
}

/*
 * Description:             VectorDotStudy.cs
 * Author:                  TONYTANG
 * Create Date:             2022/03/17
 */

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

/// <summary>
/// VectorDotStudy.cs
/// 向量点乘学习
/// </summary>
public class VectorDotStudy : MonoBehaviour
{
    ******

    private void Start()
    {
        var cube1ToCube2Vector = Cube2.transform.position - Cube1.transform.position;
        var cube1ToCube3Vector = Cube3.transform.position - Cube1.transform.position;
        var vectorDot = Vector3.Dot(cube1ToCube2Vector, cube1ToCube3Vector);
        var radians = Mathf.Acos(vectorDot / (cube1ToCube2Vector.magnitude * cube1ToCube3Vector.magnitude));
        var angle = Mathf.Rad2Deg * radians;
        TipTxt.text = $"红色表示Cube1,绿色表示Cube2,蓝色表示Cube3\n" +
                        $"Cube1世界坐标:{Cube1.transform.position.ToString()} 朝向:{Cube1.transform.forward.ToString()}\n" +
                        $"Cube2世界坐标系:{Cube2.transform.position.ToString()} 朝向:{Cube2.transform.forward.ToString()}\n" +
                        $"Cube3世界坐标系:{Cube3.transform.position.ToString()} 朝向:{Cube3.transform.forward.ToString()}\n" +
                        $"Cube1到Cube2的向量:{cube1ToCube2Vector.ToString()}\n" +
                        $"Cube1到Cube3的向量:{cube1ToCube3Vector.magnitude}\n" +
                        $"1->2 点乘 2->3 = {vectorDot}\n" +
                        $"1->2和2->3的夹角:{angle}";
    }
}

$VectorDot$

通过上面的计算和可视化，可以看到我们通过Mathf.Acos(a.b / (|a| * |b|)) * Mathf.Rad2Deg实现了点乘角度的逆推。

并且因为点乘是a.b = |a| * |b| * cos(θ)，所以从点乘的结果我们可以分析出两个向量的角度情况:

a.b > 0表示a和b向量夹角为0度到90度

a.b==0表示a和b向量垂直

a.b<0表示a和b向量夹角为90度到180度

Note:

点乘满足交换律
点乘对零向量的解释是，零向量和任意其他向量垂直
Unity Mathf.Acos()返回的是弧度而非角度，需要通过乘以Mathf.Rad2Deg进行角度转换

叉乘

叉乘又称叉积，和点乘不一样，点乘得到一个标量并满足交换律，向量叉乘得到一个向量并且不满足交换律

[x1] * [x2] [y1 * z2 - z1 * y1 ]

a X b = [y1] * [y2] = [ z1 * x2 - x1 * z2 ]

[z1] * [y3] [ x1 * y2 - y1 * x2 ]

几何解释：

叉乘得到的向量垂直于原来的两个向量

$VectorCrossVisilization$

**|aXb|=|a||b|sinθ

从2维平面几何来说，a向量和b向量的叉乘长度等于以a向量和b向量为边的平行四边形面积。

我们知道了a向量叉乘b向量得到的是一个垂直于a和b平面的向量，那么这个向量是朝上还是朝下是如何决定的了？

通过把a向量和b向量首尾相连，在左手坐标系里如果a和b成顺时针，那么aXb的结果向量向外，反之向里。右手坐标系中则恰好相反。

接下来让我们结合实战，看下我们是如何利用叉乘计算出垂直a和b向量的c向量的:

/*
 * Description:             VectorCrossStudyEditor.cs
 * Author:                  TONYTANG
 * Create Date:             2022/03/17
 */

using System.Collections;
using System.Collections.Generic;
using UnityEditor;
using UnityEngine;

/// <summary>
/// VectorCrossStudyEditor.cs
/// VectorCrossStudy的Editor绘制
/// </summary>
[CustomEditor(typeof(VectorCrossStudy))]
public class VectorCrossStudyEditor : Editor
{
    ******

    /// <summary>
    /// 绘制相关向量
    /// </summary>
    private void DrawVectorInfo()
    {
        if (Event.current.type == EventType.Repaint)
        {
            if (mCube1 != null && mCube2 != null && mCube3 != null)
            {
                var cube1Forward = mCube1.transform.forward;
                var cube1ToCube2 = mCube2.transform.position - mCube1.transform.position;
                var vectorDot = Vector3.Dot(cube1Forward, cube1ToCube2);
                var radians = Mathf.Acos(vectorDot / (cube1Forward.magnitude * cube1ToCube2.magnitude));
                var angle = Mathf.Rad2Deg * radians;
                var vectorCross = Vector3.Cross(cube1Forward, cube1ToCube2);
                vectorCross = (angle <= Mathf.Epsilon && angle >= -Mathf.Epsilon) ? cube1Forward : vectorCross;
                Handles.color = mVectorColorProperty.colorValue;
                Handles.ArrowHandleCap(1, mCube1.transform.position,
                                        Quaternion.LookRotation(cube1Forward),
                                        mCoordinateSystemLengthProperty.floatValue, EventType.Repaint);
                Handles.ArrowHandleCap(1, mCube1.transform.position,
                                        Quaternion.LookRotation(cube1ToCube2),
                                        mCoordinateSystemLengthProperty.floatValue, EventType.Repaint);
                Handles.ArrowHandleCap(1, mCube1.transform.position,
                                        Quaternion.LookRotation(vectorCross),
                                        mCoordinateSystemLengthProperty.floatValue, EventType.Repaint);
                HandlesUtilities.DrawColorLable(mCube1.transform.position, $"夹角:{angle}", Color.green);
            }
        }
    }
}

/*
 * Description:             VectorCrossStudy.cs
 * Author:                  TONYTANG
 * Create Date:             2022/03/17
 */

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

/// <summary>
/// VectorCrossStudy.cs
/// 向量叉乘学习
/// </summary>
public class VectorCrossStudy : MonoBehaviour
{
    ******

    /// <summary>
    /// 旋转角度
    /// </summary>
    private float mAngle;

    /// <summary>
    /// 旋转轴
    /// </summary>
    private Vector3 mRotateAxis;

    private void Start()
    {
        RotateBtn.onClick.AddListener(OnRotateBtnClick);
        var cube1Forward = Cube1.transform.forward;
        var cube1ToCube2 = Cube2.transform.position - Cube1.transform.position;
        var vectorDot = Vector3.Dot(cube1Forward, cube1ToCube2);
        var radians = Mathf.Acos(vectorDot / (cube1Forward.magnitude * cube1ToCube2.magnitude));
        mAngle = Mathf.Rad2Deg * radians;
        mRotateAxis = Vector3.Cross(cube1Forward, cube1ToCube2);
        var rotationDirection = mRotateAxis.y > 0 ? "顺时针" : "逆时针";
        TipTxt.text = $"红色表示Cube1,绿色表示Cube2\n" +
                        $"Cube1世界坐标:{Cube1.transform.position.ToString()} 朝向:{Cube1.transform.forward.ToString()}\n" +
                        $"Cube2世界坐标系:{Cube2.transform.position.ToString()} 朝向:{Cube2.transform.forward.ToString()}\n" +
                        $"Cube1朝向:{cube1Forward.ToString()}\n" +
                        $"Cube1到Cube2向量:{cube1ToCube2.ToString()}\n" +
                        $"Cube1朝向 点乘 Cube1到Cube2向量 = {vectorDot}\n" +
                        $"Cube1朝向 叉乘 Cube1到Cube2向量 = {mRotateAxis.ToString()}\n" +
                        $"Cube1看向Cube2旋转方向:{rotationDirection}\n" +
                        $"Cube1看向Cube2旋转角度:{mAngle}";
    }

    /// <summary>
    /// 点击旋转Cube1看向Cube2
    /// </summary>
    public void OnRotateBtnClick()
    {
        Cube1.transform.Rotate(mRotateAxis, mAngle);
        Debug.Log($"Cube1看向Cube2旋转方向:{mRotateAxis} 旋转角度:{mAngle}");
    }
}

$VectorCross$

从上面的绘制可以看出，向量2-1叉乘向量1-3的结果是(0, 33.6, 0)，即结果向量是向上的，这和Unity左手坐标系，a和b头尾相连顺时针则向外(即向上)是符合的。

Note:

点乘和叉乘一起时，叉乘优先计算
叉乘不满足交换律和结合律
判定叉乘A叉乘B方向时可以通过四指指向A向量，然后转向B向量，此时大拇指的方向就是叉乘向量方向

运用

点乘和叉乘最典型的运用就是通过点乘计算两个向量的夹角，通过叉乘计算两个向量的角度方向。

典型的问题就是已知玩家A和B的位置和朝向，如何让玩家A看向玩家B。

要解决上述问题，我们需要通过玩家A到玩家B位置的向量和玩家A的朝向向量来计算出他们的夹角和旋转方向。

接下来结合Unity实战，让我们看看，我们是如何通过点乘和叉乘计算出两个向量的旋转角度和方向的:

/*
 * Description:             VectorUsingStudyEditor.cs
 * Author:                  TONYTANG
 * Create Date:             2022/03/17
 */

using System.Collections;
using System.Collections.Generic;
using UnityEditor;
using UnityEngine;

/// <summary>
/// VectorUsingStudyEditor.cs
/// VectorUsingStudy的Editor绘制
/// </summary>
[CustomEditor(typeof(VectorUsingStudy))]
public class VectorUsingStudyEditor : Editor
{
    ******

    /// <summary>
    /// 绘制相关向量
    /// </summary>
    private void DrawVectorInfo()
    {
        if (Event.current.type == EventType.Repaint)
        {
            if (mCube1 != null && mCube2 != null && mCube3 != null)
            {
                var cube1Forward = mCube1.transform.forward;
                var cube1ToCube2 = mCube2.transform.position - mCube1.transform.position;
                var vectorDot = Vector3.Dot(cube1Forward, cube1ToCube2);
                var radians = Mathf.Acos(vectorDot / (cube1Forward.magnitude * cube1ToCube2.magnitude));
                var angle = Mathf.Rad2Deg * radians;
                var vectorCross = Vector3.Cross(cube1Forward, cube1ToCube2);
                vectorCross = (angle <= Mathf.Epsilon && angle >= -Mathf.Epsilon) ? cube1Forward : vectorCross;
                Handles.color = mVectorColorProperty.colorValue;
                Handles.ArrowHandleCap(1, mCube1.transform.position,
                                        Quaternion.LookRotation(cube1Forward),
                                        mCoordinateSystemLengthProperty.floatValue, EventType.Repaint);
                Handles.ArrowHandleCap(1, mCube1.transform.position,
                                        Quaternion.LookRotation(cube1ToCube2),
                                        mCoordinateSystemLengthProperty.floatValue, EventType.Repaint);
                Handles.ArrowHandleCap(1, mCube1.transform.position,
                                        Quaternion.LookRotation(vectorCross),
                                        mCoordinateSystemLengthProperty.floatValue, EventType.Repaint);
                HandlesUtilities.DrawColorLable(mCube1.transform.position, $"夹角:{angle}", Color.green);
            }
        }
    }
}

/*
 * Description:             VectorUsingStudy.cs
 * Author:                  TONYTANG
 * Create Date:             2022/03/17
 */

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

/// <summary>
/// VectorUsingStudy.cs
/// 向量点乘和叉乘实战学习
/// </summary>
public class VectorUsingStudy : MonoBehaviour
{
    ******
    
    /// <summary>
    /// 旋转角度
    /// </summary>
    private float mAngle;

    /// <summary>
    /// 旋转轴
    /// </summary>
    private Vector3 mRotateAxis;

    private void Start()
    {
        RotateBtn.onClick.AddListener(OnRotateBtnClick);
        var cube1Forward = Cube1.transform.forward;
        var cube1ToCube2 = Cube2.transform.position - Cube1.transform.position;
        var vectorDot = Vector3.Dot(cube1Forward, cube1ToCube2);
        var radians = Mathf.Acos(vectorDot / (cube1Forward.magnitude * cube1ToCube2.magnitude));
        mAngle = Mathf.Rad2Deg * radians;
        mRotateAxis = Vector3.Cross(cube1Forward, cube1ToCube2);
        var rotationDirection = mRotateAxis.y > 0 ? "顺时针" : "逆时针";
        TipTxt.text = $"红色表示Cube1,绿色表示Cube2\n" +
                        $"Cube1世界坐标:{Cube1.transform.position.ToString()} 朝向:{Cube1.transform.forward.ToString()}\n" +
                        $"Cube2世界坐标系:{Cube2.transform.position.ToString()} 朝向:{Cube2.transform.forward.ToString()}\n" +
                        $"Cube1朝向:{cube1Forward.ToString()}\n" +
                        $"Cube1到Cube2向量:{cube1ToCube2.ToString()}\n" +
                        $"Cube1朝向 点乘 Cube1到Cube2向量 = {vectorDot}\n" +
                        $"Cube1朝向 叉乘 Cube1到Cube2向量 = {mRotateAxis.ToString()}\n" +
                        $"Cube1看向Cube2旋转方向:{rotationDirection}\n" +
                        $"Cube1看向Cube2旋转角度:{mAngle}";
    }

    /// <summary>
    /// 点击旋转Cube1看向Cube2
    /// </summary>
    public void OnRotateBtnClick()
    {
        Cube1.transform.Rotate(mRotateAxis, mAngle);
        Debug.Log($"Cube1看向Cube2旋转方向:{mRotateAxis} 旋转角度:{mAngle}");
    }
}