public static List <KeyValuePair <string, ImportedAnimationKeyframe[]> > CopyAnimation(WorkspaceAnimation wsAnimation, int resampleCount, bool linear)
{
List <KeyValuePair <string, ImportedAnimationKeyframe[]> > newTrackList = new List <KeyValuePair <string, ImportedAnimationKeyframe[]> >(wsAnimation.TrackList.Count);
List <Tuple <ImportedAnimationTrack, ImportedAnimationKeyframe[]> > interpolateTracks = new List <Tuple <ImportedAnimationTrack, ImportedAnimationKeyframe[]> >();
foreach (var wsTrack in wsAnimation.TrackList)
{
if (!wsAnimation.isTrackEnabled(wsTrack))
{
continue;
}
ImportedAnimationKeyframe[] newKeyframes;
if (resampleCount < 0 || wsTrack.Keyframes.Length == resampleCount)
{
newKeyframes = new ImportedAnimationKeyframe[wsTrack.Keyframes.Length];
for (int i = 0; i < wsTrack.Keyframes.Length; i++)
{
ImportedAnimationKeyframe keyframe = wsTrack.Keyframes[i];
if (keyframe == null)
{
continue;
}
newKeyframes[i] = new ImportedAnimationKeyframe();
newKeyframes[i].Rotation = keyframe.Rotation;
newKeyframes[i].Translation = keyframe.Translation;
newKeyframes[i].Scaling = keyframe.Scaling;
}
}
else
{
newKeyframes = new ImportedAnimationKeyframe[resampleCount];
if (wsTrack.Keyframes.Length < 1)
{
ImportedAnimationKeyframe keyframe = new ImportedAnimationKeyframe();
keyframe.Rotation = Quaternion.Identity;
keyframe.Scaling = new Vector3(1, 1, 1);
keyframe.Translation = new Vector3(0, 0, 0);
for (int i = 0; i < newKeyframes.Length; i++)
{
newKeyframes[i] = keyframe;
}
}
else
{
interpolateTracks.Add(new Tuple <ImportedAnimationTrack, ImportedAnimationKeyframe[]>(wsTrack, newKeyframes));
}
}
newTrackList.Add(new KeyValuePair <string, ImportedAnimationKeyframe[]>(wsTrack.Name, newKeyframes));
}
if (resampleCount >= 0)
{
Fbx.InterpolateKeyframes(interpolateTracks, resampleCount, linear);
}
return(newTrackList);
}
public static Quaternion EulerToQuaternion(Vector3 v)
{
return(Fbx.EulerToQuaternion(v));
}
public static Vector3 QuaternionToEuler(Quaternion q)
{
return(Fbx.QuaternionToEuler(q));
}
public static void ReplaceAnimation(WorkspaceAnimation wsAnimation, xaParser parser, int resampleCount, ReplaceAnimationMethod replaceMethod, int insertPos)
{
if (parser.AnimationSection == null)
{
Report.ReportLog("The .xa file doesn't have an animation section. Skipping this animation");
return;
}
if (!(wsAnimation.importedAnimation is ImportedKeyframedAnimation))
{
Report.ReportLog("The animation has incompatible keyframes.");
return;
}
Report.ReportLog("Replacing animation ...");
List <ImportedAnimationKeyframedTrack> trackList = ((ImportedKeyframedAnimation)wsAnimation.importedAnimation).TrackList;
List <KeyValuePair <string, xaAnimationKeyframe[]> > newTrackList = new List <KeyValuePair <string, xaAnimationKeyframe[]> >(trackList.Count);
List <Tuple <ImportedAnimationTrack, xaAnimationKeyframe[]> > interpolateTracks = new List <Tuple <ImportedAnimationTrack, xaAnimationKeyframe[]> >();
foreach (var wsTrack in trackList)
{
if (!wsAnimation.isTrackEnabled(wsTrack))
{
continue;
}
ImportedAnimationKeyframe[] keyframes = ((ImportedAnimationKeyframedTrack)wsTrack).Keyframes;
xaAnimationKeyframe[] newKeyframes = null;
int wsTrackKeyframesLength = 0;
for (int i = 0; i < keyframes.Length; i++)
{
if (keyframes[i] != null)
{
wsTrackKeyframesLength++;
}
}
if (resampleCount < 0 || wsTrackKeyframesLength == resampleCount)
{
newKeyframes = new xaAnimationKeyframe[wsTrackKeyframesLength];
int keyframeIdx = 0;
for (int i = 0; i < keyframes.Length; i++)
{
ImportedAnimationKeyframe keyframe = keyframes[i];
if (keyframe == null)
{
continue;
}
newKeyframes[keyframeIdx] = new xaAnimationKeyframe();
newKeyframes[keyframeIdx].Index = i;
newKeyframes[keyframeIdx].Rotation = keyframe.Rotation;
xa.CreateUnknowns(newKeyframes[keyframeIdx]);
newKeyframes[keyframeIdx].Translation = keyframe.Translation;
newKeyframes[keyframeIdx].Scaling = keyframe.Scaling;
keyframeIdx++;
}
}
else
{
newKeyframes = new xaAnimationKeyframe[resampleCount];
if (wsTrackKeyframesLength < 1)
{
xaAnimationKeyframe keyframe = new xaAnimationKeyframe();
keyframe.Rotation = Quaternion.Identity;
keyframe.Scaling = new Vector3(1, 1, 1);
keyframe.Translation = new Vector3(0, 0, 0);
xa.CreateUnknowns(keyframe);
for (int i = 0; i < newKeyframes.Length; i++)
{
keyframe.Index = i;
newKeyframes[i] = keyframe;
}
}
else
{
interpolateTracks.Add(new Tuple <ImportedAnimationTrack, xaAnimationKeyframe[]>(wsTrack, newKeyframes));
}
}
newTrackList.Add(new KeyValuePair <string, xaAnimationKeyframe[]>(wsTrack.Name, newKeyframes));
}
if (interpolateTracks.Count > 0)
{
Fbx.InterpolateKeyframes(interpolateTracks, resampleCount);
}
List <xaAnimationTrack> animationNodeList = parser.AnimationSection.TrackList;
Dictionary <string, xaAnimationTrack> animationNodeDic = null;
if (replaceMethod != ReplaceAnimationMethod.Replace)
{
animationNodeDic = new Dictionary <string, xaAnimationTrack>();
foreach (xaAnimationTrack animationNode in animationNodeList)
{
animationNodeDic.Add(animationNode.Name, animationNode);
}
}
if (replaceMethod == ReplaceAnimationMethod.Replace)
{
animationNodeList.Clear();
foreach (var newTrack in newTrackList)
{
xaAnimationTrack animationNode = new xaAnimationTrack();
animationNodeList.Add(animationNode);
animationNode.KeyframeList = new List <xaAnimationKeyframe>(newTrack.Value);
animationNode.Name = newTrack.Key;
xa.CreateUnknowns(animationNode);
}
}
else if (replaceMethod == ReplaceAnimationMethod.ReplacePresent)
{
foreach (var newTrack in newTrackList)
{
xaAnimationTrack animationNode = xa.animationGetOriginalKeyframes(animationNodeDic, newTrack.Key, animationNodeList);
animationNode.KeyframeList = new List <xaAnimationKeyframe>(newTrack.Value);
}
}
else if (replaceMethod == ReplaceAnimationMethod.Merge)
{
foreach (var newTrack in newTrackList)
{
xaAnimationTrack animationNode;
xaAnimationKeyframe[] origKeyframes = xa.animationGetOriginalKeyframes(animationNodeDic, newTrack.Key, animationNodeList, out animationNode);
xaAnimationKeyframe[] destKeyframes;
int newEnd = insertPos + newTrack.Value.Length;
if (origKeyframes.Length < insertPos)
{
destKeyframes = new xaAnimationKeyframe[newEnd];
xa.animationCopyKeyframeTransformArray(origKeyframes, 0, destKeyframes, 0, origKeyframes.Length);
xa.animationNormalizeTrack(origKeyframes, destKeyframes, insertPos);
}
else
{
if (origKeyframes.Length < newEnd)
{
destKeyframes = new xaAnimationKeyframe[newEnd];
}
else
{
destKeyframes = new xaAnimationKeyframe[origKeyframes.Length];
xa.animationCopyKeyframeTransformArray(origKeyframes, newEnd, destKeyframes, newEnd, origKeyframes.Length - newEnd);
}
xa.animationCopyKeyframeTransformArray(origKeyframes, 0, destKeyframes, 0, insertPos);
}
xa.animationCopyKeyframeTransformArray(newTrack.Value, 0, destKeyframes, insertPos, newTrack.Value.Length);
animationNode.KeyframeList = new List <xaAnimationKeyframe>(destKeyframes);
}
}
else if (replaceMethod == ReplaceAnimationMethod.Insert)
{
foreach (var newTrack in newTrackList)
{
xaAnimationTrack animationNode;
xaAnimationKeyframe[] origKeyframes = xa.animationGetOriginalKeyframes(animationNodeDic, newTrack.Key, animationNodeList, out animationNode);;
xaAnimationKeyframe[] destKeyframes;
int newEnd = insertPos + newTrack.Value.Length;
if (origKeyframes.Length < insertPos)
{
destKeyframes = new xaAnimationKeyframe[newEnd];
xa.animationCopyKeyframeTransformArray(origKeyframes, 0, destKeyframes, 0, origKeyframes.Length);
xa.animationNormalizeTrack(origKeyframes, destKeyframes, insertPos);
}
else
{
destKeyframes = new xaAnimationKeyframe[origKeyframes.Length + newTrack.Value.Length];
xa.animationCopyKeyframeTransformArray(origKeyframes, 0, destKeyframes, 0, insertPos);
xa.animationCopyKeyframeTransformArray(origKeyframes, insertPos, destKeyframes, newEnd, origKeyframes.Length - insertPos);
}
xa.animationCopyKeyframeTransformArray(newTrack.Value, 0, destKeyframes, insertPos, newTrack.Value.Length);
animationNode.KeyframeList = new List <xaAnimationKeyframe>(destKeyframes);
}
}
else if (replaceMethod == ReplaceAnimationMethod.Append)
{
int maxKeyframes = 0;
foreach (xaAnimationTrack animationNode in animationNodeList)
{
int numKeyframes = animationNode.KeyframeList[animationNode.KeyframeList.Count - 1].Index;
if (numKeyframes > maxKeyframes)
{
maxKeyframes = numKeyframes;
}
}
foreach (var newTrack in newTrackList)
{
xaAnimationTrack animationNode;
xaAnimationKeyframe[] origKeyframes = xa.animationGetOriginalKeyframes(animationNodeDic, newTrack.Key, animationNodeList, out animationNode);
xaAnimationKeyframe[] destKeyframes = new xaAnimationKeyframe[maxKeyframes + insertPos + newTrack.Value[newTrack.Value.Length - 1].Index + 1];
xa.animationCopyKeyframeTransformArray(origKeyframes, destKeyframes, 0);
if (origKeyframes.Length > 0 && origKeyframes.Length == origKeyframes[origKeyframes.Length - 1].Index + 1)
{
xa.animationNormalizeTrack(origKeyframes, destKeyframes, origKeyframes.Length + insertPos);
}
xa.animationCopyKeyframeTransformArray(newTrack.Value, destKeyframes, maxKeyframes + insertPos);
animationNode.KeyframeList = new List <xaAnimationKeyframe>(origKeyframes.Length + insertPos + newTrack.Value.Length);
for (int i = 0; i < destKeyframes.Length; i++)
{
if (destKeyframes[i] == null)
{
continue;
}
animationNode.KeyframeList.Add(destKeyframes[i]);
}
}
}
else
{
Report.ReportLog("Error: Unexpected animation replace method " + replaceMethod + ". Skipping this animation");
return;
}
}
public static string GetFbxVersion(bool full = true)
{
return(Fbx.GetFbxVersion(full));
}
public static List <KeyValuePair <string, ImportedAnimationSampledTrack> > CopySampledAnimation(WorkspaceAnimation wsAnimation, int resampleCount, bool linear, bool EulerFilter, float filterPrecision, bool forceInterpolation = false)
{
List <ImportedAnimationSampledTrack> trackList = ((ImportedSampledAnimation)wsAnimation.importedAnimation).TrackList;
List <KeyValuePair <string, ImportedAnimationSampledTrack> > newTrackList = new List <KeyValuePair <string, ImportedAnimationSampledTrack> >(trackList.Count);
List <Tuple <ImportedAnimationTrack, ImportedAnimationSampledTrack> > interpolateTracks = new List <Tuple <ImportedAnimationTrack, ImportedAnimationSampledTrack> >();
foreach (var wsTrack in trackList)
{
if (!wsAnimation.isTrackEnabled(wsTrack))
{
continue;
}
ImportedAnimationSampledTrack track = new ImportedAnimationSampledTrack();
bool interpolateTrack = forceInterpolation;
Vector3?[] newScalings = null;
Quaternion?[] newRotations = null;
Vector3?[] newTranslations = null;
if (!interpolateTrack)
{
Vector3?[] scalings = wsTrack.Scalings;
if (scalings != null)
{
if (resampleCount < 0 || scalings.Length == resampleCount)
{
newScalings = new Vector3?[scalings.Length];
for (int i = 0; i < scalings.Length; i++)
{
Vector3?scale = scalings[i];
if (scale == null)
{
continue;
}
newScalings[i] = scale.Value;
}
}
else
{
if (scalings.Length < 1)
{
newScalings = new Vector3?[resampleCount];
for (int i = 0; i < newScalings.Length; i++)
{
newScalings[i] = new Vector3(1, 1, 1);
}
}
else
{
interpolateTrack = true;
}
}
}
Quaternion?[] rotations = wsTrack.Rotations;
if (rotations != null)
{
if (resampleCount < 0 || rotations.Length == resampleCount)
{
newRotations = new Quaternion?[rotations.Length];
for (int i = 0; i < rotations.Length; i++)
{
Quaternion?rotate = rotations[i];
if (rotate == null)
{
continue;
}
newRotations[i] = rotate.Value;
}
}
else
{
if (rotations.Length < 1)
{
newRotations = new Quaternion?[resampleCount];
for (int i = 0; i < newRotations.Length; i++)
{
newRotations[i] = Quaternion.Identity;
}
}
else
{
interpolateTrack = true;
}
}
}
Vector3?[] translations = wsTrack.Translations;
if (translations != null)
{
if (resampleCount < 0 || translations.Length == resampleCount)
{
newTranslations = new Vector3?[translations.Length];
for (int i = 0; i < translations.Length; i++)
{
Vector3?translate = translations[i];
if (translate == null)
{
continue;
}
newTranslations[i] = translate.Value;
}
}
else
{
if (translations.Length < 1)
{
newTranslations = new Vector3?[resampleCount];
for (int i = 0; i < newTranslations.Length; i++)
{
newTranslations[i] = new Vector3(0, 0, 0);
}
}
else
{
interpolateTrack = true;
}
}
}
}
if (interpolateTrack)
{
interpolateTracks.Add(new Tuple <ImportedAnimationTrack, ImportedAnimationSampledTrack>(wsTrack, track));
}
track.Scalings = newScalings;
track.Rotations = newRotations;
track.Translations = newTranslations;
newTrackList.Add(new KeyValuePair <string, ImportedAnimationSampledTrack>(wsTrack.Name, track));
}
if (interpolateTracks.Count > 0)
{
Fbx.InterpolateSampledTracks(interpolateTracks, resampleCount, linear, EulerFilter, filterPrecision);
}
return(newTrackList);
}
