public static SceneAnim FromJson(string json)
{
SceneAnim anim = new SceneAnim();
FromJson(anim, json);
return(anim);
}
private void LoadAnim(SceneAnim scn)
{
Text = scn.Name;
SceneAnim = scn;
foreach (var cameraAnim in scn.CameraAnims)
{
BfresCameraAnim anim = new BfresCameraAnim();
anim.LoadAnim(cameraAnim);
Nodes.Add(anim);
}
foreach (var lightAnim in scn.LightAnims)
{
BfresLightAnim anim = new BfresLightAnim();
anim.LoadAnim(lightAnim);
Nodes.Add(anim);
}
foreach (var fogAnim in scn.FogAnims)
{
BfresFogAnim anim = new BfresFogAnim();
anim.LoadAnim(fogAnim);
Nodes.Add(anim);
}
}
public static void Write(ResFileSwitchSaver saver, SceneAnim sceneAnim)
{
if (saver.ResFile.VersionMajor2 == 9)
{
saver.Write(sceneAnim.Flags);
}
else
{
saver.SaveHeaderBlock();
}
saver.SaveString(sceneAnim.Name);
saver.SaveString(sceneAnim.Path);
sceneAnim.PosCameraAnimArrayOffset = saver.SaveOffset();
sceneAnim.PosCameraAnimDictOffset = saver.SaveOffset();
sceneAnim.PosLightAnimArrayOffset = saver.SaveOffset();
sceneAnim.PosLightAnimDictOffset = saver.SaveOffset();
sceneAnim.PosFogAnimArrayOffset = saver.SaveOffset();
sceneAnim.PosFogAnimDictOffset = saver.SaveOffset();
sceneAnim.PosUserDataOffset = saver.SaveOffset();
sceneAnim.PosUserDataDictOffset = saver.SaveOffset();
saver.Write((ushort)sceneAnim.UserData.Count);
saver.Write((ushort)sceneAnim.CameraAnims.Count);
saver.Write((ushort)sceneAnim.LightAnims.Count);
saver.Write((ushort)sceneAnim.FogAnims.Count);
}
public static string ToJson(string Name, SceneAnim sceneAnim)
{
var config = new AnimConfig();
config.ToYaml(sceneAnim);
return(JsonConvert.SerializeObject(config, Formatting.Indented));
}
public void ToYaml(SceneAnim sceneAnim)
{
Name = sceneAnim.Name;
Path = sceneAnim.Path;
foreach (var cameraAnim in sceneAnim.CameraAnims)
{
CameraAnimations.Add(new CameraAnimConfig(cameraAnim));
}
}
public override void Replace(string FileName)
{
string ext = Utils.GetExtension(FileName);
if (ext == ".bfscn")
{
Replace(FileName, GetResFile(), GetResFileU());
}
else if (ext == ".yaml")
{
SceneAnim = YamlFscn.FromYaml(FileName);
}
else if (ext == ".json")
{
SceneAnim = YamlFscn.FromJson(FileName);
}
}
public static string ToYaml(string Name, SceneAnim sceneAnim)
{
var serializerSettings = new SerializerSettings()
{
// EmitTags = false
};
serializerSettings.DefaultStyle = YamlStyle.Any;
serializerSettings.ComparerForKeySorting = null;
serializerSettings.RegisterTagMapping("AnimConfig", typeof(AnimConfig));
var config = new AnimConfig();
config.ToYaml(sceneAnim);
var serializer = new Serializer(serializerSettings);
string yaml = serializer.Serialize(config, typeof(AnimConfig));
return(yaml);
}
internal static void Read(ResFileSwitchLoader loader, SceneAnim sceneAnim)
{
if (loader.ResFile.VersionMajor2 == 9)
{
sceneAnim.Flags = loader.ReadUInt32();
}
else
{
loader.LoadHeaderBlock();
}
sceneAnim.Name = loader.LoadString();
sceneAnim.Path = loader.LoadString();
sceneAnim.CameraAnims = loader.LoadDictValues <CameraAnim>();
sceneAnim.LightAnims = loader.LoadDictValues <LightAnim>();
sceneAnim.FogAnims = loader.LoadDictValues <FogAnim>();
sceneAnim.UserData = loader.LoadDictValues <UserData>();
ushort numUserData = loader.ReadUInt16();
ushort numCameraAnim = loader.ReadUInt16();
ushort numLightAnim = loader.ReadUInt16();
ushort numFogAnim = loader.ReadUInt16();
}
public FSCN(SceneAnim scn)
{
Initialize(); LoadAnim(scn);
}
public static void FromJson(SceneAnim anim, string json)
{
JsonConvert.DefaultSettings = () =>
{
var settings = new JsonSerializerSettings();
return(settings);
};
var animJson = JsonConvert.DeserializeObject <SceneAnimStuct>(json);
anim.Name = animJson.Name;
anim.CameraAnims = new ResDict <CameraAnim>();
anim.LightAnims = new ResDict <LightAnim>();
anim.FogAnims = new ResDict <FogAnim>();
anim.UserData = UserDataConvert.Convert(animJson.UserData);
foreach (var camAnimJson in animJson.CameraAnims)
{
CameraAnim camAnim = new CameraAnim();
camAnim.Flags = 0;
anim.CameraAnims.Add(camAnimJson.Name, camAnim);
if (camAnimJson.Loop)
{
camAnim.Flags |= CameraAnimFlags.Looping;
}
if (camAnimJson.Baked)
{
camAnim.Flags |= CameraAnimFlags.BakedCurve;
}
if (camAnimJson.Perspective)
{
camAnim.Flags |= CameraAnimFlags.Perspective;
}
if (camAnimJson.EulerRotation)
{
camAnim.Flags |= CameraAnimFlags.EulerZXY;
}
camAnim.Name = camAnimJson.Name;
camAnim.FrameCount = camAnimJson.FrameCount;
camAnim.BaseData = camAnimJson.BaseData;
foreach (var curveJson in camAnimJson.Curves)
{
var target = (CameraAnimDataOffset)Enum.Parse(typeof(CameraAnimDataOffset), curveJson.Target);
var curve = CurveAnimHelper.GenerateCurve(curveJson, (uint)target, false);
camAnim.Curves.Add(curve);
}
}
foreach (var lightAnimJson in animJson.LightAnims)
{
LightAnim lightAnim = new LightAnim();
lightAnim.Flags = 0;
anim.LightAnims.Add(lightAnimJson.Name, lightAnim);
if (lightAnimJson.Loop)
{
lightAnim.Flags |= LightAnimFlags.Looping;
}
if (lightAnimJson.Baked)
{
lightAnim.Flags |= LightAnimFlags.BakedCurve;
}
if (lightAnimJson.BaseAngleAttn)
{
lightAnim.Flags |= LightAnimFlags.BaseAngleAttn;
}
if (lightAnimJson.BaseColor0)
{
lightAnim.Flags |= LightAnimFlags.BaseColor0;
}
if (lightAnimJson.BaseColor1)
{
lightAnim.Flags |= LightAnimFlags.BaseColor1;
}
if (lightAnimJson.BaseDir)
{
lightAnim.Flags |= LightAnimFlags.BaseDir;
}
if (lightAnimJson.BaseDistAttn)
{
lightAnim.Flags |= LightAnimFlags.BaseDistAttn;
}
if (lightAnimJson.BasePos)
{
lightAnim.Flags |= LightAnimFlags.BasePos;
}
lightAnim.Name = lightAnimJson.Name;
lightAnim.FrameCount = lightAnimJson.FrameCount;
lightAnim.BaseData = lightAnimJson.BaseData;
if (lightAnim.BaseData.Enable == 1)
{
lightAnim.Flags |= LightAnimFlags.BaseEnable;
}
foreach (var curveJson in lightAnimJson.Curves)
{
var target = (CameraAnimDataOffset)Enum.Parse(typeof(CameraAnimDataOffset), curveJson.Target);
var curve = CurveAnimHelper.GenerateCurve(curveJson, (uint)target, false);
lightAnim.Curves.Add(curve);
}
}
foreach (var fogAnimJson in animJson.FogAnims)
{
FogAnim fogAnim = new FogAnim();
fogAnim.Flags = 0;
anim.CameraAnims.Add(fogAnimJson.Name, fogAnim);
if (fogAnimJson.Loop)
{
fogAnim.Flags |= FogAnimFlags.Looping;
}
if (fogAnimJson.Baked)
{
fogAnim.Flags |= FogAnimFlags.BakedCurve;
}
fogAnim.Name = fogAnimJson.Name;
fogAnim.FrameCount = fogAnimJson.FrameCount;
fogAnim.DistanceAttnFuncIndex = fogAnimJson.DistanceAttnFuncIndex;
fogAnim.DistanceAttnFuncName = fogAnimJson.DistanceAttnFuncName;
fogAnim.BaseData = fogAnimJson.BaseData;
foreach (var curveJson in fogAnimJson.Curves)
{
var target = (CameraAnimDataOffset)Enum.Parse(typeof(CameraAnimDataOffset), curveJson.Target);
var curve = CurveAnimHelper.GenerateCurve(curveJson, (uint)target, false);
fogAnim.Curves.Add(curve);
}
}
}
public static string ToJson(SceneAnim anim)
{
SceneAnimStuct animConv = new SceneAnimStuct();
animConv.Name = anim.Name;
animConv.Path = anim.Path;
animConv.CameraAnims = new List <CameraAnimStruct>();
animConv.LightAnims = new List <LightAnimStruct>();
animConv.FogAnims = new List <FogAnimStruct>();
foreach (var camAnim in anim.CameraAnims.Values)
{
CameraAnimStruct camAnimConv = new CameraAnimStruct();
camAnimConv.Curves = new List <CurveAnimHelper>();
camAnimConv.Name = camAnim.Name;
camAnimConv.FrameCount = camAnim.FrameCount;
camAnimConv.Loop = camAnim.Flags.HasFlag(CameraAnimFlags.Looping);
camAnimConv.Baked = camAnim.Flags.HasFlag(CameraAnimFlags.BakedCurve);
camAnimConv.BaseData = camAnim.BaseData;
camAnimConv.EulerRotation = camAnim.Flags.HasFlag(CameraAnimFlags.EulerZXY);
camAnimConv.Perspective = camAnim.Flags.HasFlag(CameraAnimFlags.Perspective);
animConv.CameraAnims.Add(camAnimConv);
foreach (var curve in camAnim.Curves)
{
string target = ((CameraAnimDataOffset)curve.AnimDataOffset).ToString();
bool isDegrees = target.Contains("Rotation") && animConv.UseDegrees && camAnimConv.EulerRotation;
var convCurve = CurveAnimHelper.FromCurve(curve, target, isDegrees);
camAnimConv.Curves.Add(convCurve);
}
}
foreach (var lightAnim in anim.LightAnims.Values)
{
LightAnimStruct lightAnimConv = new LightAnimStruct();
lightAnimConv.Curves = new List <CurveAnimHelper>();
lightAnimConv.Name = lightAnim.Name;
lightAnimConv.FrameCount = lightAnim.FrameCount;
lightAnimConv.Loop = lightAnim.Flags.HasFlag(LightAnimFlags.Looping);
lightAnimConv.Baked = lightAnim.Flags.HasFlag(LightAnimFlags.BakedCurve);
lightAnimConv.BaseAngleAttn = lightAnim.Flags.HasFlag(LightAnimFlags.BaseAngleAttn);
lightAnimConv.BaseColor0 = lightAnim.Flags.HasFlag(LightAnimFlags.BaseColor0);
lightAnimConv.BaseColor1 = lightAnim.Flags.HasFlag(LightAnimFlags.BaseColor1);
lightAnimConv.BaseDir = lightAnim.Flags.HasFlag(LightAnimFlags.BaseDir);
lightAnimConv.BaseDistAttn = lightAnim.Flags.HasFlag(LightAnimFlags.BaseDistAttn);
lightAnimConv.BasePos = lightAnim.Flags.HasFlag(LightAnimFlags.BasePos);
if (lightAnim.Flags.HasFlag(LightAnimFlags.BaseEnable))
{
lightAnimConv.BaseData = lightAnim.BaseData;
}
animConv.LightAnims.Add(lightAnimConv);
foreach (var curve in lightAnim.Curves)
{
string target = ((LightAnimDataOffset)curve.AnimDataOffset).ToString();
var convCurve = CurveAnimHelper.FromCurve(curve, target, false);
lightAnimConv.Curves.Add(convCurve);
}
}
foreach (var fogAnim in anim.FogAnims.Values)
{
FogAnimStruct fogAnimConv = new FogAnimStruct();
fogAnimConv.Curves = new List <CurveAnimHelper>();
fogAnimConv.Name = fogAnim.Name;
fogAnimConv.FrameCount = fogAnim.FrameCount;
fogAnimConv.Loop = fogAnim.Flags.HasFlag(FogAnimFlags.Looping);
fogAnimConv.Baked = fogAnim.Flags.HasFlag(FogAnimFlags.BakedCurve);
fogAnimConv.BaseData = fogAnim.BaseData;
fogAnimConv.DistanceAttnFuncIndex = fogAnim.DistanceAttnFuncIndex;
fogAnimConv.DistanceAttnFuncName = fogAnim.DistanceAttnFuncName;
animConv.FogAnims.Add(fogAnimConv);
foreach (var curve in fogAnim.Curves)
{
string target = ((FogAnimDataOffset)curve.AnimDataOffset).ToString();
var convCurve = CurveAnimHelper.FromCurve(curve, target, false);
fogAnimConv.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 void Read(SceneAnim scn)
{
SceneAnim = scn;
}
public SceneAnim FromYaml()
{
SceneAnim anim = new SceneAnim();
anim.Name = Name;
anim.Path = Path;
foreach (var camera in CameraAnimations)
{
CameraAnim camAnim = new CameraAnim();
camAnim.Name = camera.Name;
camAnim.FrameCount = camera.FrameCount;
camAnim.BakedSize = camera.BakedSize;
camAnim.BaseData = camera.BaseData;
if (camera.EulerZXY)
{
camAnim.Flags |= CameraAnimFlags.EulerZXY;
}
if (camera.Loop)
{
camAnim.Flags |= CameraAnimFlags.Looping;
}
if (camera.Perspective)
{
camAnim.Flags |= CameraAnimFlags.Perspective;
}
foreach (var curve in camera.Curves)
{
AnimCurve animCurve = new AnimCurve();
animCurve.AnimDataOffset = ConvertOffset(curve.Type);
animCurve.Scale = 1;
animCurve.CurveType = AnimCurveType.Linear;
int FrameCount = curve.KeyFrames.Count;
animCurve.Frames = new float[FrameCount];
animCurve.Keys = new float[FrameCount, 2];
var values = curve.KeyFrames.Values.ToList();
for (int i = 0; i < curve.KeyFrames.Count; i++)
{
var KeyFrame = curve.KeyFrames.ElementAt(i);
animCurve.Frames[i] = KeyFrame.Key;
animCurve.Keys[i, 0] = KeyFrame.Value;
//Calculate delta
float Delta = 0;
if (i < values.Count - 1)
{
Delta = values[i + 1] - values[i];
}
animCurve.Keys[i, 1] = Delta;
}
animCurve.StartFrame = animCurve.Frames.Max();
animCurve.EndFrame = animCurve.Frames.Max();
if (animCurve.Keys.Length > 1)
{
animCurve.Delta = values[values.Count - 1] - values[0];
}
animCurve.KeyType = AnimCurveKeyType.Single;
animCurve.FrameType = AnimCurveFrameType.Single;
camAnim.Curves.Add(animCurve);
}
anim.CameraAnims.Add(camAnim);
anim.CameraAnimDict.Add(camAnim.Name);
}
return(anim);
}
