Scripting Root Motion Curves

Hey. Been banging my head against the keyboard for a week on this issue. I really hope someone here can help me figure out the missing piece to get perfect scripted root motion.

The issue:

I need to be able to script root motion at editor time for playback of the motions at runtime without relying on root motion being applied in the animator. I'm running into some position and rotation issues.

The setup:

I have a mixamo animation called Sword And Shield Slash using a y-bot model and humanoid avatar rigged from the model. I also have an editor script that bakes root motion from the curve bindings of the animation. The script also allows for running both the baked animation through the animator and an un-baked animation from the AnimationClip.SampleAnimation function.

Illustration:

AnimationClip.SampleAnimation:

Manually moving transform from baked curves and Animator.applyRootMotion == false:

Here are the scripts I'm using in case anyone wants to try this for themselves:

RootMotionBaker.cs

 using System.Collections;
 using System.Collections.Generic;
 using UnityEngine;
 
 public class RootMotionBaker : MonoBehaviour
 {
     public AnimationClip Clip;
 
     public Animator Animator;
 
     public AnimationCurve PositionXCurve;
     public AnimationCurve PositionYCurve;
     public AnimationCurve PositionZCurve;
 
     public AnimationCurve RotationXCurve;
     public AnimationCurve RotationYCurve;
     public AnimationCurve RotationZCurve;
     public AnimationCurve RotationWCurve;
 
     public AnimationCurve EulerAnglesXCurve;
     public AnimationCurve EulerAnglesYCurve;
     public AnimationCurve EulerAnglesZCurve;
 
 
     // Start is called before the first frame update
     void Start()
     {
     }
 
     // Update is called once per frame
     void Update()
     {
      
     }
 }

RootMotionBakerEditor.cs

 using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using UnityEditor;
 using UnityEditor.Animations;
 using UnityEngine;
 
 [CustomEditor(typeof(RootMotionBaker))]
 public class RootMotionBakerEditor : Editor
 {
 
     private RootMotionBaker _rootMotionBaker;
     private bool _runningBaked;
     private bool _runningStandard;
     private bool _paused;
     private bool _baking;
     private float _totalTimeRunning;
     private AnimatorController _originalAnimatorController;
     private AnimatorController _replacementAnimatorController;
     private float _timeFactor = .5f;
 
     private void Awake()
     {
         _rootMotionBaker = target as RootMotionBaker;
     }
 
     public override void OnInspectorGUI()
     {
         base.OnInspectorGUI();
 
         //Animator
         var animatorProp = serializedObject.FindProperty("Animator");
         if (animatorProp.objectReferenceValue == null)
         {
             animatorProp.objectReferenceValue = _rootMotionBaker.GetComponent<Animator>();
         }
         else
         {
         }
 
         if (serializedObject.FindProperty("Clip").objectReferenceValue != null)
         {
             if (GUILayout.Button("Bake Root Motion Curves"))
             {
                 var curves = RootMotionFunctions.GetCurves(_rootMotionBaker.Clip);
                 WriteCurves(curves);
             }
 
             GUI.enabled = (_runningBaked || _runningStandard);
 
             if (GUILayout.Button("Pause"))
             {
                 _paused = !_paused;
             }
 
 
             GUI.enabled = true;
 
 
             GUI.enabled = !(_runningBaked || _runningStandard);
 
             if (GUILayout.Button("Run Baked Animation"))
             {
                 _runningBaked = true;
                 _rootMotionBaker.Animator.applyRootMotion = false;
 
                 //Set up animator controller
                 _originalAnimatorController = (AnimatorController)_rootMotionBaker.Animator.runtimeAnimatorController;
 
                 _replacementAnimatorController = new AnimatorController();
                 _replacementAnimatorController.AddLayer("Default");
                 _replacementAnimatorController.layers[0].stateMachine.AddState("Default");
                 _replacementAnimatorController.AddMotion(_rootMotionBaker.Clip, 0);
                 _rootMotionBaker.Animator.runtimeAnimatorController = _replacementAnimatorController;
             }
 
             if (GUILayout.Button("Run Standard Animation"))
             {
                 _runningStandard = true;
             }
 
             GUI.enabled = true;
         }
 
         serializedObject.ApplyModifiedProperties();
     }
 
     private void OnSceneGUI()
     {
         if (!_paused)
         {
             if (_rootMotionBaker.Animator != null && _runningBaked) _rootMotionBaker.Animator.Update(Time.deltaTime);
 
             if (_runningBaked)
             {
                 _rootMotionBaker.Animator.PlayInFixedTime(_rootMotionBaker.Clip.name, 0, _totalTimeRunning);
 
                 Vector3 newPosition = new Vector3(_rootMotionBaker.PositionXCurve.Evaluate(_totalTimeRunning), _rootMotionBaker.PositionYCurve.Evaluate(_totalTimeRunning), _rootMotionBaker.PositionZCurve.Evaluate(_totalTimeRunning));
                 Quaternion newRotation = new Quaternion(_rootMotionBaker.RotationXCurve.Evaluate(_totalTimeRunning), _rootMotionBaker.RotationYCurve.Evaluate(_totalTimeRunning), _rootMotionBaker.RotationZCurve.Evaluate(_totalTimeRunning), _rootMotionBaker.RotationWCurve.Evaluate(_totalTimeRunning));
 
 
                 _rootMotionBaker.Animator.transform.position = newPosition;
                 _rootMotionBaker.Animator.transform.rotation = newRotation;
 
                 _totalTimeRunning += Time.deltaTime * _timeFactor;
                 if (_totalTimeRunning >= _rootMotionBaker.Clip.length)
                 {
                     _runningBaked = false;
                     _totalTimeRunning = 0f;
 
                     _rootMotionBaker.Animator.transform.position -= newPosition;
                     _rootMotionBaker.Animator.transform.rotation *= Quaternion.Inverse(newRotation);
 
                     _rootMotionBaker.Animator.runtimeAnimatorController = _originalAnimatorController;
                 }
 
 
             }
 
             if (_runningStandard)
             {
                 _rootMotionBaker.Clip.SampleAnimation(_rootMotionBaker.Animator.gameObject, _totalTimeRunning);
 
                 _totalTimeRunning += Time.deltaTime * _timeFactor;
                 if (_totalTimeRunning >= _rootMotionBaker.Clip.length)
                 {
                     _runningStandard = false;
                     _totalTimeRunning = 0f;
 
                 }
             }
         }
     }
 
     private void WriteCurves(RootMotionFunctions.RootMotionCurves curves)
     {
         serializedObject.FindProperty("PositionXCurve").animationCurveValue = curves.PositionXCurve;
         serializedObject.FindProperty("PositionYCurve").animationCurveValue = curves.PositionYCurve;
         serializedObject.FindProperty("PositionZCurve").animationCurveValue = curves.PositionZCurve;
         serializedObject.FindProperty("RotationXCurve").animationCurveValue = curves.RotationXCurve;
         serializedObject.FindProperty("RotationYCurve").animationCurveValue = curves.RotationYCurve;
         serializedObject.FindProperty("RotationZCurve").animationCurveValue = curves.RotationZCurve;
         serializedObject.FindProperty("RotationWCurve").animationCurveValue = curves.RotationWCurve;
         serializedObject.FindProperty("EulerAnglesXCurve").animationCurveValue = curves.EulerAnglesXCurve;
         serializedObject.FindProperty("EulerAnglesYCurve").animationCurveValue = curves.EulerAnglesYCurve;
         serializedObject.FindProperty("EulerAnglesZCurve").animationCurveValue = curves.EulerAnglesZCurve;
 
     }
 }

