public static SkeletalAnim FromJson(string json)
{
SkeletalAnim anim = new SkeletalAnim();
FromJson(anim, json);
return(anim);
}
public static SkeletalAnim FromStruct(SkeletalAnimHelper skelAnim)
{
SkeletalAnim anim = new SkeletalAnim();
FromStruct(anim, skelAnim);
return(anim);
}
private static SkeletalAnim Chr02Fska(CHR0Node chr0)
{
SkeletalAnim fska = new SkeletalAnim();
fska.FrameCount = chr0.FrameCount;
fska.Name = chr0.Name;
fska.Path = chr0.OriginalPath;
fska.UserDatas = new List <Syroot.NintenTools.NSW.Bfres.UserData>();
fska.UserDataDict = new ResDict();
//Set flags
if (chr0.Loop)
{
fska.FlagsAnimSettings |= SkeletalAnimFlags.Looping;
}
fska.FlagsRotate = SkeletalAnimFlagsRotate.EulerXYZ;
fska.FlagsScale = SkeletalAnimFlagsScale.Maya;
//Set bone anims and then calculate data after
foreach (var entry in chr0.Children)
{
fska.BoneAnims.Add(Chr0Entry2BoneAnim((CHR0EntryNode)entry));
}
fska.BakedSize = CalculateBakeSize(fska);
fska.BindIndices = SetIndices(fska);
return(fska);
}
public BfresSkeletalAnim(ResFile resFile, SkeletalAnim anim, string name)
{
ParentFile = resFile;
SkeletalAnim = anim;
ModelName = name;
CanPlay = false; //Default all animations to not play unless toggled in list
Reload(anim);
}
private void LoadAnim(SkeletalAnim ska)
{
Text = ska.Name;
FrameCount = ska.FrameCount;
SkeletalAnim = ska;
Initialize();
}
public static void FromJson(SkeletalAnim anim, string json)
{
JsonConvert.DefaultSettings = () =>
{
var settings = new JsonSerializerSettings();
return(settings);
};
var animJson = JsonConvert.DeserializeObject <SkeletalAnimStruct>(json);
anim.Name = animJson.Name;
anim.Baked = animJson.Baked;
anim.Loop = animJson.Loop;
anim.FrameCount = animJson.FrameCount;
anim.Baked = animJson.Baked;
anim.FlagsRotate = animJson.FlagsRotate;
anim.FlagsScale = animJson.FlagsScale;
anim.BoneAnims = new List <BoneAnim>();
anim.BindIndices = new ushort[animJson.BoneAnims.Count];
foreach (var boneAnimJson in animJson.BoneAnims)
{
BoneAnim boneAnim = new BoneAnim();
anim.BoneAnims.Add(boneAnim);
//Always these indices
boneAnim.Name = boneAnimJson.Name;
boneAnim.BeginRotate = 3;
boneAnim.BeginTranslate = 6;
boneAnim.BeginBaseTranslate = 7;
boneAnim.BaseData = boneAnimJson.BaseData;
boneAnim.FlagsTransform |= BoneAnimFlagsTransform.Identity;
if (boneAnimJson.UseBaseTranslation)
{
boneAnim.FlagsBase |= BoneAnimFlagsBase.Translate;
}
if (boneAnimJson.UseBaseRotation)
{
boneAnim.FlagsBase |= BoneAnimFlagsBase.Rotate;
}
if (boneAnimJson.UseBaseScale)
{
boneAnim.FlagsBase |= BoneAnimFlagsBase.Scale;
}
foreach (var curveJson in boneAnimJson.Curves)
{
var target = (AnimTarget)Enum.Parse(typeof(AnimTarget), curveJson.Target);
var curve = CurveConvert.GenerateCurve(curveJson, (uint)target,
curveJson.Target.Contains("Rotate") && animJson.UseDegrees);
boneAnim.Curves.Add(curve);
boneAnim.FlagsCurve = SetCurveTarget(target);
}
boneAnim.CalculateTransformFlags();
boneAnim.ApplySegmentScaleCompensate = boneAnimJson.SegmentScaleCompensate;
}
}
public static void FromJson(SkeletalAnim anim, string json)
{
JsonConvert.DefaultSettings = () =>
{
var settings = new JsonSerializerSettings();
return(settings);
};
FromStruct(anim, JsonConvert.DeserializeObject <SkeletalAnimHelper>(json));
}
private static ushort[] SetIndices(SkeletalAnim fska)
{
List <ushort> indces = new List <ushort>();
foreach (var boneAnim in fska.BoneAnims)
{
indces.Add(65535);
}
return(indces.ToArray());
}
private void UpdateAnimation(SkeletalAnim ska)
{
ska.Name = Text;
if (SkeletalAnimU != null)
{
SkeletalAnimU = BfresPlatformConverter.FSKAConvertSwitchToWiiU(ska);
LoadAnim(SkeletalAnimU);
}
else
{
SkeletalAnim = ska;
LoadAnim(SkeletalAnim);
}
}
public void FromAnim(string FileName)
{
if (SkeletalAnimU != null)
{
var SkeletalAnimNX = BrawlboxHelper.FSKAConverter.Anim2Fska(FileName);
SkeletalAnimU = BfresPlatformConverter.FSKAConvertSwitchToWiiU(SkeletalAnimNX);
SkeletalAnimU.Name = Text;
LoadAnim(SkeletalAnimU);
}
else
{
SkeletalAnim = BrawlboxHelper.FSKAConverter.Anim2Fska(FileName);
SkeletalAnim.Name = Text;
LoadAnim(SkeletalAnim);
}
}
public void FromChr0(string FileName, bool IsWiiU)
{
if (IsWiiU)
{
var SkeletalAnimNX = BrawlboxHelper.FSKAConverter.Chr02Fska(FileName);
SkeletalAnimU = BfresPlatformConverter.FSKAConvertSwitchToWiiU(SkeletalAnimNX);
SkeletalAnimU.Name = Text;
LoadAnim(SkeletalAnimU);
}
else
{
SkeletalAnim = BrawlboxHelper.FSKAConverter.Chr02Fska(FileName);
SkeletalAnim.Name = Text;
LoadAnim(SkeletalAnim);
}
}
public static string ToJson(SkeletalAnim anim)
{
SkeletalAnimStruct animConv = new SkeletalAnimStruct();
animConv.Name = anim.Name;
animConv.Path = anim.Path;
animConv.Loop = anim.Loop;
animConv.Baked = anim.Baked;
animConv.FrameCount = anim.FrameCount;
animConv.FlagsScale = anim.FlagsScale;
animConv.FlagsRotate = anim.FlagsRotate;
animConv.BoneAnims = new List <BoneAnimStruct>();
foreach (var boneAnim in anim.BoneAnims)
{
BoneAnimStruct boneAnimConv = new BoneAnimStruct();
boneAnimConv.Curves = new List <CurveAnimStruct>();
boneAnimConv.Name = boneAnim.Name;
boneAnimConv.BaseData = boneAnim.BaseData;
boneAnimConv.SegmentScaleCompensate = boneAnim.ApplySegmentScaleCompensate;
boneAnimConv.UseBaseTranslation = boneAnim.FlagsBase.HasFlag(BoneAnimFlagsBase.Translate);
boneAnimConv.UseBaseRotation = boneAnim.FlagsBase.HasFlag(BoneAnimFlagsBase.Rotate);
boneAnimConv.UseBaseScale = boneAnim.FlagsBase.HasFlag(BoneAnimFlagsBase.Scale);
animConv.BoneAnims.Add(boneAnimConv);
foreach (var curve in boneAnim.Curves)
{
string target = ((AnimTarget)curve.AnimDataOffset).ToString();
var convCurve = CurveConvert.FromCurve(curve, target,
target.Contains("Rotate") && animConv.UseDegrees);
boneAnimConv.Curves.Add(convCurve);
}
}
foreach (var param in anim.UserData.Values)
{
animConv.UserData.Add($"{param.Type}|{param.Name}", param.GetData());
}
JsonConvert.DefaultSettings = () =>
{
var settings = new JsonSerializerSettings();
return(settings);
};
return(JsonConvert.SerializeObject(animConv, Formatting.Indented));
}
public static void Fska2Chr0(SkeletalAnim fska, string FileName)
{
CHR0Node chr0 = new CHR0Node();
chr0.FrameCount = fska.FrameCount;
chr0.Name = fska.Name;
chr0.OriginalPath = fska.Path;
chr0.UserEntries = new UserDataCollection();
chr0.Loop = fska.Loop;
foreach (var entry in fska.BoneAnims)
{
BoneAnim2Chr0Entry(entry, chr0);
}
chr0.Export(FileName);
}
private void FromAssimp(string FileName, bool IsWiiU)
{
var anims = AssimpData.ImportAnimations(FileName);
for (int i = 0; i < anims.Length; i++)
{
if (IsWiiU)
{
SkeletalAnimU = BfresPlatformConverter.FSKAConvertSwitchToWiiU(FromGeneric(anims[i]));
LoadAnim(SkeletalAnimU);
}
else
{
SkeletalAnim = FromGeneric(anims[i]);
LoadAnim(SkeletalAnim);
}
break;
}
}
public SkeletalAnim FromGeneric(Animation anim)
{
SkeletalAnim ska = new SkeletalAnim();
ska.FrameCount = anim.FrameCount;
ska.Name = anim.Text;
ska.Path = "";
ska.FlagsScale = SkeletalAnimFlagsScale.Maya;
ska.FlagsRotate = SkeletalAnimFlagsRotate.EulerXYZ;
ska.Loop = anim.CanLoop;
ska.Baked = false;
for (int b = 0; b < anim.Bones.Count; b++)
{
ska.BoneAnims.Add(GenericBoneAnimToBfresBoneAnim(anim.Bones[b], b));
}
ska.BakedSize = CalculateBakeSize(ska);
ska.BindIndices = GenerateIndices(ska.BoneAnims.Count);
return(ska);
}
public static SkeletalAnim SetSkeletalAniamtion(BfresSkeletonAnim anim)
{
SkeletalAnim animation = new SkeletalAnim();
animation.Name = anim.Text;
animation.FrameCount = anim.FrameCount;
animation.FlagsAnimSettings = SkeletalAnimFlags.Looping;
animation.FlagsRotate = SkeletalAnimFlagsRotate.EulerXYZ;
animation.FlagsScale = SkeletalAnimFlagsScale.Maya;
animation.BindIndices = new ushort[anim.Bones.Count];
animation.BindSkeleton = new Skeleton();
animation.BakedSize = 0;
animation.BoneAnims = new List <BoneAnim>();
animation.UserDataDict = new ResDict();
animation.UserDatas = new List <UserData>();
foreach (var bone in anim.Bones)
{
animation.BoneAnims.Add(createBoneAnim(bone, anim));
}
return(animation);
}
public void FromSeanim(string FileName)
{
SEAnim anim = SEAnim.Read(FileName);
if (GetResFileU() != null)
{
SkeletalAnimU = new ResU.SkeletalAnim();
SkeletalAnimU.FrameCount = anim.FrameCount;
SkeletalAnimU.FlagsScale = ResU.SkeletalAnimFlagsScale.Maya;
SkeletalAnimU.FlagsRotate = ResU.SkeletalAnimFlagsRotate.EulerXYZ;
SkeletalAnimU.Loop = anim.Looping;
SkeletalAnimU.Name = System.IO.Path.GetFileNameWithoutExtension(FileName);
SkeletalAnimU.Path = "";
}
else
{
SkeletalAnim = new SkeletalAnim();
SkeletalAnim.FrameCount = anim.FrameCount;
SkeletalAnim.FlagsScale = SkeletalAnimFlagsScale.Maya;
SkeletalAnim.FlagsRotate = SkeletalAnimFlagsRotate.EulerXYZ;
SkeletalAnim.Loop = anim.Looping;
SkeletalAnim.Name = System.IO.Path.GetFileNameWithoutExtension(FileName);
SkeletalAnim.Path = "";
}
for (int i = 0; i < anim.Bones.Count; i++)
{
if (GetResFileU() != null)
{
var BoneAnimU = new ResU.BoneAnim();
BoneAnimU.Name = anim.Bones[i];
SkeletalAnimU.BoneAnims.Add(BoneAnimU);
SkeletalAnimU.BindIndices[i] = ushort.MaxValue;
bool IsRoot = false;
if (!IsRoot)
{
BoneAnimU.ApplyIdentity = false;
BoneAnimU.ApplyRotateTranslateZero = false;
BoneAnimU.ApplyRotateZero = false;
BoneAnimU.ApplyScaleOne = true;
BoneAnimU.ApplyScaleVolumeOne = true;
BoneAnimU.ApplyScaleUniform = true;
BoneAnimU.ApplySegmentScaleCompensate = true;
BoneAnimU.ApplyTranslateZero = false;
}
else
{
BoneAnimU.ApplyIdentity = true;
BoneAnimU.ApplyRotateTranslateZero = true;
BoneAnimU.ApplyRotateZero = true;
BoneAnimU.ApplyScaleOne = true;
BoneAnimU.ApplyScaleVolumeOne = true;
BoneAnimU.ApplyScaleUniform = true;
BoneAnimU.ApplySegmentScaleCompensate = false;
BoneAnimU.ApplyTranslateZero = true;
}
}
else
{
var BoneAnim = new BoneAnim();
BoneAnim.Name = anim.Bones[i];
SkeletalAnim.BoneAnims.Add(BoneAnim);
SkeletalAnim.BindIndices[i] = ushort.MaxValue;
//Set base data and curves
var baseData = new BoneAnimData();
if (anim.AnimationPositionKeys.ContainsKey(anim.Bones[i]) &&
anim.AnimationPositionKeys[anim.Bones[i]].Count > 0)
{
BoneAnim.FlagsBase |= BoneAnimFlagsBase.Translate;
var keys = anim.AnimationPositionKeys[anim.Bones[i]];
var data = (SELib.Utilities.Vector3)keys[0].Data;
baseData.Translate = new Syroot.Maths.Vector3F((float)data.X, (float)data.Y, (float)data.Z);
if (keys.Count > 1)
{
AnimCurve curve = new AnimCurve();
BoneAnim.Curves.Add(curve);
CreateCurveData(curve, keys);
}
}
if (anim.AnimationRotationKeys.ContainsKey(anim.Bones[i]) &&
anim.AnimationRotationKeys[anim.Bones[i]].Count > 0)
{
BoneAnim.FlagsBase |= BoneAnimFlagsBase.Rotate;
var keys = anim.AnimationPositionKeys[anim.Bones[i]];
var data = (SELib.Utilities.Quaternion)keys[0].Data;
baseData.Rotate = new Syroot.Maths.Vector4F((float)data.X, (float)data.Y, (float)data.Z, (float)data.W);
if (keys.Count > 1)
{
AnimCurve curve = new AnimCurve();
BoneAnim.Curves.Add(curve);
CreateCurveData(curve, keys);
}
}
if (anim.AnimationScaleKeys.ContainsKey(anim.Bones[i]) &&
anim.AnimationScaleKeys[anim.Bones[i]].Count > 0)
{
BoneAnim.FlagsBase |= BoneAnimFlagsBase.Scale;
var keys = anim.AnimationPositionKeys[anim.Bones[i]];
var data = (SELib.Utilities.Vector3)keys[0].Data;
baseData.Scale = new Syroot.Maths.Vector3F((float)data.X, (float)data.Y, (float)data.Z);
if (keys.Count > 1)
{
AnimCurve curve = new AnimCurve();
BoneAnim.Curves.Add(curve);
CreateCurveData(curve, keys);
}
}
//Set transforms
bool IsRoot = false;
if (!IsRoot)
{
BoneAnim.ApplyIdentity = false;
BoneAnim.ApplyRotateTranslateZero = false;
BoneAnim.ApplyRotateZero = false;
BoneAnim.ApplyScaleOne = true;
BoneAnim.ApplyScaleVolumeOne = true;
BoneAnim.ApplyScaleUniform = true;
BoneAnim.ApplySegmentScaleCompensate = true;
BoneAnim.ApplyTranslateZero = false;
}
else
{
BoneAnim.ApplyIdentity = true;
BoneAnim.ApplyRotateTranslateZero = true;
BoneAnim.ApplyRotateZero = true;
BoneAnim.ApplyScaleOne = true;
BoneAnim.ApplyScaleVolumeOne = true;
BoneAnim.ApplyScaleUniform = true;
BoneAnim.ApplySegmentScaleCompensate = false;
BoneAnim.ApplyTranslateZero = true;
}
}
}
for (int frame = 0; frame < anim.FrameCount; frame++)
{
}
}
public void Replace(string FileName, ResFile resFileNX, ResU.ResFile resFileU)
{
string ext = Utils.GetExtension(FileName);
if (ext == ".bfska")
{
bool IsSwitch = BfresUtilies.IsSubSectionSwitch(FileName);
if (resFileU != null)
{
//If it's a switch animation try to conver it to wii u
if (IsSwitch)
{
var ska = new SkeletalAnim();
ska.Import(FileName);
SkeletalAnimU = BfresPlatformConverter.FSKAConvertSwitchToWiiU(ska);
SkeletalAnimU.Name = Text;
LoadAnim(SkeletalAnimU);
}
else
{
SkeletalAnimU.Import(FileName, resFileU);
SkeletalAnimU.Name = Text;
LoadAnim(SkeletalAnimU);
}
}
else
{
if (IsSwitch)
{
SkeletalAnim.Import(FileName);
SkeletalAnim.Name = Text;
LoadAnim(SkeletalAnim);
}
else
{
//Create a new wii u skeletal anim and try to convert it instead
var ska = new ResU.SkeletalAnim();
ska.Import(FileName, new ResU.ResFile());
SkeletalAnim = BfresPlatformConverter.FSKAConvertWiiUToSwitch(ska);
SkeletalAnim.Name = Text;
LoadAnim(SkeletalAnim);
}
}
}
else if (ext == ".anim")
{
FromAnim(FileName);
}
else if (ext == ".seanim")
{
STSkeleton skeleton = GetActiveSkeleton();
if (skeleton != null)
{
var ska = FromGeneric(SEANIM.Read(FileName, skeleton));
ska.Loop = this.CanLoop;
UpdateAnimation(ska);
}
else
{
STErrorDialog.Show("No matching skeleton bones found to assign!", "Skeleton Importer", "");
}
}
else if (ext == ".smd")
{
STSkeleton skeleton = GetActiveSkeleton();
if (skeleton != null)
{
var ska = FromGeneric(SMD.Read(FileName, skeleton));
ska.Loop = this.CanLoop;
UpdateAnimation(ska);
}
else
{
STErrorDialog.Show("No matching skeleton bones found to assign!", "Skeleton Importer", "");
}
}
else if (ext == ".chr0")
{
FromChr0(FileName, resFileU != null);
}
else if (ext == ".dae")
{
// FromAssimp(FileName, resFileU != null);
}
else if (ext == ".fbx")
{
// FromAssimp(FileName, resFileU != null);
}
}
private static uint CalculateBakeSize(SkeletalAnim fska)
{
return(0);
}
public static void FromStruct(SkeletalAnim anim, SkeletalAnimHelper animJson)
{
anim.Name = animJson.Name;
anim.Baked = animJson.Baked;
anim.Loop = animJson.Loop;
anim.FrameCount = animJson.FrameCount;
anim.Baked = animJson.Baked;
anim.FlagsRotate = animJson.FlagsRotate;
anim.FlagsScale = animJson.FlagsScale;
anim.BoneAnims = new List <BoneAnim>();
anim.BindIndices = new ushort[animJson.BoneAnims.Count];
anim.UserData = UserDataConvert.Convert(animJson.UserData);
foreach (var boneAnimJson in animJson.BoneAnims)
{
BoneAnim boneAnim = new BoneAnim();
anim.BoneAnims.Add(boneAnim);
//Always these indices
boneAnim.Name = boneAnimJson.Name;
boneAnim.BeginRotate = 3;
boneAnim.BeginTranslate = 6;
boneAnim.BeginBaseTranslate = 7;
Vector4F rotation = boneAnimJson.BaseData.Rotate;
if (animJson.UseDegrees && animJson.FlagsRotate == SkeletalAnimFlagsRotate.EulerXYZ)
{
rotation = new Vector4F(
rotation.X * CurveAnimHelper.Deg2Rad,
rotation.Y * CurveAnimHelper.Deg2Rad,
rotation.Z * CurveAnimHelper.Deg2Rad,
rotation.W);
}
boneAnim.BaseData = new BoneAnimData()
{
Flags = boneAnimJson.BaseData.Flags,
Rotate = rotation,
Translate = boneAnimJson.BaseData.Translate,
Scale = boneAnimJson.BaseData.Scale,
};
boneAnim.FlagsTransform |= BoneAnimFlagsTransform.Identity;
if (boneAnimJson.UseBaseTranslation)
{
boneAnim.FlagsBase |= BoneAnimFlagsBase.Translate;
}
if (boneAnimJson.UseBaseRotation)
{
boneAnim.FlagsBase |= BoneAnimFlagsBase.Rotate;
}
if (boneAnimJson.UseBaseScale)
{
boneAnim.FlagsBase |= BoneAnimFlagsBase.Scale;
}
foreach (var curveJson in boneAnimJson.Curves)
{
var target = (AnimTarget)Enum.Parse(typeof(AnimTarget), curveJson.Target);
var curve = CurveAnimHelper.GenerateCurve(curveJson, (uint)target,
curveJson.Target.Contains("Rotate") && animJson.UseDegrees);
boneAnim.Curves.Add(curve);
boneAnim.FlagsCurve = SetCurveTarget(target);
}
boneAnim.CalculateTransformFlags();
boneAnim.ApplySegmentScaleCompensate = boneAnimJson.SegmentScaleCompensate;
}
}
private static void WriteSkeletalAnimation(XmlWriter writer, SkeletalAnim anim)
{
JPSkeletalAnim jPSkeletalAnim = new JPSkeletalAnim();
jPSkeletalAnim.LoadAnimData(anim);
writer.WriteStartElement("Anim");
writer.WriteAttributeString("Name", anim.Name);
writer.WriteAttributeString("IsBaked", anim.Baked.ToString());
writer.WriteAttributeString("IsLooping", anim.Loop.ToString());
writer.WriteAttributeString("ScalingType", anim.FlagsScale.ToString());
writer.WriteAttributeString("RotationType", anim.FlagsRotate.ToString());
writer.WriteAttributeString("FrameCount", anim.FrameCount.ToString());
writer.WriteAttributeString("BoneAnimationCount", anim.BoneAnims.Count.ToString());
writer.WriteAttributeString("BakedSize", anim.BakedSize.ToString());
writer.WriteAttributeString("UserDataCount", anim.UserData.Count.ToString()); // TODO Is this printing IK data??
string bindIndices = "";
for (int i = 0; i < anim.BindIndices.Length; i++)
{
short index = (short)anim.BindIndices[i];
bindIndices += index.ToString() + ",";
}
bindIndices = bindIndices.Trim(',');
writer.WriteAttributeString("BindIndices", bindIndices);
writer.WriteStartElement("BoneAnims");
// Check for non hermite curves
for (int i = 0; i < anim.BoneAnims.Count; i++)
{
for (int j = 0; j < anim.BoneAnims[i].Curves.Count; j++)
{
Program.AssertAndLog(Program.ErrorType.eNonHermiteAnimCurve, anim.BoneAnims[i].Curves[j].CurveType == AnimCurveType.Cubic, $"{anim.BoneAnims[i].Curves[j].CurveType} is a non hermite curve");
}
}
WriteJPSkeletonBoneAnimData(writer, jPSkeletalAnim);
writer.WriteEndElement();
writer.WriteStartElement("UserDatas");
for (int i = 0; i < anim.UserData.Count; i++)
{
writer.WriteStartElement("UserData");
writer.WriteAttributeString("Name", anim.UserData[i].Name.ToString());
writer.WriteAttributeString("Type", anim.UserData[i].Type.ToString());
string values = "";
switch (anim.UserData[i].Type)
{
case UserDataType.Int32:
foreach (int value in anim.UserData[i].GetValueInt32Array())
{
values += value.ToString() + ',';
}
values = values.Trim(',');
writer.WriteAttributeString("Values", values);
break;
case UserDataType.Single:
foreach (float value in anim.UserData[i].GetValueSingleArray())
{
values += value.ToString() + ',';
}
values = values.Trim(',');
writer.WriteAttributeString("Values", values);
break;
case UserDataType.String:
foreach (string value in anim.UserData[i].GetValueStringArray())
{
values += value.ToString() + ',';
}
values = values.Trim(',');
writer.WriteAttributeString("Values", values);
break;
case UserDataType.WString:
foreach (string value in anim.UserData[i].GetValueStringArray())
{
values += value.ToString() + ',';
}
values = values.Trim(',');
writer.WriteAttributeString("Values", values);
break;
case UserDataType.Byte:
foreach (byte value in anim.UserData[i].GetValueByteArray())
{
values += value.ToString() + ',';
}
values = values.Trim(',');
writer.WriteAttributeString("Values", values);
break;
default:
break;
}
writer.WriteEndElement();
}
writer.WriteEndElement();
// anim.BindSkeleton just know this exists
writer.WriteEndElement();
}
public void Reload(SkeletalAnim anim)
{
SkeletalAnim = anim;
Name = anim.Name;
FrameCount = anim.FrameCount;
FrameRate = 60.0f;
Loop = anim.Loop;
AnimGroups.Clear();
foreach (var boneAnim in anim.BoneAnims)
{
var group = new BoneAnimGroup();
AnimGroups.Add(group);
group.Name = boneAnim.Name;
if (anim.FlagsRotate == SkeletalAnimFlagsRotate.Quaternion)
{
group.UseQuaternion = true;
}
float scale = GLContext.PreviewScale;
//Set the base data for the first set of keys if used
if (boneAnim.FlagsBase.HasFlag(BoneAnimFlagsBase.Translate))
{
group.Translate.X.KeyFrames.Add(new STKeyFrame(0, boneAnim.BaseData.Translate.X));
group.Translate.Y.KeyFrames.Add(new STKeyFrame(0, boneAnim.BaseData.Translate.Y));
group.Translate.Z.KeyFrames.Add(new STKeyFrame(0, boneAnim.BaseData.Translate.Z));
}
if (boneAnim.FlagsBase.HasFlag(BoneAnimFlagsBase.Rotate))
{
group.Rotate.X.KeyFrames.Add(new STKeyFrame(0, boneAnim.BaseData.Rotate.X));
group.Rotate.Y.KeyFrames.Add(new STKeyFrame(0, boneAnim.BaseData.Rotate.Y));
group.Rotate.Z.KeyFrames.Add(new STKeyFrame(0, boneAnim.BaseData.Rotate.Z));
group.Rotate.W.KeyFrames.Add(new STKeyFrame(0, boneAnim.BaseData.Rotate.Z));
}
if (boneAnim.FlagsBase.HasFlag(BoneAnimFlagsBase.Scale))
{
group.Scale.X.KeyFrames.Add(new STKeyFrame(0, boneAnim.BaseData.Scale.X));
group.Scale.Y.KeyFrames.Add(new STKeyFrame(0, boneAnim.BaseData.Scale.Y));
group.Scale.Z.KeyFrames.Add(new STKeyFrame(0, boneAnim.BaseData.Scale.Z));
}
if (boneAnim.ApplySegmentScaleCompensate)
{
group.UseSegmentScaleCompensate = true;
}
//Generate keyed data from the curves
foreach (var curve in boneAnim.Curves)
{
switch ((TrackType)curve.AnimDataOffset)
{
case TrackType.XPOS: BfresAnimations.GenerateKeys(group.Translate.X, curve); break;
case TrackType.YPOS: BfresAnimations.GenerateKeys(group.Translate.Y, curve); break;
case TrackType.ZPOS: BfresAnimations.GenerateKeys(group.Translate.Z, curve); break;
case TrackType.XROT: BfresAnimations.GenerateKeys(group.Rotate.X, curve); break;
case TrackType.YROT: BfresAnimations.GenerateKeys(group.Rotate.Y, curve); break;
case TrackType.ZROT: BfresAnimations.GenerateKeys(group.Rotate.Z, curve); break;
case TrackType.WROT: BfresAnimations.GenerateKeys(group.Rotate.W, curve); break;
case TrackType.XSCA: BfresAnimations.GenerateKeys(group.Scale.X, curve); break;
case TrackType.YSCA: BfresAnimations.GenerateKeys(group.Scale.Y, curve); break;
case TrackType.ZSCA: BfresAnimations.GenerateKeys(group.Scale.Z, curve); break;
}
}
}
}
public FSKA(SkeletalAnim ska)
{
LoadAnim(ska);
}
//This hasn't been necessary so far but i do need todo this
public uint CalculateBakeSize(SkeletalAnim ska)
{
return(0);
}
public void Read(SkeletalAnim ska, ResFile b)
{
FrameCount = ska.FrameCount;
SkeletalAnim = ska;
foreach (BoneAnim bn in ska.BoneAnims)
{
FSKANode bonean = new FSKANode(bn);
Animation.KeyNode bone = new Animation.KeyNode("");
Bones.Add(bone);
if (ska.FlagsRotate == SkeletalAnimFlagsRotate.EulerXYZ)
{
bone.RotType = Animation.RotationType.EULER;
}
else
{
bone.RotType = Animation.RotationType.QUATERNION;
}
bone.Text = bonean.Text;
for (int Frame = 0; Frame < ska.FrameCount; Frame++)
{
if (Frame == 0)
{
if (bn.FlagsBase.HasFlag(BoneAnimFlagsBase.Scale))
{
bone.XSCA.Keys.Add(new KeyFrame()
{
Frame = 0, Value = bonean.sca.X
});
bone.YSCA.Keys.Add(new KeyFrame()
{
Frame = 0, Value = bonean.sca.Y
});
bone.ZSCA.Keys.Add(new KeyFrame()
{
Frame = 0, Value = bonean.sca.Z
});
}
if (bn.FlagsBase.HasFlag(BoneAnimFlagsBase.Rotate))
{
bone.XROT.Keys.Add(new KeyFrame()
{
Frame = 0, Value = bonean.rot.X
});
bone.YROT.Keys.Add(new KeyFrame()
{
Frame = 0, Value = bonean.rot.Y
});
bone.ZROT.Keys.Add(new KeyFrame()
{
Frame = 0, Value = bonean.rot.Z
});
bone.WROT.Keys.Add(new KeyFrame()
{
Frame = 0, Value = bonean.rot.W
});
}
if (bn.FlagsBase.HasFlag(BoneAnimFlagsBase.Translate))
{
bone.XPOS.Keys.Add(new KeyFrame()
{
Frame = 0, Value = bonean.pos.X
});
bone.YPOS.Keys.Add(new KeyFrame()
{
Frame = 0, Value = bonean.pos.Y
});
bone.ZPOS.Keys.Add(new KeyFrame()
{
Frame = 0, Value = bonean.pos.Z
});
}
}
foreach (FSKATrack track in bonean.tracks)
{
KeyFrame frame = new KeyFrame();
frame.InterType = Animation.InterpolationType.HERMITE;
frame.Frame = Frame;
FSKAKey left = track.GetLeft(Frame);
FSKAKey right = track.GetRight(Frame);
float value;
value = Animation.Hermite(Frame, left.frame, right.frame, 0, 0, left.unk1, right.unk1);
// interpolate the value and apply
switch (track.flag)
{
case (int)TrackType.XPOS: frame.Value = value; bone.XPOS.Keys.Add(frame); break;
case (int)TrackType.YPOS: frame.Value = value; bone.YPOS.Keys.Add(frame); break;
case (int)TrackType.ZPOS: frame.Value = value; bone.ZPOS.Keys.Add(frame); break;
case (int)TrackType.XROT: frame.Value = value; bone.XROT.Keys.Add(frame); break;
case (int)TrackType.YROT: frame.Value = value; bone.YROT.Keys.Add(frame); break;
case (int)TrackType.ZROT: frame.Value = value; bone.ZROT.Keys.Add(frame); break;
case (int)TrackType.XSCA: frame.Value = value; bone.XSCA.Keys.Add(frame); break;
case (int)TrackType.YSCA: frame.Value = value; bone.YSCA.Keys.Add(frame); break;
case (int)TrackType.ZSCA: frame.Value = value; bone.ZSCA.Keys.Add(frame); break;
}
}
}
}
}
private void LoadAnimData(SkeletalAnim ska)
{
Nodes.Clear();
Bones.Clear();
CanLoop = ska.FlagsAnimSettings.HasFlag(SkeletalAnimFlags.Looping);
for (int i = 0; i < ska.BoneAnims.Count; i++)
{
var bn = ska.BoneAnims[i];
BoneAnimNode bone = new BoneAnimNode(bn.Name, false);
bone.BoneAnim = bn;
bone.UseSegmentScaleCompensate = bn.ApplySegmentScaleCompensate;
Bones.Add(bone);
// Nodes.Add(bone);
if (ska.FlagsRotate == SkeletalAnimFlagsRotate.EulerXYZ)
{
bone.RotType = Animation.RotationType.EULER;
}
else
{
bone.RotType = Animation.RotationType.QUATERNION;
}
if (bn.UseScale)
{
bone.XSCA.Keys.Add(new KeyFrame()
{
Frame = 0, Value = bn.BaseData.Scale.X, IsKeyed = true
});
bone.YSCA.Keys.Add(new KeyFrame()
{
Frame = 0, Value = bn.BaseData.Scale.Y, IsKeyed = true
});
bone.ZSCA.Keys.Add(new KeyFrame()
{
Frame = 0, Value = bn.BaseData.Scale.Z, IsKeyed = true
});
}
if (bn.UseRotation)
{
bone.XROT.Keys.Add(new KeyFrame()
{
Frame = 0, Value = bn.BaseData.Rotate.X, IsKeyed = true
});
bone.YROT.Keys.Add(new KeyFrame()
{
Frame = 0, Value = bn.BaseData.Rotate.Y, IsKeyed = true
});
bone.ZROT.Keys.Add(new KeyFrame()
{
Frame = 0, Value = bn.BaseData.Rotate.Z, IsKeyed = true
});
bone.WROT.Keys.Add(new KeyFrame()
{
Frame = 0, Value = bn.BaseData.Rotate.W, IsKeyed = true
});
}
if (bn.UseTranslation)
{
bone.XPOS.Keys.Add(new KeyFrame()
{
Frame = 0, Value = bn.BaseData.Translate.X, IsKeyed = true
});
bone.YPOS.Keys.Add(new KeyFrame()
{
Frame = 0, Value = bn.BaseData.Translate.Y, IsKeyed = true
});
bone.ZPOS.Keys.Add(new KeyFrame()
{
Frame = 0, Value = bn.BaseData.Translate.Z, IsKeyed = true
});
}
for (int curve = 0; curve < bn.Curves.Count; curve++)
{
Animation.KeyGroup keyGroup = CurveHelper.CreateTrack(bn.Curves[curve]);
keyGroup.AnimDataOffset = bn.Curves[curve].AnimDataOffset;
switch (keyGroup.AnimDataOffset)
{
case (int)TrackType.XPOS: bone.XPOS.Keys.AddRange(keyGroup.Keys); break;
case (int)TrackType.YPOS: bone.YPOS.Keys.AddRange(keyGroup.Keys); break;
case (int)TrackType.ZPOS: bone.ZPOS.Keys.AddRange(keyGroup.Keys); break;
case (int)TrackType.XROT: bone.XROT.Keys.AddRange(keyGroup.Keys); break;
case (int)TrackType.YROT: bone.YROT.Keys.AddRange(keyGroup.Keys); break;
case (int)TrackType.ZROT: bone.ZROT.Keys.AddRange(keyGroup.Keys); break;
case (int)TrackType.WROT: bone.WROT.Keys.AddRange(keyGroup.Keys); break;
case (int)TrackType.XSCA: bone.XSCA.Keys.AddRange(keyGroup.Keys); break;
case (int)TrackType.YSCA: bone.YSCA.Keys.AddRange(keyGroup.Keys); break;
case (int)TrackType.ZSCA: bone.ZSCA.Keys.AddRange(keyGroup.Keys); break;
default: throw new Exception("Unknown Anim Offset " + keyGroup.AnimDataOffset);
}
}
}
}
private void WriteSkeletonAnimations(SkeletalAnim ska)
{
if (ska.BindIndices.Length > 0)
{
Align(4);
WriteOffset(ska.PosBindIndicesOffset);
Write(ska.BindIndices);
}
if (ska.BoneAnims.Count > 0)
{
Align(4);
WriteOffset(ska.PosBoneAnimsOffset);
for (int i = 0; i < ska.BoneAnims.Count; i++)
{
((IResData)ska.BoneAnims[i]).Save(this);
}
}
for (int b = 0; b < ska.BoneAnims.Count; b++)
{
object baseData = ska.BoneAnims[b].BaseData;
if (baseData != null && ska.BoneAnims[b].FlagsBase.HasFlag(BoneAnimFlagsBase.Translate) ||
ska.BoneAnims[b].FlagsBase.HasFlag(BoneAnimFlagsBase.Rotate) ||
ska.BoneAnims[b].FlagsBase.HasFlag(BoneAnimFlagsBase.Scale))
{
Align(4);
WriteOffset(ska.BoneAnims[b].PosBaseDataOffset);
ska.BoneAnims[b].BaseData.Save(this, ska.BoneAnims[b].FlagsBase);
}
if (ska.BoneAnims[b].Curves.Count > 0)
{
Align(4);
WriteOffset(ska.BoneAnims[b].PosCurvesOffset);
for (int i = 0; i < ska.BoneAnims[b].Curves.Count; i++)
{
ska.BoneAnims[b].Curves[i].SaveEntryBlock = false;
((IResData)ska.BoneAnims[b].Curves[i]).Save(this);
}
for (int i = 0; i < ska.BoneAnims[b].Curves.Count; i++)
{
if (ska.BoneAnims[b].Curves[i].Frames.Length > 0)
{
Align(4);
WriteOffset(ska.BoneAnims[b].Curves[i].PosFrameOffset);
ska.BoneAnims[b].Curves[i].SaveFrames(this);
}
if (ska.BoneAnims[b].Curves[i].Keys.Length > 0)
{
Align(4);
WriteOffset(ska.BoneAnims[b].Curves[i].PosKeyDataOffset);
ska.BoneAnims[b].Curves[i].SaveKeyData(this);
}
}
}
}
if (ska.UserData.Count > 0)
{
WriteOffset(ska.PosUserDataOffset);
((IResData)ska.UserData).Save(this);
Align(8);
}
}
