ChivaFrameWork/Framework/SimulationToolDev/AnimationDriver/AnimationTool-Example/AnimationDataEditor.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using ChivaXR;
using Sirenix.OdinInspector;
using System.Linq;
using System.Text.RegularExpressions;
using UnityEngine.Events;
using ChivaXR.Op;
using System;
using QFramework;
#if UNITY_EDITOR

using UnityEditor;


using System.Text;
using UniRx;
using Valve.VR.InteractionSystem;
using UniRx.Triggers;

[Serializable]
public class AniDataEditorContainer
{
    [Sirenix.OdinInspector.ReadOnly]
    [HorizontalGroup("动画名称", Order = 1)]
    [HideLabel]
    public string AniName;

#if UNITY_EDITOR

    [HorizontalGroup("快捷指令", Order = 2)]
    [Button("更新模型")]
    [GUIColor("RelatColor")]
    [PropertyOrder(2)]
    /// <summary>
    /// 更新当前Scene选择物体到出发对象
    /// </summary>
    public void ReplaceSelectionObjToRelat()
    {
        if (Selection.activeGameObject != null)
        {
            relatGameObjects.Clear();
            relatGameObjects.AddRange(Selection.gameObjects);
        }
    }

#endif

    [HorizontalGroup("触发物体列表")]
    [GUIColor("RelatColor")]
    [PropertyOrder(3)]
    [ListDrawerSettings()]
    [LabelText("$relatInfo")]
    public List<GameObject> relatGameObjects = new List<GameObject>();

    public string relatInfo
    {
        get
        {
            if (relatGameObjects.Count == 1)
            {
                return "已指定模型:" + relatGameObjects[0].name;
            }
            else if (relatGameObjects.Count > 1)
            {
                return "已指定模型:" + relatGameObjects[0].name + "/" + relatGameObjects[1].name + "等多个物体";
            }
            else
            {
                return "未指定物体";
            }
        }
    }

#if UNITY_EDITOR

    /// <summary>
    /// 更新当前Scene选择物体到出发对象
    /// </summary>
    public void SelectRelatObj()
    {
        Selection.objects = relatGameObjects.ToArray();
        SceneView.lastActiveSceneView.FrameSelected();
    }

#endif

    private Color RelatColor()
    {
        if (relatGameObjects.Count != 0)
        {
            return new Color(0.7f, 1f, 0.7f);
        }
        return GUI.color;
    }

    [HideInInspector]
    /// <summary>
    /// 观察视角坐标
    /// </summary>
    public Vector3 ViewPoint;

    [HideInInspector]
    /// <summary>
    /// 观察视角角度
    /// </summary>
    public Vector3 ViewEuler;

    [HideInTables]
    public AniDataContainer AniDataContainer;
    public AniDataEditorContainer(AniDataContainer data)
    {
        AniName = data.AniDataName;
        AniDataContainer = data;
    }

    [TableColumnWidth(60)]
    [HorizontalGroup("动画状态", Order = 4)]
    [Button("初始状态")]
    [GUIColor("InitStateColor")]
    public void SetInitState()
    {
        if (AniDataContainer.aniData)
        {
            AniDataContainer.aniData.SetInitState();
        }
    }

    [ShowInInspector]
    [HideLabel]
    [HorizontalGroup("动画状态")]
    public AniData GetAniData
    {
        get { return AniDataContainer.aniData; }
    }

    [TableColumnWidth(60)]
    [HorizontalGroup("动画状态")]
    [Button("结束状态")]
    [GUIColor("FinishedStateColor")]
    public void SetFinishedState()
    {
        if (AniDataContainer.aniData)
        {
            AniDataContainer.aniData.SetFinishedState();
        }
    }
    private Color FinishedStateColor()
    {
        switch (AniDataContainer.aniData.currentAniState)
        {
            case Animation_State.finishedState:
                return new Color(0.7f, 1f, 0.7f);
        }
        return GUI.color;
    }

    private Color InitStateColor()
    {
        if (AniDataContainer.aniData != null)
        {
            switch (AniDataContainer.aniData.currentAniState)
            {
                case Animation_State.initState:
                    return new Color(0.7f, 1f, 0.7f);
            }
        }
        return GUI.color;
    }
}

[ExecuteInEditMode]
public class AnimationDataEditor : SerializedMonoSingleton<AnimationDataEditor>
{
    #region 动画流程创建

