public InputDir(FPVector3 dir)
{
this.Dir = dir;
}
public static FPQuaternion Euler(FPVector3 v)
{
return(Euler(v.x, v.y, v.z));
}
public static AnimatorData Extract(AnimationClip clip)
{
AnimatorData animationData = new AnimatorData();
animationData.clipName = clip.name;
EditorCurveBinding[] curveBindings = AnimationUtility.GetCurveBindings(clip);
AnimationClipSettings settings = AnimationUtility.GetAnimationClipSettings(clip);
float usedTime = settings.stopTime - settings.startTime;
animationData.frameRate = Mathf.RoundToInt(clip.frameRate);
animationData.length = FP.FromFloat_UNSAFE(usedTime);
animationData.frameCount = Mathf.RoundToInt(clip.frameRate * usedTime);
animationData.frames = new AnimatorFrame[animationData.frameCount];
animationData.looped = clip.isLooping && settings.loopTime;
animationData.mirror = settings.mirror;
//Read the curves of animation
int frameCount = animationData.frameCount;
int curveBindingsLength = curveBindings.Length;
if (curveBindingsLength == 0)
{
return(animationData);
}
AnimationCurve curveTx = null, curveTy = null, curveTz = null, curveRx = null, curveRy = null, curveRz = null, curveRw = null;
for (int c = 0; c < curveBindingsLength; c++)
{
string propertyName = curveBindings[c].propertyName;
if (propertyName == "m_LocalPosition.x" || propertyName == "RootT.x")
{
curveTx = AnimationUtility.GetEditorCurve(clip, curveBindings[c]);
}
if (propertyName == "m_LocalPosition.y" || propertyName == "RootT.y")
{
curveTy = AnimationUtility.GetEditorCurve(clip, curveBindings[c]);
}
if (propertyName == "m_LocalPosition.z" || propertyName == "RootT.z")
{
curveTz = AnimationUtility.GetEditorCurve(clip, curveBindings[c]);
}
if (propertyName == "m_LocalRotation.x" || propertyName == "RootQ.x")
{
curveRx = AnimationUtility.GetEditorCurve(clip, curveBindings[c]);
}
if (propertyName == "m_LocalRotation.y" || propertyName == "RootQ.y")
{
curveRy = AnimationUtility.GetEditorCurve(clip, curveBindings[c]);
}
if (propertyName == "m_LocalRotation.z" || propertyName == "RootQ.z")
{
curveRz = AnimationUtility.GetEditorCurve(clip, curveBindings[c]);
}
if (propertyName == "m_LocalRotation.w" || propertyName == "RootQ.w")
{
curveRw = AnimationUtility.GetEditorCurve(clip, curveBindings[c]);
}
}
// if (curveBindingsLength >= 7)
// {
// //Position Curves
// curveTx = AnimationUtility.GetEditorCurve(clip, curveBindings[0]);
// curveTy = AnimationUtility.GetEditorCurve(clip, curveBindings[1]);
// curveTz = AnimationUtility.GetEditorCurve(clip, curveBindings[2]);
//
// //Rotation Curves
// curveRx = AnimationUtility.GetEditorCurve(clip, curveBindings[3]);
// curveRy = AnimationUtility.GetEditorCurve(clip, curveBindings[4]);
// curveRz = AnimationUtility.GetEditorCurve(clip, curveBindings[5]);
// curveRw = AnimationUtility.GetEditorCurve(clip, curveBindings[6]);
// }
bool hasPosition = curveTx != null && curveTy != null && curveTz != null;
bool hasRotation = curveRx != null && curveRy != null && curveRz != null && curveRw != null;
if (!hasPosition)
{
Debug.LogWarning("No movement data was found in the animation: " + clip.name);
}
if (!hasRotation)
{
Debug.LogWarning("No rotation data was found in the animation: " + clip.name);
}
//The initial pose might not be the first frame and might not face foward
//calculate the initial direction and create an offset Quaternion to apply to transforms;
Quaternion startRotUq = Quaternion.identity;
FPQuaternion startRot = FPQuaternion.Identity;
if (hasRotation)
{
float srotxu = curveRx.Evaluate(settings.startTime);
float srotyu = curveRy.Evaluate(settings.startTime);
float srotzu = curveRz.Evaluate(settings.startTime);
float srotwu = curveRw.Evaluate(settings.startTime);
FP srotx = FP.FromFloat_UNSAFE(srotxu);
FP sroty = FP.FromFloat_UNSAFE(srotyu);
FP srotz = FP.FromFloat_UNSAFE(srotzu);
FP srotw = FP.FromFloat_UNSAFE(srotwu);
startRotUq = new Quaternion(srotxu, srotyu, srotzu, srotwu);
startRot = new FPQuaternion(srotx, sroty, srotz, srotw);
}
Quaternion offsetRotUq = Quaternion.Inverse(startRotUq);
FPQuaternion offsetRot = FPQuaternion.Inverse(startRot);
for (int i = 0; i < frameCount; i++)
{
var frameData = new AnimatorFrame();
frameData.id = i;
float percent = i / (frameCount - 1f);
float frameTime = usedTime * percent;
frameData.time = FP.FromFloat_UNSAFE(frameTime);
float clipTIme = settings.startTime + percent * (settings.stopTime - settings.startTime);
if (hasPosition)
{
FP posx = FP.FromFloat_UNSAFE(i > 0 ? curveTx.Evaluate(clipTIme) - curveTx.Evaluate(settings.startTime) : 0);
FP posy = FP.FromFloat_UNSAFE(i > 0 ? curveTy.Evaluate(clipTIme) - curveTy.Evaluate(settings.startTime) : 0);
FP posz = FP.FromFloat_UNSAFE(i > 0 ? curveTz.Evaluate(clipTIme) - curveTz.Evaluate(settings.startTime) : 0);
FPVector3 newPosition = offsetRot * new FPVector3(posx, posy, posz);
if (settings.mirror)
{
newPosition.X = -newPosition.X;
}
frameData.position = newPosition;
}
if (hasRotation)
{
float curveRxEval = curveRx.Evaluate(clipTIme);
float curveRyEval = curveRy.Evaluate(clipTIme);
float curveRzEval = curveRz.Evaluate(clipTIme);
float curveRwEval = curveRw.Evaluate(clipTIme);
Quaternion curveRotation = offsetRotUq * new Quaternion(curveRxEval, curveRyEval, curveRzEval, curveRwEval);
if (settings.mirror)//mirror the Y axis rotation
{
Quaternion mirrorRotation = new Quaternion(curveRotation.x, -curveRotation.y, -curveRotation.z, curveRotation.w);
if (Quaternion.Dot(curveRotation, mirrorRotation) < 0)
{
mirrorRotation = new Quaternion(-mirrorRotation.x, -mirrorRotation.y, -mirrorRotation.z, -mirrorRotation.w);
}
curveRotation = mirrorRotation;
}
FP rotx = FP.FromFloat_UNSAFE(curveRotation.x);
FP roty = FP.FromFloat_UNSAFE(curveRotation.y);
FP rotz = FP.FromFloat_UNSAFE(curveRotation.z);
FP rotw = FP.FromFloat_UNSAFE(curveRotation.w);
FPQuaternion newRotation = new FPQuaternion(rotx, roty, rotz, rotw);
frameData.rotation = newRotation * offsetRot;
float rotY = curveRotation.eulerAngles.y * Mathf.Deg2Rad;
while (rotY < -Mathf.PI)
{
rotY += Mathf.PI * 2;
}
while (rotY > Mathf.PI)
{
rotY += -Mathf.PI * 2;
}
frameData.rotationY = FP.FromFloat_UNSAFE(rotY);
}
animationData.frames[i] = frameData;
}
return(animationData);
}
private void AnimationClipGui(AnimatorClip clip)
{
EditorGUILayout.BeginVertical("box", GUILayout.Width(EditorGUIUtility.currentViewWidth - 20));
EditorGUILayout.LabelField("Animator Clip");
EditorGUILayout.LabelField(string.Format("Name: {0}", clip.clipName));
EditorGUILayout.LabelField(string.Format("Length: {0}", clip.data.length.AsFloat));
EditorGUILayout.LabelField(string.Format("Frame Rate: {0}", clip.data.frameRate));
EditorGUILayout.LabelField(string.Format("Frame Count: {0}", clip.data.frameCount));
EditorGUILayout.LabelField(string.Format("Looped: {0}", clip.data.looped));
EditorGUILayout.LabelField(string.Format("Mirrored: {0}", clip.data.mirror));
int frameCount = clip.data.frameCount;
Vector3[] positions = new Vector3[frameCount];
Quaternion[] rotationsQ = new Quaternion[frameCount];
Vector3[] rotations = new Vector3[frameCount];
float[] times = new float[frameCount];
for (int f = 0; f < frameCount; f++)
{
AnimatorFrame frame = clip.data.frames[f];
float frameTime = frame.time.AsFloat;
FPVector3 position = frame.position;
FPQuaternion rotation = frame.rotation;
Vector3 pV3 = new Vector3(position.X.AsFloat, position.Y.AsFloat, position.Z.AsFloat);
Quaternion rQ = new Quaternion(rotation.X.AsFloat, rotation.Y.AsFloat, rotation.Z.AsFloat, rotation.W.AsFloat);
Vector3 rV3 = rQ.eulerAngles;
positions[f] = pV3;
rotationsQ[f] = rQ;
rotations[f] = rV3;
times[f] = frameTime;
}
EditorGUILayout.BeginVertical("box");
EditorGUILayout.LabelField(string.Format("Delta Movement: {0}", (positions[frameCount - 1] - positions[0]).ToString("F3")));
Quaternion deltaQ = Quaternion.FromToRotation(rotationsQ[0] * Vector3.forward, rotationsQ[frameCount - 1] * Vector3.forward);
Vector3 deltaQV = deltaQ.eulerAngles;
if (deltaQV.x > 180)
{
deltaQV.x += -360;
}
if (deltaQV.y > 180)
{
deltaQV.y += -360;
}
if (deltaQV.z > 180)
{
deltaQV.z += -360;
}
EditorGUILayout.LabelField(string.Format("Delta Rotation: {0}", deltaQV.ToString("F3")));
EditorGUILayout.EndVertical();
EditorGUILayout.BeginVertical("box");
if (showMovementData = EditorGUILayout.Foldout(showMovementData, "Movement Data"))
{
EditorGUILayout.BeginHorizontal();
EditorGUILayout.BeginVertical();
EditorGUILayout.LabelField("Times", GUILayout.Width(75));
for (int f = 0; f < frameCount; f++)
{
EditorGUILayout.LabelField(times[f].ToString("F3"), GUILayout.Width(75));
}
EditorGUILayout.EndVertical();
EditorGUILayout.BeginVertical();
EditorGUILayout.LabelField("Positions", GUILayout.Width(160));
for (int f = 0; f < frameCount; f++)
{
EditorGUILayout.LabelField(positions[f].ToString("F2"), GUILayout.Width(160));
}
EditorGUILayout.EndVertical();
EditorGUILayout.BeginVertical();
EditorGUILayout.LabelField("Rotations", GUILayout.Width(160));
for (int f = 0; f < frameCount; f++)
{
EditorGUILayout.LabelField(rotations[f].ToString("F2"), GUILayout.Width(160));
}
EditorGUILayout.EndVertical();
EditorGUILayout.EndHorizontal();
}
EditorGUILayout.EndVertical();
EditorGUILayout.EndVertical();
}
public static Vector2 ToUnityVector2(this FPVector3 v)
{
return(new Vector2(v.X.AsFloat, v.Y.AsFloat));
}
