Question How to know where(Vector3) the transform will be at the end of the animation?

So I want to be able to know before playing an animation that applies rootmotion, where will my character be at the end of it?

 

Bump

 

I don't think it's possible.
You could try backing up the current animator state, use Animator.StartPlayback to manually play the animator, then animator.play to play the animation at normalized time 1(the end), record the position and then restore everything to normal.
It's not super simple and not sure it will work.
Usually people do the opposite, decide where they want to go and interpolate the rootmotion to get to desired destination.

 

You could also try adding OnAnimatorMove() and caching Animator.deltaPosition .
then doing whatever calculation you need here before applying it.

 

Animator.deltaPosition only tell you the difference between the current frame and the next frame, but he want to know where it will be at the end of the animation, meaning by using that method he'll only know after the animation has actually finished.

 

I don't think Havie was saying otherwise there, but the point would be the calculation you could derive from doing that. If you perform an animation, you log the start and end positions...taking the difference between them would give you a transform you could add prior.

I'm imagining there are a few ways to mess that up, such as if the animation has an exit time, performs differently if interrupted, etc... Depends on the application the OP had in mind, and type of animating that's going on.

 

First you extract the root motion curves from your clips. Then you can simply evaluate those Curves at runtime with clip length to find the translation at end of Clip ( or any time through the clip's length )

Luckily i have some code lying around from when i was working on something similar.

We will have to use Editor Script to extract Root Motion Animation Curves for Clips as they are not accessible at runtime and then store into ScriptableObject for easy access. Following is a Scriptable object with both the Extraction and Storage functionality.

1. Create RootMotionConfiguration.cs script in your project and add the following code.

Code (CSharp):

1. using System.Collections;
2. using System.Collections.Generic;
3. using UnityEngine;
4. using UnityEditor;
5. using System;
6.  
7. [CreateAssetMenu(fileName = "root_motion_library", menuName = "Game/Animation/Root Motion")]
8. public class RootMotionConfiguration : ScriptableObject
9. {
10.     [Header("Input")]
11.     public RootMotionCurveNames[] names;
12.     public AnimationClip[] clips;
13.  
14.     [Header("Output")]
15.     public List<RootMotionCurves> curves = new List<RootMotionCurves>();
16.  
17.     Dictionary<AnimationClip, RootMotionCurves> curveDirectory = new Dictionary<AnimationClip, RootMotionCurves>();
18.  
19.     [Serializable]
20.     public struct RotationCurve
21.     {
22.         public AnimationCurve x;
23.         public AnimationCurve y;
24.         public AnimationCurve z;
25.         public AnimationCurve w;
26.     }
27.  
28.     [Serializable]
29.     public struct TranslationCurve
30.     {
31.         public AnimationCurve x;
32.         public AnimationCurve y;
33.         public AnimationCurve z;
34.     }
35.  
36.     [Serializable]
37.     public struct RootMotionCurves
38.     {
39.         public AnimationClip clip;
40.         public RotationCurve rotationCurve;
41.         public TranslationCurve translationCurve;
42.     }
43.  
44.     [Serializable]
45.     public struct RootMotionCurveNames
46.     {
47.         // public string root;
48.         public PositionCurveName positionCurveName;
49.         public RotationCurveName rotationCurveName;
50.     }
51.  
52.     [Serializable]
53.     public struct PositionCurveName
54.     {
55.         public string x;
56.         public string y;
57.         public string z;
58.     }
59.  
60.     [Serializable]
61.     public struct RotationCurveName
62.     {
63.         public string x;
64.         public string y;
65.         public string z;
66.         public string w;
67.     }
68.  
69.     public RootMotionCurves GetRootMotionCurveForClip(AnimationClip clip)
70.     {
71.         foreach (var curve in curves)
72.             if (curve.clip == clip)
73.                 return curve;
74.  
75.         return default(RootMotionCurves);
76.     }
77.  
78.     [ContextMenu("Process")]
79.     public void Process()
80.     {
81.         curves.Clear();
82.         curveDirectory.Clear();
83.         // propertyNames.Clear();
84.  
85.         foreach (var clip in clips)
86.         {
87.             var curveBindings = UnityEditor.AnimationUtility.GetCurveBindings(clip);
88.  
89.             foreach (var name in names)
90.             {
91.                 foreach (var curveBinding in curveBindings)
92.                 {
93.  
94.                     if (name.positionCurveName.x == curveBinding.propertyName)
95.                     {
96.                         var curve = default(RootMotionCurves);
97.  
98.                         if (!curveDirectory.TryGetValue(clip, out curve))
99.                             curveDirectory.Add(clip, curve);
100.  
101.                         var positionCurves = curve.translationCurve;
102.                         positionCurves.x = AnimationUtility.GetEditorCurve(clip, curveBinding);
103.                         curve.translationCurve = positionCurves;
104.                         curveDirectory[clip] = curve;
105.                     }
106.  
107.                     if (name.positionCurveName.y == curveBinding.propertyName)
108.                     {
109.                         var curve = default(RootMotionCurves);
110.  
111.                         if (!curveDirectory.TryGetValue(clip, out curve))
112.                             curveDirectory.Add(clip, curve);
113.  
114.                         var positionCurves = curve.translationCurve;
115.                         positionCurves.y = AnimationUtility.GetEditorCurve(clip, curveBinding);
116.                         curve.translationCurve = positionCurves;
117.                         curveDirectory[clip] = curve;
118.                     }
119.  
120.                     if (name.positionCurveName.z == curveBinding.propertyName)
121.                     {
122.                         var curve = default(RootMotionCurves);
123.  
124.                         if (!curveDirectory.TryGetValue(clip, out curve))
125.                             curveDirectory.Add(clip, curve);
126.  
127.                         var positionCurves = curve.translationCurve;
128.                         positionCurves.z = AnimationUtility.GetEditorCurve(clip, curveBinding);
129.                         curve.translationCurve = positionCurves;
130.                         curveDirectory[clip] = curve;
131.                     }
132.  
133.                     if (name.rotationCurveName.x == curveBinding.propertyName)
134.                     {
135.                         var curve = default(RootMotionCurves);
136.  
137.                         if (!curveDirectory.TryGetValue(clip, out curve))
138.                             curveDirectory.Add(clip, curve);
139.  
140.                         var rotationCurve = curve.rotationCurve;
141.                         rotationCurve.x = AnimationUtility.GetEditorCurve(clip, curveBinding);
142.                         curve.rotationCurve = rotationCurve;
143.                         curveDirectory[clip] = curve;
144.                     }
145.  
146.                     if (name.rotationCurveName.y == curveBinding.propertyName)
147.                     {
148.                         var curve = default(RootMotionCurves);
149.  
150.                         if (!curveDirectory.TryGetValue(clip, out curve))
151.                             curveDirectory.Add(clip, curve);
152.  
153.                         var rotationCurve = curve.rotationCurve;
154.                         rotationCurve.y = AnimationUtility.GetEditorCurve(clip, curveBinding);
155.                         curve.rotationCurve = rotationCurve;
156.                         curveDirectory[clip] = curve;
157.                     }
158.  
159.                     if (name.rotationCurveName.z == curveBinding.propertyName)
160.                     {
161.                         var curve = default(RootMotionCurves);
162.  
163.                         if (!curveDirectory.TryGetValue(clip, out curve))
164.                             curveDirectory.Add(clip, curve);
165.  
166.                         var rotationCurve = curve.rotationCurve;
167.                         rotationCurve.z = AnimationUtility.GetEditorCurve(clip, curveBinding);
168.                         curve.rotationCurve = rotationCurve;
169.                         curveDirectory[clip] = curve;
170.                     }
171.  
172.                     if (name.rotationCurveName.w == curveBinding.propertyName)
173.                     {
174.                         var curve = default(RootMotionCurves);
175.  
176.                         if (!curveDirectory.TryGetValue(clip, out curve))
177.                             curveDirectory.Add(clip, curve);
178.  
179.                         var rotationCurve = curve.rotationCurve;
180.                         rotationCurve.w = AnimationUtility.GetEditorCurve(clip, curveBinding);
181.                         curve.rotationCurve = rotationCurve;
182.                         curveDirectory[clip] = curve;
183.                     }
184.                 }
185.             }
186.         }
187.  
188.         foreach (var clip in curveDirectory.Keys)
189.         {
190.             var curve = curveDirectory[clip];
191.             curve.clip = clip;
192.             curves.Add(curve);
193.         }
194.     }
195. }
196.  
197.  

2. Create RootMotionConfiguration Asset with Context Menu in Project View from Game/Animation/Root Motion




3. Provide follow data in the inspector

• Curves : Name of the curves to be extracted. The Root Motion Curves are stored with MotionT ( translation ) & MotionQ ( rotation ) in my clips. Its probably the standard curve names for root motion but you can define different name in Inspector if your Clips have it named differently. You can use Animation Window to inspect your clip curves.
  
• Clips : The Animation Clips you want to extract and store root motion curves for.

4. Right Click empty inspector area on top of asset to bring up the context Menu. Hit Process to generate the root motion curves list for clips.





5. The generated curves will appear in the Inspector in Output - Curves section , stored in the asset itself.





6. Now we can reference this root motion curve asset into our target Script and evaluate it at runtime as following

Code (CSharp):

1. public void PlotMotion(Transform targetTransform, AnimationClip clip, RootMotionConfiguration rootMotionConfiguration, float normalizedTime) //normalizedTime ; 0f = start , 1f = end
2.     {
3.         RootMotionConfiguration.RootMotionCurves curve = rootMotionConfiguration.GetRootMotionCurveForClip(clip);
4.         float time = clip.length * normalizedTime;
5.  
6.         Vector3 translation = new Vector3()
7.         {
8.             x = curve.translationCurve.x.Evaluate(time),
9.             y = curve.translationCurve.y.Evaluate(time),
10.             z = curve.translationCurve.z.Evaluate(time),
11.         };
12.  
13.         Quaternion rotation = new Quaternion()
14.         {
15.             x = curve.rotationCurve.x.Evaluate(time),
16.             y = curve.rotationCurve.y.Evaluate(time),
17.             z = curve.rotationCurve.z.Evaluate(time),
18.             w = curve.rotationCurve.w.Evaluate(time)
19.         };
20.  
21.         //This is your Position and Rotation at target time
22.         Vector3 targetPosition = targetTransform.position + translation;
23.         Quaternion targetRotation = targetTransform.rotation * rotation;
24.     }

Hope this helps
Cheers.

 

Can't you just do animationClip.averageSpeed * animationClip.length?

 

That's such a pro move! I didn't know exctracting an entire curve is possible. I got a similar question not sure if you can help me as well. I'm trying to query the transform vector3 that's being fed to my specific bone within the hierachy (let's say arm_L) from the animator controller on that very specific frame during runtime. How do I do that?

 

If it's a humanoid you could add a trigger/event on the frame you want (via the animation import options) to extract the bone position, then when handling the callback just use Animator.GetBoneTransform. Otherwise, since the bones are exposed in the hierarchy you could just add the bone to a public variable in your component that handles the callback and query it from there.

 

thank you sir I'll look into that. The second solution you mentioned was what I tried to do, unfortunately I can not get the transform after animator controller and before constraint. I think their order priorities are too close for me to look between them.