    [TabGroup("TapGroup", "动画流程创建")]
    [LabelText("动画流程列表")]
    [TableList(MaxScrollViewHeight = 300, ShowPaging = true, NumberOfItemsPerPage = 10, AlwaysExpanded = true/*, IsReadOnly = true*/)]
    public List<AniDataEditorContainer> animationEditorDatas = new List<AniDataEditorContainer>();

    [HideInInspector]
    public string operationDataName;

    [ValidateInput("NewAniDataNameStandard", "$AddAniDataNameErrorInfo")]
    [FoldoutGroup("TapGroup/动画流程创建/创建动画", Order = -1)]
    [LabelText("新建动画名称(支持多行名称创建)")]
    [MultiLineProperty(10)]
    public string m_AddAnimationDataNames;

    public bool NewAniDataNameStandard
    {
        get
        {
            if (m_AddAnimationDataNames.IsNullOrEmpty()) return false;
            if (AnimationManager.Instance.aniDatasDic.ContainsKey(m_AddAnimationDataNames)) return false;
            if (m_AddAnimationDataNames.Split('\n').Length >= 2)
            {
                string[] AniDataNames = m_AddAnimationDataNames.Split('\n');
                foreach (var item in AniDataNames)
                {
                    if (AnimationManager.Instance.aniDatasDic.ContainsKey(item))
                    {
                        return false;
                    }
                    //if (AniDataNames.Where(s => s == item).Count() >= 2)
                    //{
                    //    return false;
                    //}
                }
            }
            return true;
        }
    }
    public string AddAniDataNameErrorInfo
    {
        get
        {
            if (m_AddAnimationDataNames.IsNullOrEmpty()) return "注册动画名称不能为空";
            if (AnimationManager.Instance.aniDatasDic.ContainsKey(m_AddAnimationDataNames)) return m_AddAnimationDataNames + "已注册";
            if (m_AddAnimationDataNames.Split('\n').Length >= 2)
            {
                foreach (var item in m_AddAnimationDataNames.Split('\n'))
                {
                    string[] AniDataNames = m_AddAnimationDataNames.Split('\n');
                    if (AnimationManager.Instance.aniDatasDic.ContainsKey(item))
                    {
                        return item + "已注册";
                    }
                    //if (AniDataNames.Where(s => s == item).Count() >= 2)
                    //{
                    //    return "当前添加动画名称内" + item + "重复";
                    //}
                }
            }

            return "";
        }
    }

    [PropertySpace(10, 10)]
    [FoldoutGroup("TapGroup/动画流程创建/创建动画/辅助工具", Order = 1)]
    [FoldoutGroup("TapGroup/动画流程创建/创建动画/辅助工具/RefrushAniIndex", GroupName = "按照当前列表刷新新增动画名称序号", Order = 1)]
    [Button("刷新待创建动画名称序号")]
    public void RefrushAniDataIndex()
    {
        string[] AniDataNames = m_AddAnimationDataNames.Split('\n');

        StringBuilder stringBuilder = new StringBuilder();
        int startIndex = animationEditorDatas.Count;
        for (int i = 0; i < AniDataNames.Length; i++)
        {
            stringBuilder.Append((startIndex + i + 1).ToString("000") + "_" + AniDataNames[i]);
            if (i < AniDataNames.Length - 1)
            {
                stringBuilder.AppendLine();
            }
        }

        m_AddAnimationDataNames = stringBuilder.ToString();
    }

    [FoldoutGroup("TapGroup/动画流程创建/创建动画/辅助工具/ImportAni", GroupName = "导入动画(基于AnimationManager)", Order = 2)]
    [LabelText("动画导入(基于AnimationManager已注册AniData)")]
    [ShowInInspector]
    [ValueDropdown("GetAllOperationDataNames", IsUniqueList = true)]
    public string OperationDataName
    {
        get { return operationDataName; }
        set
        {
            if (operationDataName != value)
            {
                operationDataName = value;
            }
        }
    }
    private static IEnumerable GetAllOperationDataNames()
    {
        return AnimationManager.Instance.animationDatas.Select(s => new ValueDropdownItem(s.AniDataName, s.AniDataName));
    }

    [FoldoutGroup("TapGroup/动画流程创建/创建动画/辅助工具/ImportAni", Order = 1)]
    [Button("导入")]
    public void AddSelectOperationData()
    {
        if (operationDataName == "") { return; }
        AniDataContainer tmpAniDataContainer =
           AnimationManager.Instance.animationDatas.Where(s => s.AniDataName == operationDataName).First();

        if (tmpAniDataContainer != null)
        {
            animationEditorDatas.Add(new AniDataEditorContainer(tmpAniDataContainer));
        }
    }

