337 lines
13 KiB
C#
337 lines
13 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.IO;
|
|
using System.Threading.Tasks;
|
|
using Bfres.Structs;
|
|
using SharpYaml;
|
|
using SharpYaml.Events;
|
|
using SharpYaml.Serialization;
|
|
using SharpYaml.Serialization.Serializers;
|
|
using Syroot.NintenTools.NSW.Bfres;
|
|
using System.Reflection;
|
|
using System.Text.RegularExpressions;
|
|
|
|
namespace FirstPlugin
|
|
{
|
|
public class YamlFmaa
|
|
{
|
|
public class AnimConfig
|
|
{
|
|
public string Name { get; set; }
|
|
public string Path { get; set; }
|
|
public bool Loop { get; set; }
|
|
public int FrameCount { get; set; }
|
|
|
|
public List<MatAnimConfig> MaterialAnimConfigs { get; set; }
|
|
|
|
public void ToYaml(MaterialAnim materialAnim)
|
|
{
|
|
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.BeginConstant != ushort.MaxValue;
|
|
matConfig.ParamInfos.Add(paramCfg);
|
|
|
|
if (paramInfo.BeginCurve != ushort.MaxValue)
|
|
{
|
|
var curve = mat.Curves[(int)paramInfo.BeginCurve];
|
|
for (int i = 0; i < paramInfo.IntCurveCount + paramInfo.FloatCurveCount; i++)
|
|
{
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
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)
|
|
{
|
|
|
|
}
|
|
|
|
TexturePatternCurveIndex += matAnimData.TexturePatternAnimInfos.Where(item => item.CurveIndex != uint.MaxValue).ToList().Count;
|
|
ShaderParamCurveIndex += matAnimData.ParamAnimInfos.Where(item => item.BeginCurve != ushort.MaxValue).ToList().Count;
|
|
}
|
|
|
|
return matAnim;
|
|
}
|
|
|
|
private List<string> GenerateTextureList()
|
|
{
|
|
List<string> Textures = new List<string>();
|
|
foreach (var matCfg in MaterialAnimConfigs)
|
|
{
|
|
foreach (var texturePatternCfg in matCfg.TexturePatternInfos)
|
|
{
|
|
if (texturePatternCfg.ConstantValue != null)
|
|
{
|
|
if (!Textures.Contains(texturePatternCfg.ConstantValue.Texture))
|
|
Textures.Add(texturePatternCfg.ConstantValue.Texture);
|
|
}
|
|
|
|
if (texturePatternCfg.CurveData == null)
|
|
continue;
|
|
|
|
foreach (var KeyFrame in texturePatternCfg.CurveData.KeyFrames)
|
|
if (!Textures.Contains(KeyFrame.Value))
|
|
Textures.Add(KeyFrame.Value);
|
|
}
|
|
}
|
|
|
|
return Textures;
|
|
}
|
|
}
|
|
|
|
public class ConstantTPConfig
|
|
{
|
|
public string Texture { get; set; }
|
|
}
|
|
|
|
public class CurveTPConfig
|
|
{
|
|
public Dictionary<int, string> KeyFrames { get; set; }
|
|
|
|
public CurveTPConfig()
|
|
{
|
|
KeyFrames = new Dictionary<int, string>();
|
|
}
|
|
}
|
|
|
|
public class MatAnimConfig
|
|
{
|
|
public string Name { get; set; }
|
|
|
|
public List<PatternInfo> TexturePatternInfos { get; set; }
|
|
public List<ParamInfo> ParamInfos { get; set; }
|
|
|
|
public MatAnimConfig()
|
|
{
|
|
TexturePatternInfos = new List<PatternInfo>();
|
|
ParamInfos = new List<ParamInfo>();
|
|
}
|
|
}
|
|
|
|
public class ParamInfo
|
|
{
|
|
public string Name { get; set; }
|
|
|
|
public bool IsConstant { get; set; }
|
|
|
|
public AnimCurve Curve { get; set; }
|
|
}
|
|
|
|
public class PatternInfo
|
|
{
|
|
public string Name { get; set; }
|
|
|
|
public bool IsConstant { get; set; }
|
|
|
|
public ConstantTPConfig ConstantValue { get; set; }
|
|
|
|
public CurveTPConfig CurveData { get; set; }
|
|
}
|
|
|
|
public static MaterialAnim FromYaml(string Name)
|
|
{
|
|
var serializerSettings = new SerializerSettings()
|
|
{
|
|
// EmitTags = false
|
|
};
|
|
|
|
serializerSettings.DefaultStyle = YamlStyle.Any;
|
|
serializerSettings.ComparerForKeySorting = null;
|
|
serializerSettings.RegisterTagMapping("AnimConfig", typeof(AnimConfig));
|
|
|
|
var serializer = new Serializer( serializerSettings);
|
|
AnimConfig config = serializer.Deserialize<AnimConfig>(File.ReadAllText(Name));
|
|
|
|
return config.FromYaml();
|
|
}
|
|
|
|
public static string ToYaml(string Name, MaterialAnim MatAnim)
|
|
{
|
|
var serializerSettings = new SerializerSettings()
|
|
{
|
|
// EmitTags = false
|
|
};
|
|
|
|
serializerSettings.DefaultStyle = YamlStyle.Any;
|
|
serializerSettings.ComparerForKeySorting = null;
|
|
serializerSettings.RegisterTagMapping("AnimConfig", typeof(AnimConfig));
|
|
|
|
var config = new AnimConfig();
|
|
config.ToYaml(MatAnim);
|
|
|
|
var serializer = new Serializer(serializerSettings);
|
|
string yaml = serializer.Serialize(config, typeof(AnimConfig));
|
|
|
|
return yaml;
|
|
}
|
|
|
|
private void SetConfig()
|
|
{
|
|
|
|
}
|
|
}
|
|
}
|