static void UpdateParamInfo(BfresMaterialAnim anim, STAnimGroup paramGroup)
{
var materials = anim.GetMaterials(SelectedMaterial);
if (materials.Count > 0)
{
var mat = materials.FirstOrDefault();
if (mat.ShaderParams.ContainsKey(paramGroup.Name))
{
ParamProperty.ParamType = mat.ShaderParams[paramGroup.Name].Type;
}
}
if (paramGroup.Name.Contains("color") || paramGroup.Name.Contains("Color"))
{
isColor = true;
}
}
private void ParseAnimationTrack(STAnimGroup group, FMAT mat)
{
foreach (var track in group.GetTracks())
{
if (track is SamplerTrack)
{
ParseSamplerTrack(mat, (SamplerTrack)track);
}
if (track is ParamTrack)
{
ParseParamTrack(mat, group, (ParamTrack)track);
}
}
foreach (var subGroup in group.SubAnimGroups)
{
ParseAnimationTrack(subGroup, mat);
}
}
private NodeBase CreateGroupHierachy(FMAT material, STAnimGroup group)
{
if (group is ParamAnimGroup)
{
return(CreateParamNodeHierachy(material, (ParamAnimGroup)group));
}
var groupNode = new NodeBase(group.Name);
groupNode.Tag = group;
//Params have their own sub group for each parameter
//The X, Y, Z values being individual tracks
foreach (STAnimGroup subGroup in group.SubAnimGroups)
{
groupNode.AddChild(CreateGroupHierachy(material, subGroup));
}
var tracks = group.GetTracks();
return(groupNode);
}
private void AddGroup(TreeNodeCollection nodes, STAnimGroup group)
{
TreeNode groupNode = new TreeNode(group.Name)
{
Tag = group, ImageKey = "AnimationGroup",
};
nodes.Add(groupNode);
foreach (var subGroup in group.SubAnimGroups)
{
AddGroup(groupNode.Nodes, subGroup);
}
foreach (var track in group.GetTracks())
{
if (!track.HasKeys)
{
continue;
}
string imageKey = "AnimationTrack";
if (track.Name.EndsWith("R"))
{
imageKey = "AnimationTrackR";
}
if (track.Name.EndsWith("G"))
{
imageKey = "AnimationTrackG";
}
if (track.Name.EndsWith("B"))
{
imageKey = "AnimationTrackB";
}
if (track.Name.EndsWith("A"))
{
imageKey = "AnimationTrackA";
}
if (track.Name.EndsWith("X"))
{
imageKey = "AnimationTrackX";
}
if (track.Name.EndsWith("Y"))
{
imageKey = "AnimationTrackY";
}
if (track.Name.EndsWith("Z"))
{
imageKey = "AnimationTrackZ";
}
if (track.Name.EndsWith("W"))
{
imageKey = "AnimationTrackW";
}
TreeNode trackNode = new TreeNode(track.Name)
{
Tag = track, ImageKey = imageKey, SelectedImageKey = imageKey,
};
groupNode.Nodes.Add(trackNode);
}
}
public LytAnimGroup(BxlanPaiEntry entry)
{
animEntry = entry;
Name = entry.Name;
if (entry.Target == AnimationTarget.Material)
{
Category = "Materials";
}
else if (entry.Target == AnimationTarget.Pane)
{
Category = "Panes";
}
else
{
Category = "User Data";
}
//Generate sub groups which contain the track data
for (int i = 0; i < entry.Tags?.Count; i++)
{
STAnimGroup group = new STAnimGroup();
string tag = entry.Tags[i].Tag.Remove(0, 1);
switch (tag)
{
case "LPA":
group = new LytPaneSRTGroup(entry.Tags[i]);
break;
case "LVI":
group = new LytVisibiltyGroup(entry.Tags[i]);
break;
case "LTS":
group = new LytTextureSRTGroup(entry.Tags[i]);
break;
case "LVC":
group = new LytVertexColorGroup(entry.Tags[i]);
break;
case "LMC":
group = new LytMaterialColorGroup(entry.Tags[i]);
break;
case "LIM":
group = new LytIndirectSRTGroup(entry.Tags[i]);
break;
case "LTP":
group = new LytTexturePatternGroup(entry.Tags[i]);
break;
case "LAC":
group = new LytAlphaTestGroup(entry.Tags[i]);
break;
case "LCT":
group = new LytFontShadowGroup(entry.Tags[i]);
break;
case "LCC":
group = new LytPerCharacterTransformCurveGroup(entry.Tags[i]);
break;
}
foreach (var keyGroup in entry.Tags[i].Entries)
{
if (!(group is IAnimationTarget))
{
continue;
}
var targetGroup = ((IAnimationTarget)group).GetTrack(keyGroup.AnimationTarget);
if (targetGroup != null)
{
targetGroup.LoadKeyFrames(keyGroup.KeyFrames);
targetGroup.Name = keyGroup.TargetName;
if (keyGroup.CurveType == CurveType.Constant)
{
targetGroup.InterpolationType = STInterpoaltionType.Constant;
}
else if (keyGroup.CurveType == CurveType.Hermite)
{
targetGroup.InterpolationType = STInterpoaltionType.Hermite;
}
else if (keyGroup.CurveType == CurveType.Step)
{
targetGroup.InterpolationType = STInterpoaltionType.Step;
}
}
else
{
Console.WriteLine($"Unsupported track type for tag {keyGroup.TargetName} {keyGroup.AnimationTarget}");
}
}
group.Name = entry.Tags[i].Type;
SubAnimGroups.Add(group);
}
}
private void ParseParamTrack(FMAT material, STAnimGroup group, ParamTrack track)
{
if (!material.ShaderParams.ContainsKey(group.Name))
{
return;
}
var value = track.GetFrameValue(this.Frame);
//4 bytes per float or int value
uint index = track.ValueOffset / 4;
var targetParam = material.ShaderParams[group.Name];
var param = new ShaderParam();
if (!material.AnimatedParams.ContainsKey(group.Name))
{
if (targetParam.DataValue is float[])
{
float[] values = (float[])targetParam.DataValue;
float[] dest = new float[values.Length];
Array.Copy(values, dest, values.Length);
param.DataValue = dest;
}
else
{
param.DataValue = targetParam.DataValue;
}
param.Type = targetParam.Type;
param.Name = group.Name;
material.AnimatedParams.Add(group.Name, param);
}
param = material.AnimatedParams[group.Name];
switch (targetParam.Type)
{
case ShaderParamType.Float: param.DataValue = (float)value; break;
case ShaderParamType.Float2:
case ShaderParamType.Float3:
case ShaderParamType.Float4:
((float[])param.DataValue)[index] = value;
break;
case ShaderParamType.Int: param.DataValue = value; break;
case ShaderParamType.Int2:
case ShaderParamType.Int3:
case ShaderParamType.Int4:
((int[])param.DataValue)[index] = (int)value;
break;
case ShaderParamType.TexSrt:
case ShaderParamType.TexSrtEx:
{
TexSrtMode mode = ((TexSrt)param.DataValue).Mode;
var translateX = ((TexSrt)param.DataValue).Translation.X;
var translateY = ((TexSrt)param.DataValue).Translation.Y;
var rotate = ((TexSrt)param.DataValue).Rotation;
var scaleX = ((TexSrt)param.DataValue).Scaling.X;
var scaleY = ((TexSrt)param.DataValue).Scaling.Y;
// if (track.ValueOffset == 0) mode = (TexSrtMode)Convert.ToUInt32(value);
if (track.ValueOffset == 4)
{
scaleX = value;
}
if (track.ValueOffset == 8)
{
scaleY = value;
}
if (track.ValueOffset == 12)
{
rotate = value;
}
if (track.ValueOffset == 16)
{
translateX = value;
}
if (track.ValueOffset == 20)
{
translateY = value;
}
param.DataValue = new TexSrt()
{
Mode = mode,
Scaling = new Syroot.Maths.Vector2F(scaleX, scaleY),
Translation = new Syroot.Maths.Vector2F(translateX, translateY),
Rotation = rotate,
};
}
break;
case ShaderParamType.Srt2D:
{
var translateX = ((Srt2D)param.DataValue).Translation.X;
var translateY = ((Srt2D)param.DataValue).Translation.Y;
var rotate = ((Srt2D)param.DataValue).Rotation;
var scaleX = ((Srt2D)param.DataValue).Scaling.X;
var scaleY = ((Srt2D)param.DataValue).Scaling.Y;
if (track.ValueOffset == 0)
{
scaleX = value;
}
if (track.ValueOffset == 4)
{
scaleY = value;
}
if (track.ValueOffset == 8)
{
rotate = value;
}
if (track.ValueOffset == 12)
{
translateX = value;
}
if (track.ValueOffset == 16)
{
translateY = value;
}
param.DataValue = new Srt2D()
{
Scaling = new Syroot.Maths.Vector2F(scaleX, scaleY),
Translation = new Syroot.Maths.Vector2F(translateX, translateY),
Rotation = rotate,
};
}
break;
}
}