    [HideInInspector]
    public string aniDataSelectReName;

    [FoldoutGroup("TapGroup/动画流程创建/创建动画/辅助工具/ReName", GroupName = "动画重命名", Order = 3)]
    [LabelText("选择动画")]
    [ShowInInspector]
    [ValueDropdown("GetAniDataEditorAniDataNames", IsUniqueList = true)]
    public string AniDataSelectReName
    {
        get { return aniDataSelectReName; }
        set
        {
            if (aniDataSelectReName != value)
            {
                aniDataSelectReName = value;
            }
        }
    }
    private static IEnumerable GetAniDataEditorAniDataNames()
    {
        return AnimationDataEditor.Instance.animationEditorDatas.Select(s => new ValueDropdownItem(s.AniName, s.AniName));
    }

    [FoldoutGroup("TapGroup/动画流程创建/创建动画/辅助工具/ReName", GroupName = "动画重命名", Order = 5)]
    [LabelText("重命名称")]
    public string m_AniDataReName;

    [FoldoutGroup("TapGroup/动画流程创建/创建动画/辅助工具/ReName", GroupName = "动画重命名", Order = 4)]
    [Button("重命名")]
    [GUIColor("ReNameBtnColor")]
    [EnableIf("ReNameAniDataStandard")]
    public void AniDataReName()
    {
        AniDataEditorContainer reNameAniDataEditorContainer = animationEditorDatas.Where(s => s.AniName == aniDataSelectReName).First();
        AnimationManager.Instance.AniDataReName(reNameAniDataEditorContainer.AniDataContainer, m_AniDataReName);
        reNameAniDataEditorContainer.AniDataContainer.aniData.gameObject.name = m_AniDataReName;
        reNameAniDataEditorContainer.AniName = m_AniDataReName;
    }
    public bool ReNameAniDataStandard
    {
        get
        {
            if (m_AniDataReName.IsNullOrEmpty()) return false;
            if (AnimationManager.Instance.aniDatasDic.ContainsKey(m_AniDataReName)) return false;
            return true;
        }
    }
    /// <summary>
    /// 重命名按钮准许颜色
    /// </summary>
    /// <returns></returns>
    private Color ReNameBtnColor()
    {
        if (ReNameAniDataStandard)
        {
            return new Color(0.7f, 1f, 0.7f);
        }
        return GUI.color;
    }

    [FoldoutGroup("TapGroup/动画流程创建/模型快捷操作", GroupName = "模型快捷操作", Order = -2)]
    [HorizontalGroup("TapGroup/动画流程创建/模型快捷操作/模型处理")]
    [Button("所选物体合并")]
    public void SelectObjsCombine()
    {
        GameObject combineObjsParent = new GameObject();
        combineObjsParent.transform.parent = Selection.activeGameObject.transform.parent;

        combineObjsParent.transform.position = Selection.activeGameObject.transform.position;
        for (int i = 0; i < Selection.gameObjects.Length; i++)
        {
            Selection.gameObjects[i].transform.parent = combineObjsParent.transform;
        }

        combineObjsParent.transform.SetAsFirstSibling();

        Selection.activeGameObject = combineObjsParent;
    }
    [FoldoutGroup("TapGroup/动画流程创建/模型快捷操作", GroupName = "模型快捷操作", Order = -2)]
    [HorizontalGroup("TapGroup/动画流程创建/模型快捷操作/模型处理")]
    [Button("重置所选物体父级坐标与所选物体一致")]
    public void ReSetParentPos()
    {
        Transform reSetParent = Selection.activeGameObject.transform.parent;

        List<Transform> childObjs = new List<Transform>();
        for (int i = 0; i < reSetParent.childCount; i++)
        {
            childObjs.Add(reSetParent.GetChild(i).transform);
        }

        for (int i = 0; i < childObjs.Count; i++)
        {
            childObjs[i].transform.parent = null;
        }

        reSetParent.transform.position = Selection.activeGameObject.transform.position;

        for (int i = 0; i < childObjs.Count; i++)
        {
            childObjs[i].transform.parent = reSetParent;
        }
        childObjs.Clear();
    }

