using UnityEngine;using System.Collections;/* * ---------------------------------------------------------------------------- * Creation Info * ---------------------------------------------------------------------------- * Root Motion Computer * Version: 1.2 * Date: 2010.12.08 * Author: Adam Mechtley (http://adammechtley.com) * Created for Mixamo, Inc. (http://mixamo.com) *  * ---------------------------------------------------------------------------- * Description: * ---------------------------------------------------------------------------- * Like many other game engines, Unity was developed with the intent that * character animations be created in-place, as though the characters were * moving and acting on a treadmill, and the characters‘ root nodes would then * be moved programmatically using physics, a character controller, or another * procedural mechanism. Unfortunately, many character movements, such as a * zombie lurching forward, do not move forward with a constant velocity. * Consequently, such motions can introduce foot sliding or dramatic bobbing * back and forth when moved procedurally. *  * The Root Motion Computer was designed to solve this problem, particularly by * leveraging the fact that motion-capture animations actually capture a moving * actor rather than an actor performing in place. Using all of the default * settings, the root motion computer uses the movement of the character‘s * pelvis to move move the root node. Thus, in-place motions will play back in- * place, while motions captured with forward or sideways movement will * actually move the character when looping, rather than snapping back to the * starting location. Users can also configure the computer‘s various settings * to instead pipe its output to another script to drive the velocity of a * character controller or another movement tool. *  * ---------------------------------------------------------------------------- * Usage: * ---------------------------------------------------------------------------- * You can place this script anywhere in your project folder. Because it is * written in C#, however, you must put it in your Plugins folder in your * project if you are coding in UnityScript. *  * In many cases, you can simply add the component to your character and it * should "just work." Otherwise you can manually specify various properties: *  * isManagedExternally: Specifies that another script will invoke Initialize() *     and ComputeRootMotion(). This is used if you need to manage the *     execution order to prevent the computer from interfering with animation *     requests you may make in your own Start(), Awake(), or LateUpdate() *     functions. * rootNode: The transform that is actually moved, whether by the computer or *     by another mechanism like a character controller. * anim: The animation component from which to process AnimationStates. * pelvis: The character‘s pelvis transform. This object is used to determine *     changes in the character‘s overall position or rotation. * pelvisForwardAxis: The axis on the pelvis that points to the character‘s *     front in the bind pose. * pelvisRightAxis: The axis on the pelvis that points to the character‘s right *     in the bind pose. * computationMode: Specifies whether the computer should compute only forward *     translation, all translation (forward-back and side-to-side), or all *     translation as well as turning rotation. * applyMotion: Specifies whether the computation results should be applied to *     rootNode. Set to false if output is going to be read and processed by *     another script to move a character controller, for example. * deltaPosition: Represents the character‘s change in translation since the *     last frame, given in the space of rootNode. * deltaRotation: Represents the character‘s change in orientation since the *     last frame, given in the space of rootNode. * deltaEulerAngles: Same as deltaRotation but converted into Euler angles. * isDebugMode: Renders pelvis axes in the scene view when the character is *     selected. Renders axis tripods to illustrate the position and *     orientation of the pelvis and root node when the game is playing. * debugGizmoSize: A scalar for the debug gizmos. *  * ---------------------------------------------------------------------------- * Notes and Limitations: * ---------------------------------------------------------------------------- * 1. The computer is currently only designed to handle movement of characters * forward-back and side-to-side with rotation about their up-axes. As such, it * offers no generalized mechanism for adjusting the height of a character * (e.g. jumping, going up stairs). Because the computer operates using delta  * values in LateUpdate(), however, you can implement your own custom logic for * adjusting a character‘s height in your own movement code and the computer * will simply work on top if it. *  * 2. As of Unity 2.x, there is no way to query the post-normalized weights of * AnimationStates. The computer attempts to work around this by rebuilding * normalized weights for each state using the same process that Unity uses * (applying weights to top-most layers first, and then working down). *  * 3. The computer currently assumes that the clip for any particular * AnimationState will not change. (Generally speaking, it should not once it * has been added to the animation component anyway.) *  * 4. The computer should support adding new clips at run-time, though the * feature has been tested only briefly. *  * 5. Because of how rotation computation works, if a character is on his * stomach and then rolls onto his back (or vice-versa), then it is inadvisable * to blend in other motions at the time the actual roll occurs (unless it is * another synchronized rolling motion). * */// a struct to store information about all of the animation states/// <summary>/// 存放动画状态的结构体/// </summary>public struct AnimInfo{    /// <summary>    /// 当前动作的规范化时间，直接指向对应动画的规范化时间    /// </summary>    public float currentNormalizedTime;    /// <summary>    /// 之前动作的规范化时间    /// </summary>    public float previousNormalizedTime;    /// <summary>    /// 当前动作的权重，直接指向对应动画的权重    /// </summary>    public float currentWeight; // the actual weight value queried from the AnimationState    /// <summary>    /// 实际播放出来的权重    /// </summary>    public float contributingWeight; // the weight the AnimationState is actually contributing to the final result based on layers    /// <summary>    /// 当前位置    /// </summary>    public Vector3 currentPosition;    /// <summary>    /// 之前的位置    /// </summary>    public Vector3 previousPosition;    /// <summary>    /// 开始位置    /// </summary>    public Vector3 startPosition;    /// <summary>    /// 结束位置    /// </summary>    public Vector3 endPosition;    /// <summary>    /// 当前的轴    /// </summary>    public Vector3 currentAxis;    /// <summary>    /// 之前的轴    /// </summary>    public Vector3 previousAxis;    /// <summary>    /// 开始的轴    /// </summary>    public Vector3 startAxis;    /// <summary>    /// 结束的轴    /// </summary>    public Vector3 endAxis;    /// <summary>    /// 全部旋转    /// </summary>    public Quaternion totalRotation;}// an enum to describe how delta values should be computed/// <summary>/// 增量值计算枚举/// </summary>public enum RootMotionComputationMode{    ZTranslation,    XZTranslation,    TranslationAndRotation}/// <summary>/// 管理所有动画，权重，混合/// </summary>[AddComponentMenu("Mixamo/Root Motion Computer")]public class RootMotionComputer : MonoBehaviour{    // the transform to have root motion applied    /// <summary>    /// 脚本所在对象    /// </summary>    public Transform rootNode;    // the animation component where all of the clips for this model exist    /// <summary>    /// 当前所有的动画数组    /// </summary>    public Animation anim;    // the pelvis joint from which the script obtains x-z motion and y-rotation for the root    /// <summary>    /// 模型所在的对象，设置X向Z移动、Y旋转    /// </summary>    public Transform pelvis;    /// <summary>    /// 骨盆局部的轴，右方向 也是X轴    /// </summary>    public Vector3 pelvisRightAxis = Vector3.right; // its local axis specifying the right direction    /// <summary>    /// 暂时存储骨盆的局部位置    /// </summary>    private Vector3 pLocalPosition; // a variable to temporarily store and set the pelvis local position after computation    // parameters for computation and application of result    /// <summary>    /// 是否是外部管理    /// </summary>    public bool isManagedExternally = false; // if the computer is managed externally, then its calls are invoked manually    /// <summary>    /// 增量结构    /// </summary>    public RootMotionComputationMode computationMode = RootMotionComputationMode.TranslationAndRotation;    /// <summary>    /// 应用运动    /// </summary>    public bool applyMotion = true;    // information about the computed root position    /// <summary>    /// 来自上一帧的三角州位置    /// </summary>    private Vector3 dPosition = Vector3.zero; // local-space delta position since previous frame    /// <summary>    /// 来自上一帧的三角州位置    /// </summary>    public Vector3 deltaPosition { get { return dPosition; } }    /// <summary>    /// 减少分配的一个容器    /// </summary>    private Vector3 p; // a simple container to minimize allocations    // information about the computed root rotation    /// <summary>    /// 来自上一帧的三角州旋转    /// </summary>    private Quaternion dRotation = Quaternion.identity; // local-space delta rotation since previous frame    /// <summary>    /// 来自上一帧的三角州旋转    /// </summary>    public Quaternion deltaRotation { get { return dRotation; } }    /// <summary>    /// 来自上一帧的三角州旋转的欧拉角    /// </summary>    public Vector3 deltaEulerAngles { get { return dRotation.eulerAngles; } }    // a hashtable storing information about each AnimationState    /// <summary>    /// 存放所有动画的哈希表    /// </summary>    private Hashtable animInfoTable;    /// <summary>    /// 动画状态信息结构体，为了减少分配    /// </summary>    private AnimInfo info; // a simple container to minimize allocations    // specify whether the component should be running in debug mode    /// <summary>    /// 是否是调试模式下运行    /// </summary>    public bool isDebugMode = true;    /// <summary>    /// 调试线框的大小    /// </summary>    public float debugGizmoSize = 0.25f;    // is the computation occuring on the first frame of execution?    /// <summary>    /// 计算上的第一帧执行？    /// </summary>    private bool isFirstFrame = true;    // the highest and lowest layers on which there is an AnimationState    /// <summary>    /// 最高的层    /// </summary>    private int highestLayer = 0;    /// <summary>    /// 最低的层    /// </summary>    private int lowestLayer = 0;    /*     * Initialize the component if it is not managed externally     * */    void Start()    {        //如果不是外部管理        if (!isManagedExternally) Initialize();    }    /*     * Initialize all necessary variables and warn user as needed     * */    /// <summary>    /// 必须的初始化    /// </summary>    public void Initialize()    {        // validate component references        if (anim == null)        {            //取子对象的所有动画            anim = gameObject.GetComponentInChildren(typeof(Animation)) as Animation;            if (anim == null) Debug.LogError("No animation component has been specified.", this);            else if (isDebugMode) Debug.LogWarning(string.Format("No animation component has been specified. Using the animation component on {0}.", gameObject.name), this);        }        if (rootNode == null)        {            //等于自身            rootNode = transform;            if (isDebugMode) Debug.LogWarning(string.Format("No root object has been manually specified. Assuming that {0} is the root object to be moved.", gameObject.name), this);        }        if (pelvis == null)        {            //取自身的所有组件            Component[] hierarchy = GetComponentsInChildren(typeof(Transform));            // first try to figure out the pelvis based on name            //给骨盆赋值            foreach (Transform joint in hierarchy)                if (pelvis == null && (joint.name.ToLower() == "hips" || joint.name.ToLower().Contains("pelvis"))) pelvis = joint;            // if no named pelvis was found, then try to find the first skinned mesh renderer with children            if (pelvis == null)            {                foreach (Transform joint in hierarchy)                {                    if (joint.GetComponent(typeof(SkinnedMeshRenderer)) == null) continue;                    Component[] children = joint.GetComponentsInChildren(typeof(Transform));                    if (children.Length > 1) pelvis = joint;                }            }            if (pelvis == null) Debug.LogError("No pelvis transform has been specified.", this);            else if (isDebugMode) Debug.LogWarning(string.Format("No pelvis object as been manually specified. Assuming that {0} is the pelvis object to track.", pelvis.name));        }        // store whether or not the animation component is playing        bool isAnimationPlaying = anim.isPlaying;        // store information about each AnimationState in a hashtable for easy lookup later        animInfoTable = new Hashtable();        // first, figure out what all AnimationStates are currently doing        //默认设置给每一个动画        foreach (AnimationState aState in anim)        {            AddAnimInfoToTable(aState);        }        //动画采样        anim.Sample(); // BUG: need to call Sample() once up front or AnimationStates in Animation component may reorder during iteration        //停止所有动画，以确保所有的动画权重为0        anim.Stop(); // call Stop() to ensure that all weights go to 0        //重新启动，以确保采样时的值是正确的        anim.enabled = true; // reenable the animation component to ensure that values will be correct when sampling        // store properties for each state one at a time        foreach (AnimationState aState in anim)        {            SetupNewAnimInfo(aState);        }        // revert the animation component to whatever it was doing beforehand        //权重，规范化时间 再次赋值为结构体里面的！当时为何不在设置结构体的时候就直接做了呢？        foreach (AnimationState aState in anim)        {            info = (AnimInfo)animInfoTable[aState];            //尼玛。这里不是重赋值么            aState.weight = info.currentWeight;            aState.normalizedTime = info.currentNormalizedTime;        }        if (isAnimationPlaying) anim.Play();        else anim.Stop();    }    /*     * Add information about the provided state to the hashtable     * */    /// <summary>    /// 设置一个动画的详细信息为结构体，并将之 动画名，结构体 的形式存入哈希表    /// </summary>    /// <param name="aState">动画</param>    public void AddAnimInfoToTable(AnimationState aState)    {        // create the new info object        AnimInfo newInfo = new AnimInfo();        // store the current properties        //设置规范化时间        newInfo.currentNormalizedTime = aState.normalizedTime;        //设置权重        newInfo.currentWeight = aState.weight;        // add a new hashtable entry for the AnimInfo        //存入动画哈希表中        animInfoTable.Add(aState, newInfo);    }    /*     * Set up further properties for a newly-created info object after calling AddAnimInfoToTable()     * */    /// <summary>    /// 设置哈希表里动画对应的结构体,重置这个动画    /// </summary>    /// <param name="aState">动画名</param>    public void SetupNewAnimInfo(AnimationState aState)    {        //取这个动画的结构体        AnimInfo newInfo = (AnimInfo)animInfoTable[aState];        // store information about the animation state up front        //当前的状态，应当是false 。        bool isEnabled = aState.enabled;        WrapMode wrapMode = aState.wrapMode;        // activate the animation state 激活动画状态        aState.weight = 1f;        aState.enabled = true;        //循环模式 确保该值在normalizedTime=1f是不一定相同normalizedTime= 0F ，官方没有 Clamp 的解释 操        aState.wrapMode = WrapMode.Clamp; // ensures the value at normalizedTime = 1f is not necessarily the same as normalizedTime = 0f        // scrub to the beginning of the animation state and store initial position and rotation values        //净化开始动画状态的初始位置的和旋转值        aState.normalizedTime = 0f;        anim.Sample();        newInfo.startPosition = GetProjectedPosition(pelvis);        newInfo.previousPosition = GetProjectedPosition(pelvis);        newInfo.startAxis = GetProjectedAxis(pelvis, pelvisRightAxis);        newInfo.previousAxis = GetProjectedAxis(pelvis, pelvisRightAxis);        // scrub to the end of the animation state and store final position and rotation values        //净化结束的动画状态，并存储最后的位置和旋转值        aState.normalizedTime = 1f;        anim.Sample();        newInfo.endPosition = GetProjectedPosition(pelvis);        newInfo.endAxis = GetProjectedAxis(pelvis, pelvisRightAxis);        // store the total rotation over the course of the animation        //从开始到结束的一个旋转的四元数        newInfo.totalRotation = Quaternion.FromToRotation(newInfo.startAxis, newInfo.endAxis);        // reset the clip to its starting point and scrub it down to 0 weight        //重置这个动画到开始的点到0的权重        aState.normalizedTime = 0f;        aState.weight = 0f;        aState.enabled = isEnabled;        aState.wrapMode = wrapMode;        anim.Sample();        //最后赋值        animInfoTable[aState] = newInfo;    }    /*     * All motion is applied in LateUpdate() since it is called after all animation states have been set     * */    //以保万一才在LatUpdate里运行，因为开头设置了。    void LateUpdate()    {        if (!isManagedExternally) ComputeRootMotion();    }    /*     * Compute the root motion variables     * */    /// <summary>    /// 计算根运动变量    /// </summary>    public void ComputeRootMotion()    {        // early out if no animation is playing 没运动        if (!anim.isPlaying) return;        // store whether or not we should be bothering to compute rotation parameters存储是否我们应该费心去计算旋转参数        bool isRotationMode = (computationMode == RootMotionComputationMode.TranslationAndRotation);        #region 设置最高层低层，是否所有的动画都已加入哈希表？没有则添加并设置        // an array to store any AnimationStates that have been added to the animation component since the last frame        //一个数组来存储已被添加到自上一帧的动画组件任何AnimationStates，用于初始化没有添加进的动画        ArrayList newlyAddedAnimationStates = null;        // first store current actual weight and time information for all AnimationStates        foreach (AnimationState aState in anim)        {            // store the highest and lowest layers for use in a later iteration            //给最高层和最低层赋值 . 这里每次都要赋一下，让我感到很费解            highestLayer = Mathf.Max(highestLayer, aState.layer);            lowestLayer = Mathf.Min(lowestLayer, aState.layer);            // if any new animation states have been added, then deal with them in a following iteration            // 这里判断有没有初始化没添加到哈希表的动画            if (!animInfoTable.ContainsKey(aState))            {                AddAnimInfoToTable(aState);                newlyAddedAnimationStates.Add(aState);                continue;            }            info = (AnimInfo)animInfoTable[aState];            //我擦。又一次分配            info.currentNormalizedTime = aState.normalizedTime;            info.currentWeight = aState.weight;            animInfoTable[aState] = info;            // scrub the weight down to 0 for the next iteration            //为下一次做好准备？？            aState.weight = 0f;        }        // if any new AnimationStates have been added, add their info to the table        //有新的动画添加，就设置        if (newlyAddedAnimationStates != null && newlyAddedAnimationStates.Count > 0)        {            // first set all weights to 0, which will include newly added states            foreach (AnimationState aState in anim) aState.weight = 0f;            // store all the properties for the new states            foreach (AnimationState aState in newlyAddedAnimationStates) SetupNewAnimInfo(aState);        }        #endregion        #region 计算层的整合，权重的分配。这里有些不懂的地方        // compute normalized AnimationState weights across layers since Unity does not expose them        //计算归AnimationState的重量跨越层，因为Unity不暴露他们        //总的权重，余下的权重        float remainingWeight = 1f;        //从最高层开始        for (int i = highestLayer; i >= lowestLayer; i--)        {            //所有动画（指当前的层）权重的总和            float weightOnThisLayer = 0f;            //用循环取当前层。layer层中可能有多个动画            foreach (AnimationState aState in anim)            {                if (aState.layer != i) continue;                //取当前层的当前动画信息                info = (AnimInfo)animInfoTable[aState];                // find out how much weight the animation state is actually contributing this frame                //没有启用动画，或者已分配完                if (!aState.enabled || remainingWeight <= 0f)                {                    info.contributingWeight = 0f;                }                else                {                    //实际上播放出来的权重                    info.contributingWeight = remainingWeight * info.currentWeight;                    //print(aState.name + "-- layer: " + aState.layer  + "还余下的权重：" + remainingWeight + "这个动画当前的权重："                    //    + info.currentWeight + "实际播放出来的权重" + info.contributingWeight);                }                //将这个层上所有的动画的权重加起来                weightOnThisLayer += info.contributingWeight;                //print(weightOnThisLayer);                animInfoTable[aState] = info;            }            // if the weight on this layer is > 1, then normalize it            // using Blend() or setting weights manually will not affect other weights on the layer, so they must be manually renormalized            //这个层上所有动画权重相加后的数大于1了            if (weightOnThisLayer > 1f)            {                //设置一个百分数来减少实际播放出来的权重                float oneOverWeightOnThisLayer = 1f / weightOnThisLayer;                //循环这个层的动画，并做出一些播出的权重的减少                foreach (AnimationState aState in anim)                {                    if (aState.layer != i) continue;                    info = (AnimInfo)animInfoTable[aState];                    info.contributingWeight = info.contributingWeight * oneOverWeightOnThisLayer;                    animInfoTable[aState] = info;                }                //重置为1                weightOnThisLayer = 1f;            }            //余下的权重 等于 减去分配后的权重            remainingWeight -= weightOnThisLayer;        }        #endregion        // reset the delta values for this frame        //重设此帧的增量值        dPosition = Vector3.zero;        dRotation = Quaternion.identity;        // compute each AnimationState‘s individual contribution to the current frame‘s delta values        //计算每个动画的贡献，以当前帧的增量值        foreach (AnimationState aState in anim)        {            info = (AnimInfo)animInfoTable[aState];            // early out if this state was contributing nothing this frame            //如果没有权重，下一位            if (info.contributingWeight == 0f) continue;            // early out if aState uses additive blending            // NOTE: Not entirely sure if this is ideal or not, but it generally should be            //如果混合模式为附加，则下一位            if (aState.blendMode == AnimationBlendMode.Additive) continue;            // scrub the weight up to 1 for sampling values            //设置权重为1            aState.weight = 1f;            // sample the values for the projected root configuration back one frame            // NOTE: cannot simply store these values from one frame to the next since user may manually change the time value at any point            //采样数值为投影机的根目录配置一帧            //注意：不能简单地存储这些值从一帧到下一个，因为用户可以在任何时候手动更改时间值            aState.time = aState.time - Time.deltaTime * aState.speed;            info.previousNormalizedTime = aState.normalizedTime;            anim.Sample();            info.previousAxis = GetProjectedAxis(pelvis, pelvisRightAxis);            info.previousPosition = GetProjectedPosition(pelvis);            // sample the values for the projected root configuration at the current frame            aState.normalizedTime = info.currentNormalizedTime;            anim.Sample();            info.currentPosition = GetProjectedPosition(pelvis);            info.currentAxis = GetProjectedAxis(pelvis, pelvisRightAxis);            // ensure both normalizedTime values are positive            info.previousNormalizedTime = 1f + info.previousNormalizedTime - (int)info.previousNormalizedTime;            info.currentNormalizedTime = 1f + info.currentNormalizedTime - (int)info.currentNormalizedTime;            // determine the contribution to the root‘s delta this frame based on whether the animation looped since the previous frame            if (info.previousNormalizedTime - (int)info.previousNormalizedTime > info.currentNormalizedTime - (int)info.currentNormalizedTime)            {                // compute displacement with respect to identity                p = info.contributingWeight * ((info.endPosition - info.previousPosition) + (info.currentPosition - info.startPosition));                if (isRotationMode)                {                    // rotate displacement into current orientation                    p = Quaternion.FromToRotation(info.currentAxis, info.totalRotation * Vector3.right) * p;                    // compute angular displacement and append to result                    dRotation *= Quaternion.Slerp(Quaternion.identity,                        Quaternion.FromToRotation(info.previousAxis, info.endAxis) * Quaternion.FromToRotation(info.startAxis, info.currentAxis),                        info.contributingWeight);                }                // append displacement to result                dPosition += p;            }            else            {                // compute displacement with respect to identity                p = info.contributingWeight * (info.currentPosition - info.previousPosition);                if (isRotationMode)                {                    // rotate displacement into current orientation                    p = Quaternion.FromToRotation(info.currentAxis, Vector3.right) * p;                    // compute angular displacement and append to result                    dRotation *= Quaternion.Slerp(Quaternion.identity, Quaternion.FromToRotation(info.previousAxis, info.currentAxis), info.contributingWeight);                }                // append displacement to result                dPosition += p;            }            // scrub the weight back down to 0 so as to not affect sampling of other states            aState.weight = 0f;        }        // reset weights to where they were before computation        foreach (AnimationState aState in anim)        {            info = (AnimInfo)animInfoTable[aState];            aState.weight = info.currentWeight;        }        // return the character to its current pose        anim.Sample();        // delta values for the first frame should simply move from the starting configuration into the current frame of animation        if (isFirstFrame)        {            // simply translate and rotate to the current projected position and orientation            dPosition = GetProjectedPosition(pelvis);            dRotation = Quaternion.FromToRotation(Vector3.right, GetProjectedAxis(pelvis, pelvisRightAxis));            // rotate displacement into current orientation            if (isRotationMode) dPosition = Quaternion.FromToRotation(GetProjectedAxis(pelvis, pelvisRightAxis), Vector3.right) * dPosition;            isFirstFrame = false;        }        // store the local position of the pelvis before returning it to hover over the root        pLocalPosition = pelvis.localPosition;        // zero out the local x-component of the position delta if root translation method is z-only        if (computationMode == RootMotionComputationMode.ZTranslation) dPosition = Vector3.forward * Vector3.Dot(dPosition, Vector3.forward);        // otherwise zero out the local x-position of the pelvis        else pLocalPosition.x = 0f;        // return the pelvis to a point hovering over the root        pLocalPosition.z = 0f;        pelvis.localPosition = pLocalPosition;        // if computing rotation, then zero out local y-rotation of the pelvis        if (isRotationMode) pelvis.localRotation = Quaternion.FromToRotation(GetProjectedAxis(pelvis, pelvisRightAxis), Vector3.right) * pelvis.localRotation;        // draw debug lines if requested        if (isDebugMode) DrawDebug();        // return if root movement is not requested (e.g. a character controller will use delta values)        if (!applyMotion) return;        // apply rotation if requested        if (isRotationMode) rootNode.localRotation *= dRotation;        // apply translation        rootNode.Translate(dPosition, Space.Self);    }    /*     * Obtain the position of t projected onto rootNode‘s zx plane     * */    /// <summary>    /// 获取传入位置投射在根结点的ZX轴坐标的一个点 ，y = 0    /// </summary>    /// <param name="t">传入的位置</param>    /// <returns></returns>    private Vector3 GetProjectedPosition(Transform t)    {        Vector3 p = rootNode.InverseTransformPoint(t.position);        p.y = 0f;        return p;    }    /*     * Obtain the projection of axis on t onto rootNode‘s zx plane     * */    /// <summary>    /// 获取根节点的zx平面上的投影轴    /// </summary>    /// <param name="t">传入的位置</param>    /// <param name="axis">方向</param>    /// <returns></returns>    private Vector3 GetProjectedAxis(Transform t, Vector3 axis)    {        Vector3 p = rootNode.InverseTransformDirection(t.TransformDirection(axis));        p.y = 0f;        return p;    }    /*     * Draw axis tripods to show how root motion is being determined and applied     * */    private void DrawDebug()    {        // draw pelvis right axis        Debug.DrawRay(pelvis.position, pelvis.TransformDirection(pelvisRightAxis) * debugGizmoSize, Color.red);        // draw root node axes        Debug.DrawRay(rootNode.position, rootNode.rotation * Vector3.forward * debugGizmoSize, Color.blue);        Debug.DrawRay(rootNode.position, rootNode.rotation * Vector3.right * debugGizmoSize, Color.red);        Debug.DrawRay(rootNode.position, rootNode.rotation * Vector3.up * debugGizmoSize, Color.green);    }}