RootMotionFunctions.cs (static helper class):

 using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using UnityEditor;
 using UnityEditor.Animations;
 using UnityEngine;
 
 public static class RootMotionFunctions
 {
     public struct RootMotionCurves
     {
         public AnimationCurve PositionXCurve;
         public AnimationCurve PositionYCurve;
         public AnimationCurve PositionZCurve;
 
         public AnimationCurve RotationXCurve;
         public AnimationCurve RotationYCurve;
         public AnimationCurve RotationZCurve;
         public AnimationCurve RotationWCurve;
 
         public AnimationCurve EulerAnglesXCurve;
         public AnimationCurve EulerAnglesYCurve;
         public AnimationCurve EulerAnglesZCurve;
     }
 
 
     public static RootMotionCurves GetCurves(AnimationClip clip)
     {
         Action<AnimationCurve, float, float> normalizeKeyframes = (curve, minValue, maxValue) =>
         {
             if (curve.keys.Length > 1)
             {
                 Keyframe[] keyframes = curve.keys.ToArray();
                 float startFrameValue = keyframes.First().value;
                 for (int i = 0; i < keyframes.Length; i++)
                 {
                     keyframes[i].value = Mathf.Clamp(keyframes[i].value - startFrameValue, minValue, maxValue);
                 }
                 curve.keys = keyframes;
             }
         };
 
         var positionXCurve = new AnimationCurve { keys = GetCurveFromAnimationClip(clip, "RootT.x").keys.ToArray() };
         normalizeKeyframes(positionXCurve, float.NegativeInfinity, float.PositiveInfinity);
 
         var positionYCurve = new AnimationCurve { keys = GetCurveFromAnimationClip(clip, "RootT.y").keys.ToArray() };
         normalizeKeyframes(positionYCurve, float.NegativeInfinity, float.PositiveInfinity);
 
         var positionZCurve = new AnimationCurve { keys = GetCurveFromAnimationClip(clip, "RootT.z").keys.ToArray() };
         normalizeKeyframes(positionZCurve, float.NegativeInfinity, float.PositiveInfinity);
 
         var quaternionXCurve = new AnimationCurve { keys = GetCurveFromAnimationClip(clip, "RootQ.x").keys.ToArray() };
         var quaternionYCurve = new AnimationCurve { keys = GetCurveFromAnimationClip(clip, "RootQ.y").keys.ToArray() };
         var quaternionZCurve = new AnimationCurve { keys = GetCurveFromAnimationClip(clip, "RootQ.z").keys.ToArray() };
         var quaternionWCurve = new AnimationCurve { keys = GetCurveFromAnimationClip(clip, "RootQ.w").keys.ToArray() };
 
         var eulerAnglesXCurve = new AnimationCurve();
         var eulerAnglesYCurve = new AnimationCurve();
         var eulerAnglesZCurve = new AnimationCurve();
 
         //Resample and normalize quaternions
         var frames = (int)(clip.length * clip.frameRate);
         var quaternionXKeyframes = new Keyframe[frames];
         var quaternionYKeyframes = new Keyframe[frames];
         var quaternionZKeyframes = new Keyframe[frames];
         var quaternionWKeyframes = new Keyframe[frames];
         var eulerAnglesXKeyframes = new Keyframe[frames];
         var eulerAnglesYKeyframes = new Keyframe[frames];
         var eulerAnglesZKeyframes = new Keyframe[frames];
         Quaternion inverseStartRotation = Quaternion.Inverse(new Quaternion(quaternionXCurve.keys[0].value, quaternionYCurve.keys[0].value, quaternionZCurve.keys[0].value, quaternionWCurve.keys[0].value));
         for (int i = 0; i < frames; i++)
         {
             float time = i * 1 / clip.frameRate;
 
             var xValue = quaternionXCurve.Evaluate(time);
             var yValue = quaternionYCurve.Evaluate(time);
             var zValue = quaternionZCurve.Evaluate(time);
             var wValue = quaternionWCurve.Evaluate(time);
 
             Quaternion sample = new Quaternion(xValue, yValue, zValue, wValue);
             var resample = sample * inverseStartRotation;
 
             quaternionXKeyframes[i].time = time;
             quaternionXKeyframes[i].value = resample.x;
             quaternionYKeyframes[i].time = time;
             quaternionYKeyframes[i].value = resample.y;
             quaternionZKeyframes[i].time = time;
             quaternionZKeyframes[i].value = resample.z;
             quaternionWKeyframes[i].time = time;
             quaternionWKeyframes[i].value = resample.w;
 
 
             Vector3 eulerAnglesSample = new Quaternion(xValue, yValue, zValue, wValue).eulerAngles;
             eulerAnglesXKeyframes[i].time = time;
             eulerAnglesXKeyframes[i].value = eulerAnglesSample.x;
             eulerAnglesYKeyframes[i].time = time;
             eulerAnglesYKeyframes[i].value = eulerAnglesSample.y;
             eulerAnglesZKeyframes[i].time = time;
             eulerAnglesZKeyframes[i].value = eulerAnglesSample.z;
 
         }
         quaternionXCurve.keys = quaternionXKeyframes;
         quaternionYCurve.keys = quaternionYKeyframes;
         quaternionZCurve.keys = quaternionZKeyframes;
         quaternionWCurve.keys = quaternionWKeyframes;
 
         eulerAnglesXCurve.keys = eulerAnglesXKeyframes;
         eulerAnglesYCurve.keys = eulerAnglesYKeyframes;
         eulerAnglesZCurve.keys = eulerAnglesZKeyframes;
 
         return new RootMotionCurves
         {
             PositionXCurve = positionXCurve,
             PositionYCurve = positionYCurve,
             PositionZCurve = positionZCurve,
             RotationXCurve = quaternionXCurve,
             RotationYCurve = quaternionYCurve,
             RotationZCurve = quaternionZCurve,
             RotationWCurve = quaternionWCurve,
             EulerAnglesXCurve = eulerAnglesXCurve,
             EulerAnglesYCurve = eulerAnglesYCurve,
             EulerAnglesZCurve = eulerAnglesZCurve,
         };
     }
 
     private static AnimationCurve GetCurveFromAnimationClip(AnimationClip clip, string curvePropertyName)
     {
         var curveBindings = UnityEditor.AnimationUtility.GetCurveBindings(clip);
 
         //var curve = new AnimationCurve { keys = UnityEditor.AnimationUtility.GetEditorCurve(clip, curveBindings.FirstOrDefault(x => x.propertyName == curvePropertyName)).keys };
         var curve = AnimationUtility.GetEditorCurve(clip, curveBindings.FirstOrDefault(x => x.propertyName == curvePropertyName));
 
         return curve;
     }
 }