    [FoldoutGroup("TapGroup/动画流程创建/创建动画")]
    [Button("创建动画")]
    [EnableIf("NewAniDataNameStandard")]
    public void CreateNewAniData()
    {
        string[] AniDataNames = m_AddAnimationDataNames.Split('\n');

        AniDataNames = CheckAniDataNames(AniDataNames);

        for (int i = 0; i < AniDataNames.Length; i++)
        {
            if (String.IsNullOrEmpty(AniDataNames[i])) break;
            AniData newAniData = new GameObject(AniDataNames[i]).AddComponent<AniData>();
            newAniData.aniName = AniDataNames[i];
            newAniData.aniDescriptioin = AniDataNames[i];
            newAniData.RegisterData();
            newAniData.transform.parent = AnimationManager.Instance.transform;
            newAniData.transform.SetAsLastSibling();

            AniDataContainer tmpAniDataContainer =
            AnimationManager.Instance.animationDatas.Where(s => s.AniDataName == AniDataNames[i]).First();
            if (tmpAniDataContainer != null)
            {
                animationEditorDatas.Add(new AniDataEditorContainer(tmpAniDataContainer));
            }
        }

        m_AddAnimationDataNames = "";
    }

    /// <summary>
    /// 检查内部重复名称
    /// </summary>
    /// <param name="AniDataNames"></param>
    private string[] CheckAniDataNames(string[] AniDataNames)
    {
        foreach (var item in AniDataNames)
        {
            List<string> tmpNames = AniDataNames.ToList().FindAll(name => name == item);

            if (tmpNames.Count >= 2)
            {
                for (int i = 0; i < tmpNames.Count; i++)
                {
                    AniDataNames[AniDataNames.ToList().IndexOf(tmpNames[i])] = tmpNames[i] + (i + 1);
                }
            }
        }

        return AniDataNames;
    }

    #endregion

    #region 动画编辑

    [BoxGroup("流程控制", CenterLabel = true, Order = -1)]
    [HorizontalGroup("流程控制/JumpAni", Order = -1)]
    [LabelText("跳步名称(编辑器跳步使用)")]
    [ValueDropdown("GetProcessAniDataNames")]
    public string jumpTargetAnimation;

    private IEnumerable GetProcessAniDataNames()
    {
        return animationEditorDatas.Select(s => new ValueDropdownItem(s.AniName, s.AniName));
    }

    [HorizontalGroup("流程控制/JumpAni", Order = -1)]
    [Button("跳转到对应动画")]
    public void JumpToTargetAnimation()
    {
        JumpProcess(jumpTargetAnimation);
    }

    [Title("流程控制/JumpState/当前动画", TitleAlignment = TitleAlignments.Centered, Title = "$m_title")]
    [BoxGroup("流程控制")]
    [Button("初始化动画组")]
    /// <summary>
    ///初始化步骤状态
    /// </summary>
    public void InitStepState()
    {
        for (int i = currentStepID; i <= animationEditorDatas.Count - 1; i++)
        {
            SetAniDataState(animationEditorDatas[i].AniName, Animation_State.finishedState);
        }

        for (int i = animationEditorDatas.Count - 1; i >= 0; i--)
        {
            SetAniDataState(animationEditorDatas[i].AniName, Animation_State.initState);
        }

        Debug.Log("初始化跳转至第一步");

        currentStepID = 1;
        RefreshAniData();
    }
    [HorizontalGroup("流程控制/JumpState")]
    [Button("上一步")]
    [PropertySpace(0, 10)]
    public void PreProcess()
    {
        JumpProcess(currentStepID - 1);
    }
    [HorizontalGroup("流程控制/JumpState")]
    [Button("下一步")]
    [PropertySpace(0, 10)]
    public void EnterNextProcess()
    {
        JumpProcess(currentStepID + 1);
    }

    public string m_title
    {
        get
        {
            if (animationEditorDatas.Count == 0)
            {
                return "暂无动画";
            }
            return "第" + currentStepID + "步：" + aniName;
        }
    }
    [HideInInspector]
    public AniData m_CurrentAniData;
    [HideInInspector]
    public string aniName;
    [HideInInspector]
    /// <summary>
    /// 当前步骤（从1开始）
    /// </summary>
    public int currentStepID = 1;

    [InfoBox("$AnimationDriversDescription", InfoMessageType.None)]
    [FoldoutGroup("动画快捷添加", Order = 2)]
    [HorizontalGroup("动画快捷添加/selectObjs")]
    [Button("选中当前步骤指定物体")]
    public void SelectCurrentAniEditorDataReleatObjs()
    {
        animationEditorDatas[CurrentListID].SelectRelatObj();
    }

