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); } }