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