    [FoldoutGroup("动画快捷添加", Order = 2)]
    [HorizontalGroup("动画快捷添加/activeGroup")]
    [Button("所选物体显示")]
    [GUIColor("SelectColor")]
    public void CreateSelectionObjsActiveAniDriver()
    {
        if (m_CurrentAniData != null)
        {
            AniDriver_ActiveObjs tmpAniDriver = new AniDriver_ActiveObjs();
            m_CurrentAniData.AnimationDriverDatas.Add(tmpAniDriver);
            tmpAniDriver.objs.AddRange(Selection.gameObjects);
            tmpAniDriver.activeObjs = true;
        }
    }
    [FoldoutGroup("动画快捷添加")]
    [HorizontalGroup("动画快捷添加/activeGroup")]
    [Button("所选物体隐藏")]
    [GUIColor("SelectColor")]
    public void CreateSelectionObjsDisActiveAniDriver()
    {
        if (m_CurrentAniData != null)
        {
            AniDriver_ActiveObjs tmpAniDriver = new AniDriver_ActiveObjs();
            m_CurrentAniData.AnimationDriverDatas.Add(tmpAniDriver);
            tmpAniDriver.objs.AddRange(Selection.gameObjects);
            tmpAniDriver.activeObjs = false;
        }
    }

    [FoldoutGroup("动画快捷添加")]
    [HorizontalGroup("动画快捷添加/moveGroup")]
    [Button("所选物体路径动画")]
    [GUIColor("SelectColor")]
    public void CreateSelectionObjsMovePathAniDriver()
    {
        if (m_CurrentAniData != null)
        {
            AniDriver_MoveByPathItem tmpAniDriver = new AniDriver_MoveByPathItem();

            m_CurrentAniData.AnimationDriverDatas.Add(tmpAniDriver);

            Transform movePathGroup = m_CurrentAniData.transform.Find("MovePathGroup");
            if (movePathGroup == null)
            {
                movePathGroup = new GameObject("MovePathGroup").transform;
                movePathGroup.parent = m_CurrentAniData.transform;
                movePathGroup.transform.localPosition = Vector3.zero;
                movePathGroup.transform.localRotation = Quaternion.identity;
                movePathGroup.transform.localScale = Vector3.one;
            }

            tmpAniDriver.mMovePathItem = new GameObject(Selection.activeGameObject.name + "_MovePath").AddComponent<MovePathItem>();
            tmpAniDriver.mMovePathItem.transform.parent = movePathGroup;
            tmpAniDriver.mMovePathItem.transform.localPosition = Vector3.zero;
            tmpAniDriver.mMovePathItem.transform.localRotation = Quaternion.identity;
            tmpAniDriver.mMovePathItem.moveTarget = Selection.activeGameObject;
            tmpAniDriver.animationSequence = AnimationSequence.waitFinished;
            tmpAniDriver.mMovePathItem.AddMovePath();
            Selection.activeGameObject = tmpAniDriver.mMovePathItem.gameObject;
        }
    }

    [FoldoutGroup("动画快捷添加")]
    [HorizontalGroup("动画快捷添加/moveGroup")]
    [Button("所选物体简易动画")]
    [GUIColor("SelectColor")]
    public void CreateSelectionObjsSimpleMoveAniDriver()
    {
        if (m_CurrentAniData != null)
        {
            AniDriver_SimpleMoveRot tmpAniDriver = new AniDriver_SimpleMoveRot();

            m_CurrentAniData.AnimationDriverDatas.Add(tmpAniDriver);

            Transform simpleMoveGroup = m_CurrentAniData.transform.Find("SimpleMoveGroup");
            if (simpleMoveGroup == null)
            {
                simpleMoveGroup = new GameObject("SimpleMoveGroup").transform;
                simpleMoveGroup.parent = m_CurrentAniData.transform;
                simpleMoveGroup.transform.localPosition = Vector3.zero;
                simpleMoveGroup.transform.localRotation = Quaternion.identity;
                simpleMoveGroup.transform.localScale = Vector3.one;
            }

            tmpAniDriver.mSimpleMoveItem = new GameObject(Selection.activeGameObject.name + "_SimpleMove").AddComponent<SimpleMoveItem>();
            tmpAniDriver.mSimpleMoveItem.transform.parent = simpleMoveGroup;
            tmpAniDriver.mSimpleMoveItem.transform.localPosition = Vector3.zero;
            tmpAniDriver.mSimpleMoveItem.transform.localRotation = Quaternion.identity;
            tmpAniDriver.animationSequence = AnimationSequence.waitFinished;

            tmpAniDriver.mSimpleMoveItem.AddSelectObj();
            Selection.activeGameObject = tmpAniDriver.mSimpleMoveItem.gameObject;
        }
    }

