/// <summary>
/// Reads a <see cref="AnimConstant"/> instance from the current stream and returns it.
/// </summary>
/// <param name="self">The extended <see cref="BinaryDataReader"/>.</param>
/// <param name="count">The number of instances to read.</param>
/// <returns>The <see cref="AnimConstant"/> instance.</returns>
public static AnimConstant[] ReadAnimConstants(this BinaryDataReader self, int count)
{
AnimConstant[] values = new AnimConstant[count];
for (int i = 0; i < count; i++)
{
values[i] = self.ReadAnimConstant();
}
return(values);
}
private void SaveParamInfos(MaterialAnimData data, Material mat, int ParamCurveIndex)
{
foreach (var param in mat.Params)
{
//Set our begin curve index
bool SetBeginCurve = false;
if (!SetBeginCurve)
{
data.ShaderParamCurveIndex += ParamCurveIndex;
data.BeginVisalConstantIndex += 0; //This is usually 0 so set it
SetBeginCurve = true;
}
foreach (var value in param.Values)
{
if (value.Constant)
{
AnimConstant animConstant = new AnimConstant();
animConstant.AnimDataOffset = 0;
animConstant.Value = value.GetValue(0); //Set our constant value
data.Constants.Add(animConstant);
}
else if (value.Keys.Count > 0) //Else create curves for each param value
{
//If constant, create a constant instance with the first value set
AnimCurve curve = new AnimCurve();
curve.AnimDataOffset = value.AnimDataOffset;
curve.Scale = value.Scale;
curve.Offset = value.Offset;
data.Curves.Add(curve);
}
}
}
}
private void SavePatternInfos(MaterialAnimData data, Material mat, int TexturePatternCurveIndex)
{
bool SetBeginCurve = false;
foreach (var sampler in mat.Samplers)
{
//If constant, create a constant instance with the first value set
if (sampler.Constant)
{
AnimConstant animConstant = new AnimConstant();
animConstant.AnimDataOffset = 0;
animConstant.Value = sampler.GetValue(0);
data.Constants.Add(animConstant);
}
else if (sampler.Keys.Count > 0)
{
//If a sampler is not constant and uses curve data, then we need to set our begin curve index
if (!SetBeginCurve)
{
data.TexturePatternCurveIndex += TexturePatternCurveIndex;
data.BeginVisalConstantIndex += 0; //This is usually 0 so set it
SetBeginCurve = true;
}
//Create a curve to store all the index data in for each frame
AnimCurve curve = new AnimCurve();
curve.AnimDataOffset = 0;
//Set our data types. Pattern and visibilty are always the same type
if (AnimType == AnimationType.TexturePattern)
{
curve.CurveType = AnimCurveType.StepInt;
}
else if (AnimType == AnimationType.Visibilty)
{
curve.CurveType = AnimCurveType.StepBool;
}
else
{
if (sampler.InterpolationType == InterpolationType.HERMITE)
{
curve.CurveType = AnimCurveType.Cubic;
}
if (sampler.InterpolationType == InterpolationType.LINEAR)
{
curve.CurveType = AnimCurveType.Linear;
}
if (sampler.InterpolationType == InterpolationType.STEP)
{
curve.CurveType = AnimCurveType.StepInt;
}
if (sampler.InterpolationType == InterpolationType.STEPBOOL)
{
curve.CurveType = AnimCurveType.StepBool;
}
}
curve.Delta = 0;
curve.EndFrame = FrameCount;
curve.StartFrame = 0;
curve.FrameType = AnimCurveFrameType.Byte;
curve.Scale = 1;
curve.Offset = 0;
List <float> Frames = new List <float>();
List <float> Keys = new List <float>();
for (int frame = 0; frame < sampler.Keys.Count; frame++)
{
float currentIndex = sampler.GetValue(frame);
if (frame > 0)
{
float previousIndex = sampler.GetValue(frame - 1);
if (currentIndex != previousIndex)
{
//Add key frame if texture not loaded previously
Frames.Add(frame);
Keys.Add(currentIndex);
}
}
else
{
//Add the first key frame value. We would add base values here but switch has none
Frames.Add(frame);
Keys.Add(currentIndex);
}
}
for (int i = 0; i < Keys.Count; i++)
{
curve.Keys[i, 0] = Keys[i];
}
curve.Frames = Frames.ToArray();
TexturePatternCurveIndex += 1;
}
}
}
// ---- METHODS (PUBLIC) ---------------------------------------------------------------------------------------
/// <summary>
/// Writes a <see cref="AnimConstant"/> instance into the current stream.
/// </summary>
/// <param name="self">The extended <see cref="BinaryDataWriter"/>.</param>
/// <param name="value">The <see cref="AnimConstant"/> instance.</param>
public static void Write(this BinaryDataWriter self, AnimConstant value)
{
self.Write(value.AnimDataOffset);
self.Write(value.Value);
}
public void ToYaml(MaterialAnim materialAnim, FMAA.AnimationType animType)
{
MaterialAnimConfigs = new List <MatAnimConfig>();
Name = materialAnim.Name;
Path = materialAnim.Path;
FrameCount = materialAnim.FrameCount;
Loop = materialAnim.Loop;
foreach (var mat in materialAnim.MaterialAnimDataList)
{
MatAnimConfig matConfig = new MatAnimConfig();
matConfig.Name = mat.Name;
MaterialAnimConfigs.Add(matConfig);
foreach (var paramInfo in mat.ParamAnimInfos)
{
ParamInfo paramCfg = new ParamInfo();
paramCfg.Name = paramInfo.Name;
paramCfg.IsConstant = paramInfo.ConstantCount != 0;
matConfig.ParamInfos.Add(paramCfg);
if (paramInfo.ConstantCount != 0)
{
paramCfg.Constants = new List <ConstantConfig>();
for (int i = 0; i < paramInfo.ConstantCount; i++)
{
AnimConstant constant = mat.Constants[paramInfo.BeginConstant + i];
ConstantConfig ConstantValue = new ConstantConfig();
ConstantValue.Offset = ConvertParamOffset(constant.AnimDataOffset, animType);
ConstantValue.Value = constant.Value;
paramCfg.Constants.Add(ConstantValue);
}
}
if (paramInfo.BeginCurve != ushort.MaxValue)
{
paramCfg.CurveData = new List <CurveConfig>();
for (int i = 0; i < paramInfo.IntCurveCount + paramInfo.FloatCurveCount; i++)
{
var curve = mat.Curves[(int)paramInfo.BeginCurve + i];
var CurveCfg = new CurveConfig();
CurveCfg.Offset = ConvertParamOffset(curve.AnimDataOffset, animType);
if (curve.Scale == 0)
{
curve.Scale = 1;
}
for (int f = 0; f < curve.Frames.Length; f++)
{
int frame = (int)curve.Frames[f];
float Value = curve.Offset + curve.Keys[f, 0] * curve.Scale;
CurveCfg.KeyFrames.Add(frame, Value);
}
paramCfg.CurveData.Add(CurveCfg);
}
}
}
foreach (var patternInfo in mat.TexturePatternAnimInfos)
{
PatternInfo infoCfg = new PatternInfo();
infoCfg.Name = patternInfo.Name;
infoCfg.IsConstant = patternInfo.BeginConstant != ushort.MaxValue;
matConfig.TexturePatternInfos.Add(infoCfg);
if (infoCfg.IsConstant)
{
infoCfg.ConstantValue = new ConstantTPConfig();
int Index = (int)mat.Constants[(int)patternInfo.BeginConstant].Value;
infoCfg.ConstantValue.Texture = materialAnim.TextureNames[Index];
}
if (patternInfo.CurveIndex != ushort.MaxValue)
{
var curve = mat.Curves[(int)patternInfo.CurveIndex];
infoCfg.CurveData = new CurveTPConfig();
if (curve.Scale == 0)
{
curve.Scale = 1;
}
for (int f = 0; f < curve.Frames.Length; f++)
{
int frame = (int)curve.Frames[f];
int Value = (int)curve.Offset + (int)curve.Keys[f, 0] * (int)curve.Scale;
infoCfg.CurveData.KeyFrames.Add(frame, materialAnim.TextureNames[Value]);
}
}
}
}
}
public MaterialAnim FromYaml()
{
MaterialAnim matAnim = new MaterialAnim();
matAnim.Name = Name;
matAnim.Path = Path;
matAnim.Loop = Loop;
matAnim.FrameCount = FrameCount;
matAnim.TextureNames = GenerateTextureList();
matAnim.BindIndices = new ushort[MaterialAnimConfigs.Count];
for (int i = 0; i < matAnim.BindIndices.Length; i++)
{
matAnim.BindIndices[i] = ushort.MaxValue;
}
int ShaderParamCurveIndex = 0;
int TexturePatternCurveIndex = 0;
Console.WriteLine("MaterialAnimConfigs " + MaterialAnimConfigs.Count);
foreach (var matCfg in MaterialAnimConfigs)
{
var matAnimData = new MaterialAnimData();
matAnimData.Name = matCfg.Name;
matAnimData.Constants = new List <AnimConstant>();
matAnimData.Curves = new List <AnimCurve>();
matAnimData.TexturePatternAnimInfos = new List <TexturePatternAnimInfo>();
matAnimData.ParamAnimInfos = new List <ParamAnimInfo>();
matAnimData.BeginVisalConstantIndex = -1;
matAnimData.ShaderParamCurveIndex = -1;
matAnimData.VisualConstantIndex = -1;
matAnimData.TexturePatternCurveIndex = -1;
matAnimData.VisalCurveIndex = -1;
matAnim.MaterialAnimDataList.Add(matAnimData);
ushort CurveIndex = 0;
ushort BeginConstantIndex = 0;
foreach (var texturePatternCfg in matCfg.TexturePatternInfos)
{
TexturePatternAnimInfo patternInfo = new TexturePatternAnimInfo();
patternInfo.Name = texturePatternCfg.Name;
matAnimData.TexturePatternAnimInfos.Add(patternInfo);
if (texturePatternCfg.IsConstant && texturePatternCfg.ConstantValue != null)
{
patternInfo.BeginConstant = BeginConstantIndex++;
AnimConstant constant = new AnimConstant();
constant.AnimDataOffset = 0;
constant.Value = matAnim.TextureNames.IndexOf(texturePatternCfg.ConstantValue.Texture);
matAnimData.Constants.Add(constant);
matAnimData.VisualConstantIndex = 0;
matAnimData.BeginVisalConstantIndex = 0;
}
else if (texturePatternCfg.CurveData != null)
{
patternInfo.CurveIndex = CurveIndex++;
matAnimData.TexturePatternCurveIndex = TexturePatternCurveIndex;
matAnimData.BeginVisalConstantIndex = 0;
AnimCurve curve = new AnimCurve();
matAnimData.Curves.Add(curve);
curve.Offset = 0;
curve.AnimDataOffset = 0;
curve.Scale = 1;
curve.CurveType = AnimCurveType.StepInt;
curve.StartFrame = 0;
int FrameCount = texturePatternCfg.CurveData.KeyFrames.Count;
curve.Frames = new float[FrameCount];
curve.Keys = new float[FrameCount, 1];
int MaxFrame = 0;
int MaxIndex = 0;
int i = 0;
foreach (var KeyFrame in texturePatternCfg.CurveData.KeyFrames)
{
int Index = matAnim.TextureNames.IndexOf(KeyFrame.Value);
Console.WriteLine($"{Index} {KeyFrame.Value}");
curve.Frames[i] = KeyFrame.Key;
curve.Keys[i, 0] = Index;
MaxFrame = Math.Max(MaxIndex, KeyFrame.Key);
MaxIndex = Math.Max(MaxIndex, Index);
i++;
}
curve.EndFrame = curve.Frames.Max();
if (curve.Keys.Length > 1)
{
curve.Delta = curve.Keys[curve.Keys.Length - 1, 0] - curve.Keys[0, 0];
}
if (MaxFrame < byte.MaxValue)
{
curve.FrameType = AnimCurveFrameType.Byte;
}
else if (MaxFrame < ushort.MaxValue)
{
curve.FrameType = AnimCurveFrameType.Decimal10x5;
}
else
{
curve.FrameType = AnimCurveFrameType.Single;
}
if (MaxIndex < byte.MaxValue)
{
curve.KeyType = AnimCurveKeyType.SByte;
}
else if (MaxIndex < ushort.MaxValue)
{
curve.KeyType = AnimCurveKeyType.Int16;
}
else
{
curve.KeyType = AnimCurveKeyType.Single;
}
}
}
foreach (var paramCfg in matCfg.ParamInfos)
{
ParamAnimInfo paramInfo = new ParamAnimInfo();
paramInfo.Name = paramCfg.Name;
matAnimData.ParamAnimInfos.Add(paramInfo);
if (paramCfg.Constants != null && paramCfg.Constants.Count > 0)
{
paramInfo.BeginConstant = BeginConstantIndex;
paramInfo.ConstantCount = (ushort)paramCfg.Constants.Count;
BeginConstantIndex += (ushort)paramCfg.Constants.Count;
foreach (var constantCfg in paramCfg.Constants)
{
AnimConstant constant = new AnimConstant();
constant.AnimDataOffset = ConvertParamOffset(constantCfg.Offset);
constant.Value = constantCfg.Value;
matAnimData.Constants.Add(constant);
}
}
if (paramCfg.CurveData != null && paramCfg.CurveData.Count > 0)
{
matAnimData.ShaderParamCurveIndex = ShaderParamCurveIndex;
paramInfo.BeginCurve = CurveIndex;
paramInfo.FloatCurveCount = (ushort)paramCfg.CurveData.Count;
CurveIndex += (ushort)paramCfg.CurveData.Count;
foreach (var curveCfg in paramCfg.CurveData)
{
AnimCurve curve = new AnimCurve();
matAnimData.Curves.Add(curve);
curve.Offset = 0;
curve.AnimDataOffset = ConvertParamOffset(curveCfg.Offset);
curve.Scale = 1;
curve.CurveType = AnimCurveType.Linear;
curve.StartFrame = 0;
int MaxFrame = 0;
float MaxValue = 0;
int FrameCount = curveCfg.KeyFrames.Count;
curve.Frames = new float[FrameCount];
curve.Keys = new float[FrameCount, 2];
int i = 0;
var values = curveCfg.KeyFrames.Values.ToList();
foreach (var KeyFrame in curveCfg.KeyFrames)
{
curve.Frames[i] = KeyFrame.Key;
curve.Keys[i, 0] = KeyFrame.Value;
//Calculate delta
float Delta = 0;
if (i < values.Count - 1)
{
Delta = values[i + 1] - values[i];
}
curve.Keys[i, 1] = Delta;
MaxFrame = Math.Max(MaxFrame, KeyFrame.Key);
MaxValue = Math.Max(MaxValue, KeyFrame.Value);
i++;
}
curve.EndFrame = curve.Frames.Max();
if (curve.Keys.Length > 1)
{
curve.Delta = values[values.Count - 1] - values[0];
}
curve.KeyType = AnimCurveKeyType.Single;
curve.FrameType = AnimCurveFrameType.Single;
/* if (MaxFrame < byte.MaxValue)
* curve.FrameType = AnimCurveFrameType.Byte;
* else if (MaxFrame < ushort.MaxValue)
* curve.FrameType = AnimCurveFrameType.Decimal10x5;
* else
* curve.FrameType = AnimCurveFrameType.Single;
*
* if (MaxValue < byte.MaxValue)
* curve.KeyType = AnimCurveKeyType.SByte;
* else if (MaxValue < ushort.MaxValue)
* curve.KeyType = AnimCurveKeyType.Int16;
* else
* curve.KeyType = AnimCurveKeyType.Single;*/
}
}
}
TexturePatternCurveIndex += matAnimData.TexturePatternAnimInfos.Where(item => item.CurveIndex != uint.MaxValue).ToList().Count;
ShaderParamCurveIndex += CurveIndex;
}
return(matAnim);
}
