/*
 * 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;
    }
}

/*
 * 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;
    }
}

/*
 * 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;
    }
}

/// <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();
}

/// <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;
        }
    }
}

/// <summary>
/// ASTCSet.cs
/// ASTC设置
/// </summary>
[CreateAssetMenu(fileName = "ASTCSet", menuName = "ScriptableObjects/AssetPipeline/AssetProcessor/PreProcessor/ASTCSet", order = 1001)]
public class ASTCSet : BasePreProcessor
{
    /// <summary>
    /// 检查器名
    /// </summary>
    public override string Name
    {
        get
        {
            return "ASTC设置";
        }
    }

    /// <summary>
    /// 目标Asset类型
    /// </summary>
    public override AssetType TargetAssetType
    {
        get
        {
            return AssetType.Texture;
        }
    }

    /// <summary>
    /// 目标Asset管线处理类型
    /// </summary>
    public override AssetProcessType TargetAssetProcessType
    {
        get
        {
            return AssetProcessType.PreprocessTexture;
        }
    }

    /// <summary>
    /// 目标纹理格式
    /// </summary>
    [Header("目标纹理格式")]
    public TextureImporterFormat TargetTextureFormat = TextureImporterFormat.ASTC_4x4;
}

/// <summary>
/// ASTCSetJson.cs
/// ASTC设置预处理器Json
/// </summary>
[Serializable]
public class ASTCSetJson : BasePreProcessorJson
{
    /// <summary>
    /// 检查器名
    /// </summary>
    public override string Name
    {
        get
        {
            return "ASTC设置";
        }
    }

    /// <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 TextureImporterFormat TargetTextureFormat = TextureImporterFormat.ASTC_4x4;

    /// <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)
    {
        var textureImporter = assetImporter as TextureImporter;
        var actiivePlatformName = EditorUtilities.GetPlatformNameByTarget(EditorUserBuildSettings.activeBuildTarget);
        var platformTextureSettings = textureImporter.GetPlatformTextureSettings(actiivePlatformName);
        var automaticFormat = textureImporter.GetAutomaticFormat(actiivePlatformName);
        var isAutomaticASTC = ResourceUtilities.IsASTCFormat(automaticFormat);
        var textureFormat = isAutomaticASTC ? automaticFormat : TargetTextureFormat;
        platformTextureSettings.overridden = true;
        platformTextureSettings.format = textureFormat;
        textureImporter.SetPlatformTextureSettings(platformTextureSettings);
        AssetPipelineLog.Log($"设置AssetPath:{assetImporter.assetPath}纹理压缩格式:{textureFormat}".WithColor(Color.yellow));
    }
}

/*
 * 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()}";
    }
}

/*
 * 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");
            }
        }
    }
}

/*
 * 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}";
    }
}