    [FoldoutGroup("动画快捷添加")]
    [HorizontalGroup("动画快捷添加/moveGroup")]
    [Button("所选物体工具动画")]
    [GUIColor("SelectColor")]
    public void CreateSelectionObjToolAnimationAniDriver()
    {
        if (m_CurrentAniData != null)
        {
            AniDriver_ToolAnimationItem tmpAniDriver = new AniDriver_ToolAnimationItem();

            m_CurrentAniData.AnimationDriverDatas.Add(tmpAniDriver);

            Transform ToolAnimationGroup = m_CurrentAniData.transform.Find("ToolAnimationGroup");
            if (ToolAnimationGroup == null)
            {
                ToolAnimationGroup = new GameObject("ToolAnimationGroup").transform;
                ToolAnimationGroup.parent = m_CurrentAniData.transform;
                ToolAnimationGroup.transform.localPosition = Vector3.zero;
                ToolAnimationGroup.transform.localRotation = Quaternion.identity;
                ToolAnimationGroup.transform.localScale = Vector3.one;
            }

            tmpAniDriver.mToolAnimationItem = new GameObject(Selection.activeGameObject.name + "_ToolAnimation").AddComponent<ToolAnimationItem>();
            tmpAniDriver.mToolAnimationItem.transform.parent = ToolAnimationGroup;
            tmpAniDriver.mToolAnimationItem.transform.localPosition = Vector3.zero;
            tmpAniDriver.mToolAnimationItem.transform.localRotation = Quaternion.identity;
            tmpAniDriver.animationSequence = AnimationSequence.waitFinished;

            tmpAniDriver.mToolAnimationItem.AddSelectObj();
            Selection.activeGameObject = tmpAniDriver.mToolAnimationItem.gameObject;
        }
    }
    [TabGroup("TapGroup", "当前动画编辑")]
    [LabelText("动画配置表")]
    [TypeFilter("GetFilteredTypeList")]
    [ListDrawerSettings(Expanded = true)]
    public List<AnimationDriverBase> AnimationDriverDatas;
    public IEnumerable<Type> GetFilteredTypeList()
    {
        var q = typeof(AnimationDriverBase).Assembly.GetTypes()
            .Where(x => !x.IsAbstract)
            .Where(x => !x.IsGenericTypeDefinition)
            .Where(x => typeof(AnimationDriverBase).IsAssignableFrom(x));

        return q;
    }

    public string AnimationDriversDescription
    {
        get
        {
            if (AnimationDriverDatas == null || AnimationDriverDatas.Count == 0) return "暂无动画";

            StringBuilder sb = new StringBuilder();
            sb.AppendLine(m_title + "当前步骤动画描述:");
            for (var i = 0; i < AnimationDriverDatas.Count; i++)
            {
                sb.AppendLine((i + 1) + "--" + AnimationDriverDatas[i].AnimationDescription());
            }
            return sb.ToString();
        }
    }


    private Color SelectColor()
    {
        return new Color(0.7f, 1f, 0.7f);
    }
    #endregion

    #region AnimationStateController

    /// <summary>
    /// 状态跳转
    /// </summary>
    /// <param name="aniDataName"></param>
    public void SetAniDataState(string aniDataName, Animation_State aniState)
    {
        if (animationEditorDatas.Where(s => s.AniName == aniDataName).Count() > 0)
        {
            AniDataEditorContainer tempAniDataEditor = animationEditorDatas.Where(s => s.AniName == aniDataName).First();

            switch (aniState)
            {
                case Animation_State.initState:
                    tempAniDataEditor.SetInitState();
                    break;
                case Animation_State.finishedState:
                    tempAniDataEditor.SetFinishedState();
                    break;
            }
        }
        else
        {
            Debug.LogError("无该动画片段--->" + aniDataName);
        }
    }

    /// <summary>
    /// 当前步骤在List中的索引(从0开始)
    /// </summary>
    public int CurrentListID
    {
        get
        {
            if ((currentStepID - 1) >= 0 && ((currentStepID - 1) < CurrentListsCount))
            {
                return currentStepID - 1;
            }
            Debug.LogError("当前步骤超出List范围");
            return 0;
        }
    }

    /// <summary>
    /// 当前List步骤数量
    /// </summary>
    public int CurrentListsCount
    {
        get
        {
            return animationEditorDatas.Count;
        }
    }

    /// <summary>
    /// 刷新当前播放信息
    /// </summary>
    private void RefreshAniData()
    {
        m_CurrentAniData = animationEditorDatas[currentStepID - 1].AniDataContainer.aniData;
        AnimationDriverDatas = m_CurrentAniData.AnimationDriverDatas;
        aniName = m_CurrentAniData.aniName;
    }

    /// <summary>
    /// 跳步
    /// </summary>
    public void JumpProcess(int targetStepID)
    {
        //步骤错误
        if (targetStepID < 1 || targetStepID > CurrentListsCount)
        {
            Debug.LogError("流程跳转：无目标步骤");
            return;
        }

        if (targetStepID == currentStepID)
        {
            SetAniDataState(animationEditorDatas[CurrentListID].AniName, Animation_State.initState);
        }
        //向前跳步
        else if (targetStepID < currentStepID)
        {
            for (int i = currentStepID - 1; i >= targetStepID - 1; i--)
            {
                SetAniDataState(animationEditorDatas[i].AniName, Animation_State.initState);
            }
        }
        //向后跳步
        else
        {
            for (int i = currentStepID - 1; i <= targetStepID - 1; i++)
            {
                if (i.Equals(targetStepID - 1))
                {
                    SetAniDataState(animationEditorDatas[i].AniName, Animation_State.initState);
                }
                else
                {
                    SetAniDataState(animationEditorDatas[i].AniName, Animation_State.finishedState);
                }
            }
        }

        currentStepID = targetStepID;
        RefreshAniData();
    }

    /// <summary>
    /// 跳步
    /// </summary>
    /// <param name="targetStepID">目标步骤ID</param>
    /// <param name="editorMode">是否在编辑器状态下</param>
    /// <param name="enter">是否执行当前步骤</param>
    public void JumpProcess(string aniName)
    {
        int targetStepID = 0;

        if (animationEditorDatas.Where(s => s.AniName == aniName).Count() > 0)
        {
            AniDataEditorContainer tempAniData = animationEditorDatas.Where(s => s.AniName == aniName).First();

            targetStepID = animationEditorDatas.IndexOf(tempAniData) + 1;
        }
        else
        {
            return;
        }

        //步骤错误
        if (targetStepID < 1 || targetStepID > CurrentListsCount)
        {
            Debug.LogError("流程跳转：无目标步骤");
            return;
        }

        if (targetStepID == currentStepID)
        {
            SetAniDataState(animationEditorDatas[CurrentListID].AniName, Animation_State.initState);
        }
        //向前跳步
        else if (targetStepID < currentStepID)
        {
            for (int i = currentStepID - 1; i >= targetStepID - 1; i--)
            {
                SetAniDataState(animationEditorDatas[i].AniName, Animation_State.initState);
            }
        }
        //向后跳步
        else
        {
            for (int i = currentStepID - 1; i <= targetStepID - 1; i++)
            {
                if (i.Equals(targetStepID - 1))
                {
                    SetAniDataState(animationEditorDatas[i].AniName, Animation_State.initState);
                }
                else
                {
                    SetAniDataState(animationEditorDatas[i].AniName, Animation_State.finishedState);
                }
            }
        }

        currentStepID = targetStepID;
        RefreshAniData();
    }
    /// <summary>
    /// Editor模式下当前选中物体列表
    /// </summary>
    [Title("辅助参数")]
    [ListDrawerSettings(IsReadOnly = true, Expanded = true)]
    [LabelText("Scene场景当前选中物体列表")]
    [PropertyOrder(3)]
    public List<GameObject> selection = new List<GameObject>();
    private void OnEnable()
    {
        Selection.selectionChanged += EditorSelectionChanged;
    }
    private void OnDisable()
    {
        Selection.selectionChanged -= EditorSelectionChanged;
    }

    void EditorSelectionChanged()
    {
        selection.Clear();
        selection.AddRange(Selection.gameObjects);
    }
    #endregion
}

#endif