static string GetDataString(ShaderParam Param)
{
switch (Param.Type)
{
case ShaderParamType.Float:
case ShaderParamType.UInt:
return(Param.DataValue.ToString());
case ShaderParamType.Float2:
case ShaderParamType.Float3:
case ShaderParamType.Float4:
return(string.Join(",", (float[])Param.DataValue));
case ShaderParamType.Srt2D:
{
var texSrt = (Srt2D)Param.DataValue;
return($"{texSrt.Scaling.X} {texSrt.Scaling.Y} {texSrt.Rotation} {texSrt.Translation.X} {texSrt.Translation.Y}");
}
case ShaderParamType.TexSrt:
case ShaderParamType.TexSrtEx:
{
var texSrt = (TexSrt)Param.DataValue;
return($"{texSrt.Mode} {texSrt.Scaling.X} {texSrt.Scaling.Y} {texSrt.Rotation} {texSrt.Translation.X} {texSrt.Translation.Y}");
}
default:
return(Param.DataValue.ToString());
}
}
public static byte[] WriteShaderParams(this FMAT m, Material mat)
{
mat.ShaderParams = new List <ShaderParam>();
System.IO.MemoryStream mem = new System.IO.MemoryStream();
using (FileWriter writer = new FileWriter(mem))
{
uint Offset = 0;
int index = 0;
writer.ByteOrder = Syroot.BinaryData.ByteOrder.LittleEndian;
foreach (BfresShaderParam shaderParam in m.matparam.Values)
{
ShaderParam param = new ShaderParam();
param.Name = shaderParam.Name;
param.Type = shaderParam.Type;
param.DataOffset = (ushort)Offset;
param.DependedIndex = (ushort)index;
param.DependIndex = (ushort)index;
writer.Seek(param.DataOffset, System.IO.SeekOrigin.Begin);
shaderParam.WriteValue(writer);
Offset += param.DataSize;
mat.ShaderParams.Add(param);
index++;
}
writer.Close();
}
return(mem.ToArray());
}
public static byte[] WriteShaderParams(this FMAT m, Material mat)
{
mat.ShaderParams = new ResDict <ShaderParam>();
System.IO.MemoryStream mem = new System.IO.MemoryStream();
using (FileWriter writer = new FileWriter(mem))
{
uint Offset = 0;
int index = 0;
writer.ByteOrder = Syroot.BinaryData.ByteOrder.BigEndian;
foreach (BfresShaderParam shaderParam in m.matparam.Values)
{
ShaderParam param = new ShaderParam();
param.Name = shaderParam.Name;
param.Type = shaderParam.SetTypeWiiU(shaderParam.Type);
param.DataOffset = (ushort)Offset;
param.offset = -1;
param.callbackPointer = 0;
param.PaddingLength = shaderParam.PaddingLength;
param.DependedIndex = (ushort)index;
param.DependIndex = (ushort)index;
writer.Seek(param.DataOffset, System.IO.SeekOrigin.Begin);
shaderParam.WriteValue(writer);
Offset += (param.DataSize + (uint)shaderParam.PaddingLength);
mat.ShaderParams.Add(param.Name, param);
index++;
}
writer.Close();
}
return(mem.ToArray());
}
private void ReadShaderParams(Material mat, Mesh poly)
{
using (Syroot.BinaryData.BinaryDataReader reader = new Syroot.BinaryData.BinaryDataReader(new MemoryStream(mat.ShaderParamData)))
{
reader.ByteOrder = Syroot.BinaryData.ByteOrder.LittleEndian;
foreach (Syroot.NintenTools.NSW.Bfres.ShaderParam param in mat.ShaderParams)
{
ShaderParam prm = new ShaderParam();
prm.Type = (Syroot.NintenTools.Bfres.ShaderParamType)param.Type;
switch (param.Type)
{
case ShaderParamType.Float:
reader.Seek(param.DataOffset, SeekOrigin.Begin);
prm.Value_float = reader.ReadSingle();
break;
case ShaderParamType.Float2:
reader.Seek(param.DataOffset, SeekOrigin.Begin);
prm.Value_float2 = new Vector2(
reader.ReadSingle(),
reader.ReadSingle());
break;
case ShaderParamType.Float3:
reader.Seek(param.DataOffset, SeekOrigin.Begin);
prm.Value_float3 = new Vector3(
reader.ReadSingle(),
reader.ReadSingle(),
reader.ReadSingle()); break;
case ShaderParamType.Float4:
reader.Seek(param.DataOffset, SeekOrigin.Begin);
prm.Value_float4 = new Vector4(
reader.ReadSingle(),
reader.ReadSingle(),
reader.ReadSingle(),
reader.ReadSingle()); break;
}
poly.material.matparam.Add(param.Name, prm);
}
reader.Close();
}
}
private static void ReadAttributes(XmlNode materialNode, MaterialData material)
{
ShaderParam shaderParam = new ShaderParam();
foreach (XmlAttribute attribute in materialNode.Attributes)
{
char[] RemoveThese = new char[] { ' ', '(', ')' };
string valueFix = string.Join("", attribute.Value.Split(RemoveThese));
switch (attribute.Name)
{
case "Name":
shaderParam.Name = attribute.Value;
break;
case "ValueFloat":
float.TryParse(attribute.Value, out shaderParam.Value_float);
break;
case "ValueFloat2":
float[] f2Array = Array.ConvertAll(valueFix.Split(','), float.Parse);
shaderParam.Value_float2 = new OpenTK.Vector2(f2Array[0], f2Array[1]);
break;
case "ValueFloat3":
float[] f3Array = Array.ConvertAll(valueFix.Split(','), float.Parse);
shaderParam.Value_float3 = new OpenTK.Vector3(f3Array[0], f3Array[1], f3Array[2]);
break;
case "ValueTexSrt":
float[] srt = Array.ConvertAll(valueFix.Split(','), float.Parse);
// shaderParam.Value_TexSrt.scale = new OpenTK.Vector2(srt[0], srt[1]);
// shaderParam.Value_TexSrt.rotate = srt[2];
// shaderParam.Value_TexSrt.translate = new OpenTK.Vector2(srt[3], srt[4]);
break;
}
}
if (shaderParam.Name != "")
{
material.matparam.Add(shaderParam.Name, shaderParam);
}
}
private void ReadShaderParams(Material mat, Mesh poly)
{
using (Syroot.BinaryData.BinaryDataReader reader = new Syroot.BinaryData.BinaryDataReader(new MemoryStream(mat.ShaderParamData)))
{
reader.ByteOrder = Syroot.BinaryData.ByteOrder.LittleEndian;
foreach (Syroot.NintenTools.NSW.Bfres.ShaderParam param in mat.ShaderParams)
{
ShaderParam prm = new ShaderParam();
prm.Type = (Syroot.NintenTools.Bfres.ShaderParamType)param.Type;
prm.Name = param.Name;
switch (param.Type)
{
case ShaderParamType.Float:
reader.Seek(param.DataOffset, SeekOrigin.Begin);
prm.Value_float = reader.ReadSingle();
break;
case ShaderParamType.Float2:
reader.Seek(param.DataOffset, SeekOrigin.Begin);
prm.Value_float2 = new Vector2(
reader.ReadSingle(),
reader.ReadSingle());
break;
case ShaderParamType.Float3:
reader.Seek(param.DataOffset, SeekOrigin.Begin);
prm.Value_float3 = new Vector3(
reader.ReadSingle(),
reader.ReadSingle(),
reader.ReadSingle()); break;
case ShaderParamType.Float4:
reader.Seek(param.DataOffset, SeekOrigin.Begin);
prm.Value_float4 = new Vector4(
reader.ReadSingle(),
reader.ReadSingle(),
reader.ReadSingle(),
reader.ReadSingle()); break;
case ShaderParamType.TexSrt:
reader.Seek(param.DataOffset, SeekOrigin.Begin);
ShaderParam.TextureSRT texSRT = new ShaderParam.TextureSRT();
texSRT.Mode = reader.ReadSingle(); //Scale mode, Maya, max ect
texSRT.scale = new Vector2(reader.ReadSingle(), reader.ReadSingle());
texSRT.rotate = reader.ReadSingle();
texSRT.translate = new Vector2(reader.ReadSingle(), reader.ReadSingle());
prm.Value_TexSrt = texSRT;
break;
case ShaderParamType.UInt:
prm.Value_UInt = reader.ReadUInt32();
break;
case ShaderParamType.Bool:
prm.Value_Bool = reader.ReadBoolean();
break;
case ShaderParamType.Float4x4:
prm.Value_float4x4 = reader.ReadSingles(16);
break;
}
poly.material.matparam.Add(param.Name, prm);
}
reader.Close();
}
}
private static string GenerateFloat2Initialisation(ShaderParam shaderParam)
{
if (string.IsNullOrEmpty(shaderParam.DefaultValue))
return "";
var values = shaderParam.DefaultValue.Replace(" ", "").Split(',').Select(v => v +"f");
var value = "new Vector2(" + string.Join(", ", values) + ");";
var line = GetPropertyName(shaderParam) + " = " + value;
return line;
}
private static ShaderParam CreateParam(string name, string[] lines, int index, ShaderParamType type)
{
var exitCondition = new Func<string, int, bool>((line, i) => line == "" || i < 0);
var param = new ShaderParam
{
Name = name,
Summary = GetValue("summary", lines, index, -1, exitCondition),
MinValue = GetValue("minValue", lines, index, -1, exitCondition),
MaxValue = GetValue("maxValue", lines, index, -1, exitCondition),
DefaultValue = GetValue("defaultValue", lines, index, -1, exitCondition),
Type = type
};
return param;
}
private static string GetPropertyName(ShaderParam shaderParam)
{
return shaderParam.Name.Substring(0, 1).ToUpper() + shaderParam.Name.Substring(1);
}
private static IEnumerable<string> GenerateTextureProperty(ShaderParam shaderParam)
{
return GenerateProperty(shaderParam, "Texture2D", "GetValueTexture2D");
}
private static string GenerateTextureInitialisation(ShaderParam shaderParam)
{
if (string.IsNullOrEmpty(shaderParam.DefaultValue))
return "";
var values = GetColor(shaderParam.DefaultValue);
var value = "new Texture2D(" + string.Join(", ", values) + ");";
var line = GetPropertyName(shaderParam) + " = " + value;
return line;
}
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;
}
}
public void Read(ResFile TargetWiiUBFRES)
{
Nodes.Add(TModels);
Nodes.Add(TTextures);
Nodes.Add(TShaderparam);
Nodes.Add(TColoranim);
Nodes.Add(TTextureSRT);
Nodes.Add(TTexturePat);
Nodes.Add(TBonevisabilty);
Nodes.Add(TVisualAnim);
Nodes.Add(TShapeAnim);
Nodes.Add(TSceneAnim);
Nodes.Add(TEmbedded);
ImageKey = "bfres";
SelectedImageKey = "bfres";
FSKACount = TargetWiiUBFRES.SkeletalAnims.Count;
textures.Clear();
foreach (Texture tex in TargetWiiUBFRES.Textures.Values)
{
string TextureName = tex.Name;
FTEX texture = new FTEX();
texture.ReadFTEX(tex);
textures.Add(TextureName, texture);
TTextures.Nodes.Add(texture);
}
int ModelCur = 0;
//FMDLs -Models-
foreach (Model mdl in TargetWiiUBFRES.Models.Values)
{
FMDL_Model model = new FMDL_Model(); //This will store VBN data and stuff
model.Text = mdl.Name;
TModels.Nodes.Add(model);
model.Node_Array = new int[mdl.Skeleton.MatrixToBoneList.Count];
int nodes = 0;
foreach (ushort node in mdl.Skeleton.MatrixToBoneList)
{
model.Node_Array[nodes] = node;
nodes++;
}
foreach (Syroot.NintenTools.Bfres.Bone bn in mdl.Skeleton.Bones.Values)
{
Bone bone = new Bone(model.skeleton);
bone.Text = bn.Name;
bone.boneId = bn.BillboardIndex;
bone.parentIndex = bn.ParentIndex;
bone.scale = new float[3];
bone.rotation = new float[4];
bone.position = new float[3];
if (bn.FlagsRotation == BoneFlagsRotation.Quaternion)
{
bone.boneRotationType = 1;
}
else
{
bone.boneRotationType = 0;
}
bone.scale[0] = bn.Scale.X;
bone.scale[1] = bn.Scale.Y;
bone.scale[2] = bn.Scale.Z;
bone.rotation[0] = bn.Rotation.X;
bone.rotation[1] = bn.Rotation.Y;
bone.rotation[2] = bn.Rotation.Z;
bone.rotation[3] = bn.Rotation.W;
bone.position[0] = bn.Position.X;
bone.position[1] = bn.Position.Y;
bone.position[2] = bn.Position.Z;
model.skeleton.bones.Add(bone);
}
model.skeleton.reset();
model.skeleton.update();
//MeshTime!!
int ShapeCur = 0;
foreach (Shape shp in mdl.Shapes.Values)
{
Mesh poly = new Mesh();
poly.Text = shp.Name;
poly.MaterialIndex = shp.MaterialIndex;
poly.matrFlag = shp.VertexSkinCount;
poly.fsklindx = shp.BoneIndex;
TModels.Nodes[ModelCur].Nodes.Add(poly);
//Create a buffer instance which stores all the buffer data
VertexBufferHelper helper = new VertexBufferHelper(mdl.VertexBuffers[shp.VertexBufferIndex], TargetWiiUBFRES.ByteOrder);
// VertexBufferHelperAttrib uv1 = helper["_u1"];
Vertex v = new Vertex();
foreach (VertexAttrib att in mdl.VertexBuffers[shp.VertexBufferIndex].Attributes.Values)
{
if (att.Name == "_p0")
{
Console.WriteLine(att.Name);
VertexBufferHelperAttrib position = helper["_p0"];
Syroot.Maths.Vector4F[] vec4Positions = position.Data;
foreach (Syroot.Maths.Vector4F p in vec4Positions)
{
v.pos.Add(new Vector3 {
X = p.X, Y = p.Y, Z = p.Z
});
}
}
if (att.Name == "_n0")
{
Console.WriteLine(att.Name);
VertexBufferHelperAttrib normal = helper["_n0"];
Syroot.Maths.Vector4F[] vec4Normals = normal.Data;
foreach (Syroot.Maths.Vector4F n in vec4Normals)
{
v.nrm.Add(new Vector3 {
X = n.X, Y = n.Y, Z = n.Z
});
}
}
if (att.Name == "_u0")
{
Console.WriteLine(att.Name);
VertexBufferHelperAttrib uv0 = helper["_u0"];
Syroot.Maths.Vector4F[] vec4uv0 = uv0.Data;
foreach (Syroot.Maths.Vector4F u in vec4uv0)
{
v.uv0.Add(new Vector2 {
X = u.X, Y = u.Y
});
}
}
if (att.Name == "_u1")
{
Console.WriteLine(att.Name);
VertexBufferHelperAttrib uv1 = helper["_u1"];
Syroot.Maths.Vector4F[] vec4uv1 = uv1.Data;
foreach (Syroot.Maths.Vector4F u in vec4uv1)
{
v.uv1.Add(new Vector2 {
X = u.X, Y = u.Y
});
}
}
if (att.Name == "_u2")
{
Console.WriteLine(att.Name);
VertexBufferHelperAttrib uv2 = helper["_u2"];
Syroot.Maths.Vector4F[] vec4uv2 = uv2.Data;
foreach (Syroot.Maths.Vector4F u in vec4uv2)
{
v.uv2.Add(new Vector2 {
X = u.X, Y = u.Y
});
}
}
if (att.Name == "_c0")
{
Console.WriteLine(att.Name);
VertexBufferHelperAttrib c0 = helper["_c0"];
Syroot.Maths.Vector4F[] vec4c0 = c0.Data;
foreach (Syroot.Maths.Vector4F c in vec4c0)
{
v.col.Add(new Vector4 {
X = c.X, Y = c.Y, Z = c.Z, W = c.W
});
}
}
if (att.Name == "_t0")
{
Console.WriteLine(att.Name);
VertexBufferHelperAttrib t0 = helper["_t0"];
Syroot.Maths.Vector4F[] vec4t0 = t0.Data;
foreach (Syroot.Maths.Vector4F u in vec4t0)
{
v.tans.Add(new Vector4 {
X = u.X, Y = u.Y, Z = u.Z, W = u.W
});
}
}
if (att.Name == "_b0")
{
Console.WriteLine(att.Name);
VertexBufferHelperAttrib b0 = helper["_b0"];
Syroot.Maths.Vector4F[] vec4b0 = b0.Data;
foreach (Syroot.Maths.Vector4F u in vec4b0)
{
v.bitans.Add(new Vector4 {
X = u.X, Y = u.Y, Z = u.Z, W = u.W
});
}
}
if (att.Name == "_w0")
{
Console.WriteLine(att.Name);
VertexBufferHelperAttrib w0 = helper["_w0"];
Syroot.Maths.Vector4F[] vec4w0 = w0.Data;
foreach (Syroot.Maths.Vector4F w in vec4w0)
{
v.weights.Add(new Vector4 {
X = w.X, Y = w.Y, Z = w.Z, W = w.W
});
}
}
if (att.Name == "_i0")
{
Console.WriteLine(att.Name);
VertexBufferHelperAttrib i0 = helper["_i0"];
Syroot.Maths.Vector4F[] vec4i0 = i0.Data;
foreach (Syroot.Maths.Vector4F i in vec4i0)
{
v.nodes.Add(new Vector4 {
X = i.X, Y = i.Y, Z = i.Z, W = i.W
});
}
}
}
poly.vertices = v;
//shp.Meshes.Count - 1 //For going to the lowest poly LOD mesh
int LODCount = 0;
uint FaceCount = FaceCount = shp.Meshes[LODCount].IndexCount;
uint[] indicesArray = shp.Meshes[LODCount].GetIndices().ToArray();
poly.BoundingCount = shp.SubMeshBoundings.Count;
for (int face = 0; face < FaceCount; face++)
{
poly.faces.Add((int)indicesArray[face] + (int)shp.Meshes[LODCount].FirstVertex);
}
int AlbedoCount = 0;
string TextureName = "";
int id = 0;
foreach (TextureRef tex in mdl.Materials[shp.MaterialIndex].TextureRefs)
{
TextureName = tex.Name;
MatTexture texture = new MatTexture();
poly.Nodes.Add(new TreeNode {
Text = TextureName
});
if (mdl.Materials[shp.MaterialIndex].Samplers[id].Name == "_a0")
{
if (AlbedoCount == 0)
{
try
{
poly.texHashs.Add(textures[TextureName].texture.display);
AlbedoCount++;
}
catch
{
poly.texHashs.Add(0);
}
poly.TextureMapTypes.Add("Diffuse");
}
}
if (mdl.Materials[shp.MaterialIndex].Samplers[id].Name == "_a1")
{
try
{
poly.texHashs.Add(textures[TextureName].texture.display);
AlbedoCount++;
}
catch
{
poly.texHashs.Add(0);
}
poly.TextureMapTypes.Add("Diffuse_Layer");
}
if (mdl.Materials[shp.MaterialIndex].Samplers[id].Name == "_n0")
{
try
{
poly.texHashs.Add(textures[TextureName].texture.display);
}
catch
{
poly.texHashs.Add(1);
}
poly.material.HasNormalMap = true;
poly.TextureMapTypes.Add("Normal");
}
if (mdl.Materials[shp.MaterialIndex].Samplers[id].Name == "_b0")
{
try
{
poly.texHashs.Add(textures[TextureName].texture.display);
}
catch
{
poly.texHashs.Add(2);
}
poly.TextureMapTypes.Add("Bake1");
}
if (mdl.Materials[shp.MaterialIndex].Samplers[id].Name == "_b1")
{
try
{
poly.texHashs.Add(textures[TextureName].texture.display);
}
catch
{
poly.texHashs.Add(3);
}
poly.TextureMapTypes.Add("Bake2");
}
id++;
texture.Name = TextureName;
}
poly.material.Name = mdl.Materials[shp.MaterialIndex].Name;
foreach (Sampler smp in mdl.Materials[shp.MaterialIndex].Samplers.Values)
{
SamplerInfo s = new SamplerInfo();
s.WrapModeU = (int)smp.TexSampler.ClampX;
s.WrapModeV = (int)smp.TexSampler.ClampY;
s.WrapModeW = (int)smp.TexSampler.ClampZ;
poly.material.samplerinfo.Add(s);
}
using (Syroot.BinaryData.BinaryDataReader reader = new Syroot.BinaryData.BinaryDataReader(new MemoryStream(mdl.Materials[shp.MaterialIndex].ShaderParamData)))
{
reader.ByteOrder = Syroot.BinaryData.ByteOrder.BigEndian;
foreach (Syroot.NintenTools.Bfres.ShaderParam param in mdl.Materials[shp.MaterialIndex].ShaderParams.Values)
{
ShaderParam prm = new ShaderParam();
prm.Type = param.Type;
switch (param.Type)
{
case ShaderParamType.Float:
reader.Seek(param.DataOffset, SeekOrigin.Begin);
prm.Value_float = reader.ReadSingle();
break;
case ShaderParamType.Float2:
reader.Seek(param.DataOffset, SeekOrigin.Begin);
prm.Value_float2 = new Vector2(
reader.ReadSingle(),
reader.ReadSingle());
break;
case ShaderParamType.Float3:
reader.Seek(param.DataOffset, SeekOrigin.Begin);
prm.Value_float3 = new Vector3(
reader.ReadSingle(),
reader.ReadSingle(),
reader.ReadSingle()); break;
case ShaderParamType.Float4:
reader.Seek(param.DataOffset, SeekOrigin.Begin);
prm.Value_float4 = new Vector4(
reader.ReadSingle(),
reader.ReadSingle(),
reader.ReadSingle(),
reader.ReadSingle()); break;
}
poly.material.matparam.Add(param.Name, prm);
}
reader.Close();
}
model.poly.Add(poly);
ShapeCur++;
}
models.Add(model);
ModelCur++;
}
}
public static List <MeshMetaInfo> FromJson(Material mat, string json)
{
JsonConvert.DefaultSettings = () =>
{
var settings = new JsonSerializerSettings();
return(settings);
};
var matJson = JsonConvert.DeserializeObject <MaterialStruct>(json);
mat.Name = matJson.Name;
mat.Visible = matJson.Visible;
mat.ShaderAssign = ConvertShaderAssign(matJson.ShaderAssign);
mat.TextureRefs = new List <TextureRef>();
mat.Samplers = new ResDict <Sampler>();
mat.ShaderParams = new ResDict <ShaderParam>();
mat.UserData = new ResDict <UserData>();
mat.RenderInfos = new ResDict <RenderInfo>();
mat.ShaderParamData = new byte[0];
mat.VolatileFlags = new byte[0];
if (matJson.RenderState != null)
{
mat.RenderState = matJson.RenderState;
}
foreach (var tex in matJson.Textures)
{
mat.TextureRefs.Add(new TextureRef()
{
Name = tex
});
}
foreach (var sampler in matJson.Samplers)
{
mat.Samplers.Add(sampler.Name, sampler);
}
mat.TextureSlotArray = new long[matJson.Textures.Count];
mat.SamplerSlotArray = new long[matJson.Textures.Count];
mat.VolatileFlags = matJson.VolatileFlags;
foreach (var param in matJson.Parameters)
{
string type = param.Key.Split('|')[0];
string name = param.Key.Split('|')[1];
ShaderParam shaderParam = new ShaderParam();
shaderParam.Name = name;
var dataType = (ShaderParamType)Enum.Parse(typeof(ShaderParamType), type);
object value = null;
switch (dataType)
{
case ShaderParamType.Float:
value = Convert.ToSingle(param.Value);
break;
case ShaderParamType.UInt:
value = Convert.ToUInt32(param.Value);
break;
case ShaderParamType.Int:
value = Convert.ToInt32(param.Value);
break;
case ShaderParamType.Bool:
value = Convert.ToBoolean(param.Value);
break;
case ShaderParamType.Srt2D:
value = ((JObject)param.Value).ToObject <Srt2D>();
break;
case ShaderParamType.Srt3D:
value = ((JObject)param.Value).ToObject <Srt3D>();
break;
case ShaderParamType.TexSrt:
value = ((JObject)param.Value).ToObject <TexSrt>();
break;
case ShaderParamType.TexSrtEx:
value = ((JObject)param.Value).ToObject <TexSrt>();
break;
case ShaderParamType.Float2:
case ShaderParamType.Float2x2:
case ShaderParamType.Float2x3:
case ShaderParamType.Float2x4:
case ShaderParamType.Float3:
case ShaderParamType.Float3x2:
case ShaderParamType.Float3x3:
case ShaderParamType.Float3x4:
case ShaderParamType.Float4:
case ShaderParamType.Float4x2:
case ShaderParamType.Float4x3:
case ShaderParamType.Float4x4:
value = ((JArray)param.Value).ToObject <float[]>();
break;
case ShaderParamType.Bool2:
case ShaderParamType.Bool3:
case ShaderParamType.Bool4:
value = ((JArray)param.Value).ToObject <bool>();
break;
case ShaderParamType.Int2:
case ShaderParamType.Int3:
case ShaderParamType.Int4:
value = ((JArray)param.Value).ToObject <int[]>();
break;
case ShaderParamType.UInt2:
case ShaderParamType.UInt3:
case ShaderParamType.UInt4:
value = ((JArray)param.Value).ToObject <uint[]>();
break;
default:
throw new Exception($"Unsupported parameter type! {type}");
}
mat.SetShaderParameter(name, dataType, value);
}
foreach (var param in matJson.RenderInfo)
{
string type = param.Key.Split('|')[0];
string name = param.Key.Split('|')[1];
RenderInfoType dataType = (RenderInfoType)Enum.Parse(typeof(RenderInfoType), type);
if (dataType == RenderInfoType.Single)
{
mat.SetRenderInfo(name, ((JArray)param.Value).ToObject <float[]>());
}
if (dataType == RenderInfoType.Int32)
{
mat.SetRenderInfo(name, ((JArray)param.Value).ToObject <int[]>());
}
if (dataType == RenderInfoType.String)
{
mat.SetRenderInfo(name, ((JArray)param.Value).ToObject <string[]>());
}
}
mat.UserData = UserDataConvert.Convert(matJson.UserData);
return(matJson.MeshInfo);
}
private static IEnumerable<string> GenerateFloat4Property(ShaderParam shaderParam)
{
return GenerateProperty(shaderParam, "Vector4", "GetValueVector4");
}
public static void WriteMaterialXML(MaterialData mat, Mesh msh)
{
SaveFileDialog sfd = new SaveFileDialog();
sfd.Filter = "XML|*.xml|All files(*.*)|*.*";
sfd.FileName = mat.Name;
//Todo. Redo this using XmlDocument and organise better
if (sfd.ShowDialog() == DialogResult.OK)
{
XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = true;
XmlWriter writer = XmlWriter.Create(sfd.FileName, settings);
writer.WriteStartDocument();
writer.WriteStartElement("Materials");
writer.WriteStartElement("SamplerArray");
int s = 0;
foreach (var tex in mat.textures)
{
writer.WriteStartElement("Sampler");
writer.WriteAttributeString("Name", mat.Samplers.Keys.ElementAt(s));
writer.WriteAttributeString("Texture_Name", tex.Name);
writer.WriteAttributeString("Index", s.ToString());
writer.WriteStartElement("WrapMode");
writer.WriteAttributeString("U", wrapmode[mat.samplerinfo[s].WrapModeU].ToString());
writer.WriteAttributeString("V", wrapmode[mat.samplerinfo[s].WrapModeV].ToString());
writer.WriteAttributeString("W", wrapmode[mat.samplerinfo[s].WrapModeW].ToString());
writer.WriteEndElement();
writer.WriteEndElement();
s++;
}
writer.WriteEndElement();
writer.WriteStartElement("Sampler");
foreach (var smp in mat.Samplers)
{
writer.WriteStartElement("SamplerInfo");
writer.WriteString(smp.Key);
writer.WriteEndElement();
}
writer.WriteEndElement();
writer.WriteStartElement("RenderInfo");
int p = 0;
foreach (var rnd in mat.renderinfo)
{
writer.WriteStartElement("Info");
writer.WriteAttributeString("Index", p.ToString());
switch (rnd.Type)
{
case RenderInfoType.String:
foreach (string item in rnd.Value_Strings)
{
writer.WriteAttributeString(rnd.Name, item);
}
break;
case RenderInfoType.Int32:
foreach (int item in rnd.Value_Ints)
{
writer.WriteAttributeString(rnd.Name, item.ToString());
}
break;
case RenderInfoType.Single:
foreach (float item in rnd.Value_Floats)
{
writer.WriteAttributeString(rnd.Name, item.ToString());
}
break;
}
writer.WriteEndElement();
p++;
}
writer.WriteEndElement();
writer.WriteStartElement("ShaderAssign");
writer.WriteAttributeString("ShaderFile", mat.shaderassign.ShaderModel);
p = 0;
foreach (var op in mat.shaderassign.options)
{
writer.WriteStartElement("Option");
writer.WriteAttributeString("Index", p.ToString());
writer.WriteAttributeString(op.Key, op.Value);
writer.WriteEndElement();
p++;
}
foreach (var smp in mat.shaderassign.samplers)
{
writer.WriteStartElement("SamplersFragmentShader");
writer.WriteAttributeString(smp.Key, smp.Value);
writer.WriteEndElement();
}
foreach (var att in mat.shaderassign.attributes)
{
writer.WriteStartElement("AttributesVertexShader");
writer.WriteAttributeString(att.Key, att.Value);
writer.WriteEndElement();
}
writer.WriteEndElement();
p = 0;
writer.WriteStartElement("ShaderParam");
foreach (var prm in mat.matparam)
{
ShaderParam param = prm.Value;
writer.WriteStartElement("ShaderParam");
writer.WriteAttributeString("Name", param.Name);
string value = "Value" + param.Type.ToString();
switch (param.Type)
{
case ShaderParamType.UInt:
writer.WriteAttributeString(value, param.Value_UInt.ToString());
break;
case ShaderParamType.Float:
writer.WriteAttributeString(value, param.Value_float.ToString());
break;
case ShaderParamType.Float2:
writer.WriteAttributeString(value, param.Value_float2.ToString());
break;
case ShaderParamType.Float3:
writer.WriteAttributeString(value, param.Value_float3.ToString());
break;
case ShaderParamType.Float4:
writer.WriteAttributeString(value, param.Value_float4.ToString());
break;
case ShaderParamType.TexSrt:
writer.WriteAttributeString(value, param.Value_TexSrt.scale.ToString() +
", (" + param.Value_TexSrt.rotate.ToString() +
"), " + param.Value_TexSrt.translate.ToString());
break;
case ShaderParamType.Bool:
writer.WriteAttributeString(value, param.Value_bool.ToString());
break;
case ShaderParamType.Float2x2:
writer.WriteAttributeString(value, FloatArrayToString(param.Value_float2x2));
break;
case ShaderParamType.Float2x3:
writer.WriteAttributeString(value, FloatArrayToString(param.Value_float2x3));
break;
case ShaderParamType.Float4x4:
writer.WriteAttributeString(value + param.Type.ToString(), FloatArrayToString(param.Value_float4x4));
break;
default:
MessageBox.Show("Cannot save undefined param type " + param.Type.ToString());
writer.WriteAttributeString(value, "Undefined");
break;
}
writer.WriteEndElement();
p++;
}
writer.WriteEndElement();
writer.WriteEndDocument();
writer.Close();
}
}
public void Read(ResFile TargetWiiUBFRES)
{
Nodes.Add(TModels);
Nodes.Add(TTextures);
Nodes.Add(TShaderparam);
Nodes.Add(TColoranim);
Nodes.Add(TTextureSRT);
Nodes.Add(TTexturePat);
Nodes.Add(TBonevisabilty);
Nodes.Add(TVisualAnim);
Nodes.Add(TShapeAnim);
Nodes.Add(TSceneAnim);
Nodes.Add(TEmbedded);
ImageKey = "bfres";
SelectedImageKey = "bfres";
FSKACount = TargetWiiUBFRES.SkeletalAnims.Count;
FTXPCount = TargetWiiUBFRES.TexPatternAnims.Count;
FSHUCount = TargetWiiUBFRES.ColorAnims.Count + TargetWiiUBFRES.TexSrtAnims.Count + TargetWiiUBFRES.ShaderParamAnims.Count;
AnimationCountTotal = FSKACount + FTXPCount + FSHUCount;
FTEXContainer = new FTEXContainer();
foreach (Texture tex in TargetWiiUBFRES.Textures.Values)
{
string TextureName = tex.Name;
FTEX texture = new FTEX();
texture.ReadFTEX(tex);
TTextures.Nodes.Add(texture);
FTEXContainer.FTEXtextures.Add(texture.Text, texture);
Runtime.FTEXContainerList.Add(FTEXContainer);
}
int ModelCur = 0;
//FMDLs -Models-
foreach (Model mdl in TargetWiiUBFRES.Models.Values)
{
FMDL_Model model = new FMDL_Model(); //This will store VBN data and stuff
model.Text = mdl.Name;
TModels.Nodes.Add(model);
model.Node_Array = new int[mdl.Skeleton.MatrixToBoneList.Count];
int nodes = 0;
foreach (ushort node in mdl.Skeleton.MatrixToBoneList)
{
model.Node_Array[nodes] = node;
nodes++;
}
foreach (Syroot.NintenTools.Bfres.Bone bn in mdl.Skeleton.Bones.Values)
{
Bone bone = new Bone(model.skeleton);
bone.Text = bn.Name;
bone.boneId = bn.BillboardIndex;
bone.parentIndex = bn.ParentIndex;
bone.scale = new float[3];
bone.rotation = new float[4];
bone.position = new float[3];
if (bn.FlagsRotation == BoneFlagsRotation.Quaternion)
{
bone.boneRotationType = 1;
}
else
{
bone.boneRotationType = 0;
}
bone.scale[0] = bn.Scale.X;
bone.scale[1] = bn.Scale.Y;
bone.scale[2] = bn.Scale.Z;
bone.rotation[0] = bn.Rotation.X;
bone.rotation[1] = bn.Rotation.Y;
bone.rotation[2] = bn.Rotation.Z;
bone.rotation[3] = bn.Rotation.W;
bone.position[0] = bn.Position.X;
bone.position[1] = bn.Position.Y;
bone.position[2] = bn.Position.Z;
model.skeleton.bones.Add(bone);
}
model.skeleton.reset();
model.skeleton.update();
//MeshTime!!
int ShapeCur = 0;
foreach (Shape shp in mdl.Shapes.Values)
{
Mesh poly = new Mesh();
poly.Text = shp.Name;
poly.MaterialIndex = shp.MaterialIndex;
poly.VertexSkinCount = shp.VertexSkinCount;
poly.boneIndx = shp.BoneIndex;
poly.fmdlIndx = ModelCur;
foreach (int bn in shp.SkinBoneIndices)
{
if (!poly.BoneIndexList.ContainsKey(model.skeleton.bones[bn].Text))
{
poly.BoneIndexList.Add(model.skeleton.bones[bn].Text, bn);
}
}
TModels.Nodes[ModelCur].Nodes.Add(poly);
//Create a buffer instance which stores all the buffer data
VertexBufferHelper helper = new VertexBufferHelper(mdl.VertexBuffers[shp.VertexBufferIndex], TargetWiiUBFRES.ByteOrder);
//Set each array first from the lib if exist. Then add the data all in one loop
Syroot.Maths.Vector4F[] vec4Positions = new Syroot.Maths.Vector4F[0];
Syroot.Maths.Vector4F[] vec4Normals = new Syroot.Maths.Vector4F[0];
Syroot.Maths.Vector4F[] vec4uv0 = new Syroot.Maths.Vector4F[0];
Syroot.Maths.Vector4F[] vec4uv1 = new Syroot.Maths.Vector4F[0];
Syroot.Maths.Vector4F[] vec4uv2 = new Syroot.Maths.Vector4F[0];
Syroot.Maths.Vector4F[] vec4c0 = new Syroot.Maths.Vector4F[0];
Syroot.Maths.Vector4F[] vec4t0 = new Syroot.Maths.Vector4F[0];
Syroot.Maths.Vector4F[] vec4b0 = new Syroot.Maths.Vector4F[0];
Syroot.Maths.Vector4F[] vec4w0 = new Syroot.Maths.Vector4F[0];
Syroot.Maths.Vector4F[] vec4i0 = new Syroot.Maths.Vector4F[0];
foreach (VertexAttrib att in mdl.VertexBuffers[shp.VertexBufferIndex].Attributes.Values)
{
Mesh.VertexAttribute attr = new Mesh.VertexAttribute();
attr.Name = att.Name;
// attr.Format = att.Format;
if (att.Name == "_p0")
{
vec4Positions = WiiUAttributeData(att, helper, "_p0");
}
if (att.Name == "_n0")
{
vec4Normals = WiiUAttributeData(att, helper, "_n0");
}
if (att.Name == "_u0")
{
vec4uv0 = WiiUAttributeData(att, helper, "_u0");
}
if (att.Name == "_u1")
{
vec4uv1 = WiiUAttributeData(att, helper, "_u1");
}
if (att.Name == "_u2")
{
vec4uv2 = WiiUAttributeData(att, helper, "_u2");
}
if (att.Name == "_c0")
{
vec4c0 = WiiUAttributeData(att, helper, "_c0");
}
if (att.Name == "_t0")
{
vec4t0 = WiiUAttributeData(att, helper, "_t0");
}
if (att.Name == "_b0")
{
vec4b0 = WiiUAttributeData(att, helper, "_b0");
}
if (att.Name == "_w0")
{
vec4w0 = WiiUAttributeData(att, helper, "_w0");
}
if (att.Name == "_i0")
{
vec4i0 = WiiUAttributeData(att, helper, "_i0");
}
poly.vertexAttributes.Add(attr);
}
for (int i = 0; i < vec4Positions.Length; i++)
{
Vertex v = new Vertex();
if (vec4Positions.Length > 0)
{
v.pos = new Vector3(vec4Positions[i].X, vec4Positions[i].Y, vec4Positions[i].Z);
}
if (vec4Normals.Length > 0)
{
v.nrm = new Vector3(vec4Normals[i].X, vec4Normals[i].Y, vec4Normals[i].Z);
}
if (vec4uv0.Length > 0)
{
v.uv0 = new Vector2(vec4uv0[i].X, vec4uv0[i].Y);
}
if (vec4uv1.Length > 0)
{
v.uv1 = new Vector2(vec4uv1[i].X, vec4uv1[i].Y);
}
if (vec4uv2.Length > 0)
{
v.uv2 = new Vector2(vec4uv2[i].X, vec4uv2[i].Y);
}
if (vec4w0.Length > 0)
{
v.boneWeights.Add(vec4w0[i].X);
v.boneWeights.Add(vec4w0[i].Y);
v.boneWeights.Add(vec4w0[i].Z);
v.boneWeights.Add(vec4w0[i].W);
}
if (vec4i0.Length > 0)
{
v.boneIds.Add((int)vec4i0[i].X);
v.boneIds.Add((int)vec4i0[i].Y);
v.boneIds.Add((int)vec4i0[i].Z);
v.boneIds.Add((int)vec4i0[i].W);
}
if (vec4t0.Length > 0)
{
v.tan = new Vector4(vec4t0[i].X, vec4t0[i].Y, vec4t0[i].Z, vec4t0[i].W);
}
if (vec4b0.Length > 0)
{
v.bitan = new Vector4(vec4b0[i].X, vec4b0[i].Y, vec4b0[i].Z, vec4b0[i].W);
}
if (vec4c0.Length > 0)
{
v.col = new Vector4(vec4c0[i].X, vec4c0[i].Y, vec4c0[i].Z, vec4c0[i].W);
}
if (poly.VertexSkinCount == 1)
{
Matrix4 sb = model.skeleton.bones[model.Node_Array[v.boneIds[0]]].transform;
// Console.WriteLine(model.skeleton.bones[model.Node_Array[v.boneIds[0]]].Text);
v.pos = Vector3.TransformPosition(v.pos, sb);
v.nrm = Vector3.TransformNormal(v.nrm, sb);
}
if (poly.VertexSkinCount == 0)
{
Matrix4 NoBindFix = model.skeleton.bones[poly.boneIndx].transform;
v.pos = Vector3.TransformPosition(v.pos, NoBindFix);
v.nrm = Vector3.TransformNormal(v.nrm, NoBindFix);
}
poly.vertices.Add(v);
}
//shp.Meshes.Count - 1 //For going to the lowest poly LOD mesh
poly.BoundingCount = shp.SubMeshBoundings.Count;
int CurLOD = 0;
foreach (var lod in shp.Meshes)
{
Mesh.LOD_Mesh lodmsh = new Mesh.LOD_Mesh();
lodmsh.index = CurLOD++;
uint FaceCount = lod.IndexCount;
uint[] indicesArray = lod.GetIndices().ToArray();
for (int face = 0; face < FaceCount; face++)
{
lodmsh.faces.Add((int)indicesArray[face] + (int)lod.FirstVertex);
}
poly.lodMeshes.Add(lodmsh);
}
foreach (Bounding bnd in shp.SubMeshBoundings)
{
Mesh.BoundingBox box = new Mesh.BoundingBox();
box.Center = new Vector3(bnd.Center.X, bnd.Center.Y, bnd.Center.Z);
box.Extent = new Vector3(bnd.Extent.X, bnd.Extent.Y, bnd.Extent.Z);
poly.boundingBoxes.Add(box); //Each box is by LOD mesh. This will be in a seperate class later so only one will be added
}
foreach (float r in shp.RadiusArray)
{
poly.radius.Add(r);
}
// Read materials
Material mat = mdl.Materials[shp.MaterialIndex];
int SampIndex = 0;
foreach (var smp in mat.Samplers)
{
poly.material.Samplers.Add(smp.Key, SampIndex);
SampIndex++;
}
int AlbedoCount = 0;
string TextureName = "";
MaterialData.ShaderAssign shaderassign = new MaterialData.ShaderAssign();
if (mat.ShaderAssign != null) //Some special cases (env models) have none
{
shaderassign.ShaderModel = mat.ShaderAssign.ShadingModelName;
shaderassign.ShaderArchive = mat.ShaderAssign.ShaderArchiveName;
int o = 0;
foreach (var op in mat.ShaderAssign.ShaderOptions)
{
shaderassign.options.Add(op.Key, mat.ShaderAssign.ShaderOptions[o]);
o++;
}
int sa = 0;
foreach (var smp in mat.ShaderAssign.SamplerAssigns)
{
shaderassign.samplers.Add(smp.Key, mat.ShaderAssign.SamplerAssigns[sa]);
sa++;
}
int va = 0;
foreach (var att in mat.ShaderAssign.AttribAssigns)
{
shaderassign.attributes.Add(att.Key, mat.ShaderAssign.AttribAssigns[va]);
va++;
}
}
poly.material.shaderassign = shaderassign;
int id = 0;
foreach (TextureRef tex in mdl.Materials[shp.MaterialIndex].TextureRefs)
{
TextureName = tex.Name;
MatTexture texture = new MatTexture();
texture.wrapModeS = (int)mdl.Materials[shp.MaterialIndex].Samplers[id].TexSampler.ClampX;
texture.wrapModeT = (int)mdl.Materials[shp.MaterialIndex].Samplers[id].TexSampler.ClampY;
bool IsAlbedo = HackyTextureList.Any(TextureName.Contains);
if (mdl.Materials[shp.MaterialIndex].Samplers[id].Name == "_a0")
{
poly.material.HasDiffuseMap = true;
texture.hash = 0;
texture.Type = MatTexture.TextureType.Diffuse;
}
if (mdl.Materials[shp.MaterialIndex].Samplers[id].Name == "_a1")
{
poly.material.HasDiffuseLayer = true;
texture.hash = 19;
texture.Type = MatTexture.TextureType.DiffuseLayer2;
}
if (mdl.Materials[shp.MaterialIndex].Samplers[id].Name == "_n0")
{
texture.hash = 1;
poly.material.HasNormalMap = true;
texture.Type = MatTexture.TextureType.Normal;
}
if (mdl.Materials[shp.MaterialIndex].Samplers[id].Name == "_s0")
{
texture.hash = 4;
poly.material.HasSpecularMap = true;
texture.Type = MatTexture.TextureType.Specular;
}
if (mdl.Materials[shp.MaterialIndex].Samplers[id].Name == "_b0")
{
texture.hash = 2;
poly.material.HasShadowMap = true;
texture.Type = MatTexture.TextureType.Shadow;
}
if (mdl.Materials[shp.MaterialIndex].Samplers[id].Name == "_b1")
{
texture.hash = 3;
poly.material.HasLightMap = true;
texture.Type = MatTexture.TextureType.Light;
}
if (mdl.Materials[shp.MaterialIndex].Samplers[id].Name == "_e0")
{
texture.hash = 8;
poly.material.HasEmissionMap = true;
texture.Type = MatTexture.TextureType.Emission;
}
texture.Name = TextureName;
poly.material.textures.Add(texture);
id++;
}
foreach (Sampler smp in mat.Samplers.Values)
{
SamplerInfo s = new SamplerInfo();
s.WrapModeU = (int)smp.TexSampler.ClampX;
s.WrapModeV = (int)smp.TexSampler.ClampY;
s.WrapModeW = (int)smp.TexSampler.ClampZ;
poly.material.samplerinfo.Add(s);
}
poly.material.Name = mdl.Materials[shp.MaterialIndex].Name;
if (mdl.Materials[shp.MaterialIndex].ShaderParamData != null) //Some special cases (env models) have none
{
using (Syroot.BinaryData.BinaryDataReader reader = new Syroot.BinaryData.BinaryDataReader(new MemoryStream(mdl.Materials[shp.MaterialIndex].ShaderParamData)))
{
reader.ByteOrder = Syroot.BinaryData.ByteOrder.BigEndian;
foreach (Syroot.NintenTools.Bfres.ShaderParam param in mdl.Materials[shp.MaterialIndex].ShaderParams.Values)
{
ShaderParam prm = new ShaderParam();
prm.Type = param.Type;
prm.Name = param.Name;
switch (param.Type)
{
case ShaderParamType.Float:
reader.Seek(param.DataOffset, SeekOrigin.Begin);
prm.Value_float = reader.ReadSingle();
break;
case ShaderParamType.Float2:
reader.Seek(param.DataOffset, SeekOrigin.Begin);
prm.Value_float2 = new Vector2(
reader.ReadSingle(),
reader.ReadSingle());
break;
case ShaderParamType.Float3:
reader.Seek(param.DataOffset, SeekOrigin.Begin);
prm.Value_float3 = new Vector3(
reader.ReadSingle(),
reader.ReadSingle(),
reader.ReadSingle()); break;
case ShaderParamType.Float4:
reader.Seek(param.DataOffset, SeekOrigin.Begin);
prm.Value_float4 = new Vector4(
reader.ReadSingle(),
reader.ReadSingle(),
reader.ReadSingle(),
reader.ReadSingle()); break;
case ShaderParamType.TexSrt:
reader.Seek(param.DataOffset, SeekOrigin.Begin);
ShaderParam.TextureSRT texSRT = new ShaderParam.TextureSRT();
texSRT.Mode = reader.ReadSingle(); //Scale mode, Maya, max ect
texSRT.scale = new Vector2(reader.ReadSingle(), reader.ReadSingle());
texSRT.rotate = reader.ReadSingle();
texSRT.translate = new Vector2(reader.ReadSingle(), reader.ReadSingle());
prm.Value_TexSrt = texSRT; break;
}
poly.material.matparam.Add(param.Name, prm);
}
reader.Close();
}
}
model.poly.Add(poly);
ShapeCur++;
}
models.Add(model);
ModelCur++;
}
}
static void LoadParamColumns(ShaderParam param, int index, bool animated = false)
{
ImGui.Columns(3);
if (selectedIndices.Contains(index))
{
ImGui.Columns(1);
if (ImGui.CollapsingHeader(param.Name, ImGuiTreeNodeFlags.DefaultOpen))
{
LoadParamUI(param, $"##{param.Name}", drag);
if (OriginalValues[param.Name] != param.DataValue)
{
ImGui.SameLine();
if (ImGui.Button("Reset"))
{
param.DataValue = OriginalValues[param.Name];
}
}
}
ImGui.Columns(3);
}
else
{
if (animated)
{
ImGui.PushStyleColor(ImGuiCol.Border, new Vector4(0, 0.5f, 0, 1));
ImGui.PushStyleVar(ImGuiStyleVar.FrameBorderSize, 1);
}
ImGui.SetColumnWidth(0, columnSize1);
ImGui.SetColumnWidth(1, columnSize2);
ImGui.SetColumnWidth(2, columnSize3);
if (ImGui.Selectable(param.Name, selectedIndices.Contains(index), ImGuiSelectableFlags.SpanAllColumns))
{
selectedIndices.Clear();
selectedIndices.Add(index);
}
ImGui.NextColumn();
ImGui.Text(GetDataString(param));
ImGui.NextColumn();
if (animated)
{
ImGui.PopStyleColor();
ImGui.PopStyleVar();
}
if (param.Type == ShaderParamType.Float4)
{
if (param.Name.Contains("color") || param.Name.Contains("Color"))
{
ImGuiHelper.InputFloatsFromColor4Button("", param, "DataValue", ImGuiColorEditFlags.AlphaPreviewHalf | ImGuiColorEditFlags.HDR);
}
}
else if (param.Type == ShaderParamType.Float3)
{
if (param.Name.Contains("color") || param.Name.Contains("Color"))
{
ImGuiHelper.InputFloatsFromColor3Button("", param, "DataValue", ImGuiColorEditFlags.HDR);
}
}
ImGui.NextColumn();
ImGui.Columns(1);
}
}
public static Material CreateSwitchMaterial(this BFRES.MaterialData mat)
{
Material m = new Material();
m.Flags = (MaterialFlags)mat.IsVisable;
m.Name = mat.Name;
m.TextureRefs = new List <TextureRef>();
m.RenderInfos = new List <RenderInfo>();
m.Samplers = new List <Sampler>();
m.VolatileFlags = new byte[0];
m.UserDatas = new List <UserData>();
m.ShaderParams = new List <ShaderParam>();
m.SamplerDict = new ResDict();
m.RenderInfoDict = new ResDict();
m.ShaderParamDict = new ResDict();
m.UserDataDict = new ResDict();
m.VolatileFlags = new byte[0];
m.TextureSlotArray = new long[mat.textures.Count];
m.SamplerSlotArray = new long[mat.textures.Count];
m.ShaderParamData = WriteShaderParams(mat);
int CurTex = 0;
foreach (BFRES.MatTexture tex in mat.textures)
{
TextureRef texture = new TextureRef();
texture.Name = tex.Name;
m.TextureRefs.Add(texture);
Sampler samp = new Sampler();
samp.BorderColorType = tex.BorderColorType;
samp.CompareFunc = tex.CompareFunc;
samp.FilterMode = tex.FilterMode;
samp.LODBias = tex.LODBias;
samp.MaxAnisotropic = tex.MaxAnisotropic;
samp.MaxLOD = tex.magFilter;
samp.MinLOD = tex.minFilter;
samp.WrapModeU = (TexClamp)tex.wrapModeS;
samp.WrapModeV = (TexClamp)tex.wrapModeT;
samp.WrapModeW = (TexClamp)tex.wrapModeW;
m.Samplers.Add(samp);
m.SamplerDict.Add(tex.SamplerName);
m.TextureSlotArray[CurTex] = -1;
m.SamplerSlotArray[CurTex] = -1;
CurTex++;
}
int CurParam = 0;
foreach (var prm in mat.matparam)
{
ShaderParam shaderParam = new ShaderParam();
shaderParam.Name = prm.Key;
shaderParam.Type = (ShaderParamType)prm.Value.Type;
shaderParam.DependIndex = (ushort)CurParam;
shaderParam.DependedIndex = (ushort)CurParam;
shaderParam.DataOffset = (ushort)prm.Value.DataOffset;
CurParam++;
}
foreach (BFRES.RenderInfoData rnd in mat.renderinfo)
{
RenderInfo renderInfo = new RenderInfo();
renderInfo.Name = rnd.Name;
if (rnd.Type == Syroot.NintenTools.Bfres.RenderInfoType.Int32)
{
renderInfo.SetValue(rnd.Value_Ints);
}
if (rnd.Type == Syroot.NintenTools.Bfres.RenderInfoType.Single)
{
renderInfo.SetValue(rnd.Value_Floats);
}
if (rnd.Type == Syroot.NintenTools.Bfres.RenderInfoType.String)
{
renderInfo.SetValue(rnd.Value_Strings);
}
m.RenderInfos.Add(renderInfo);
}
ShaderAssign shaderAssign = new ShaderAssign();
shaderAssign.ShaderArchiveName = mat.shaderassign.ShaderArchive;
shaderAssign.ShadingModelName = mat.shaderassign.ShaderModel;
shaderAssign.ShaderOptionDict = new ResDict();
shaderAssign.AttribAssignDict = new ResDict();
shaderAssign.SamplerAssignDict = new ResDict();
shaderAssign.ShaderOptions = new List <string>();
shaderAssign.AttribAssigns = new List <string>();
shaderAssign.SamplerAssigns = new List <string>();
foreach (var op in mat.shaderassign.options)
{
shaderAssign.ShaderOptionDict.Add(op.Key);
shaderAssign.ShaderOptions.Add(op.Value);
}
foreach (var att in mat.shaderassign.attributes)
{
shaderAssign.AttribAssignDict.Add(att.Key);
shaderAssign.AttribAssigns.Add(att.Value);
}
foreach (var smp in mat.shaderassign.samplers)
{
shaderAssign.SamplerAssignDict.Add(smp.Key);
shaderAssign.SamplerAssigns.Add(smp.Value);
}
m.ShaderAssign = shaderAssign;
return(m);
}
private static IEnumerable<string> GenerateProperty(ShaderParam shaderParam, string type, string getter)
{
var result = new List<string>
{
"/// <summary>",
};
if (!string.IsNullOrEmpty(shaderParam.Summary)) result.Add("/// " + shaderParam.Summary);
if (!string.IsNullOrEmpty(shaderParam.DefaultValue)) result.Add("/// Default: " + shaderParam.DefaultValue);
if (!string.IsNullOrEmpty(shaderParam.MinValue)) result.Add("/// Min: " + shaderParam.MinValue);
if (!string.IsNullOrEmpty(shaderParam.MaxValue)) result.Add("/// Max: " + shaderParam.MaxValue);
result.AddRange(new List<string>
{
"/// </summary>",
"public " + type + " " + GetPropertyName(shaderParam),
"{",
"\tget { return Effect.Parameters[\"" + shaderParam.Name +"\"]." + getter + "(); }",
"\tset { Effect.Parameters[\"" + shaderParam.Name +"\"].SetValue(value); }",
"}",
});
return result;
}
private static string GenerateFloatInitialisation(ShaderParam shaderParam)
{
if (string.IsNullOrEmpty(shaderParam.DefaultValue))
return "";
var line = GetPropertyName(shaderParam) + " = " + shaderParam.DefaultValue + "f;";
return line;
}
static void LoadParamUI(ShaderParam param, string label = "", bool drag = false)
{
switch (param.Type)
{
case ShaderParamType.Bool:
{
ImGuiHelper.InputFromBoolean(label, param, "DataValue");
}
break;
case ShaderParamType.Int:
{
ImGuiHelper.InputFromInt(label, param, "DataValue", 1, drag);
}
break;
case ShaderParamType.UInt:
{
ImGuiHelper.InputFromUint(label, param, "DataValue", 1, drag);
}
break;
case ShaderParamType.Float:
{
ImGuiHelper.InputFromFloat(label, param, "DataValue", drag);
}
break;
case ShaderParamType.Float2:
{
ImGuiHelper.InputFloatsFromVector2(label, param, "DataValue", drag);
}
break;
case ShaderParamType.Float3:
{
if (param.Name.Contains("color") || param.Name.Contains("Color"))
{
ImGuiHelper.InputFloatsFromColor3(label, param, "DataValue");
}
else
{
ImGuiHelper.InputFloatsFromVector3(label, param, "DataValue", drag);
}
}
break;
case ShaderParamType.Float4:
{
if (param.Name.Contains("color") || param.Name.Contains("Color"))
{
ImGuiHelper.InputFloatsFromColor4(label, param, "DataValue", ImGuiColorEditFlags.AlphaBar | ImGuiColorEditFlags.AlphaPreviewHalf);
}
else
{
ImGuiHelper.InputFloatsFromVector4(label, param, "DataValue", drag);
}
}
break;
case ShaderParamType.Srt2D:
{
Srt2D value = (Srt2D)param.DataValue;
var pos = new Vector2(value.Translation.X, value.Translation.Y);
var scale = new Vector2(value.Scaling.X, value.Scaling.Y);
var rot = value.Rotation;
bool edited0 = ImGui.DragFloat2("Scale", ref scale);
bool edited1 = ImGui.DragFloat("Rotate", ref rot, 0.1f);
bool edited2 = ImGui.DragFloat2("Translate", ref pos);
if (edited0 || edited1 || edited2)
{
param.DataValue = new Srt2D()
{
Scaling = new Syroot.Maths.Vector2F(scale.X, scale.Y),
Translation = new Syroot.Maths.Vector2F(pos.X, pos.Y),
Rotation = rot,
};
}
}
break;
case ShaderParamType.TexSrt:
case ShaderParamType.TexSrtEx:
{
TexSrt value = (TexSrt)param.DataValue;
bool edited3 = ImGuiHelper.ComboFromEnum <TexSrtMode>("Mode", value, "Mode");
var pos = new Vector2(value.Translation.X, value.Translation.Y);
var scale = new Vector2(value.Scaling.X, value.Scaling.Y);
var rot = value.Rotation;
bool edited0 = ImGui.DragFloat2("Scale", ref scale);
bool edited1 = ImGui.DragFloat("Rotate", ref rot, 0.1f);
bool edited2 = ImGui.DragFloat2("Translate", ref pos);
if (edited0 || edited1 || edited2 || edited3)
{
param.DataValue = new TexSrt()
{
Mode = value.Mode,
Scaling = new Syroot.Maths.Vector2F(scale.X, scale.Y),
Translation = new Syroot.Maths.Vector2F(pos.X, pos.Y),
Rotation = rot,
};
}
}
break;
}
}
private static IEnumerable<string> GenerateFloatProperty(ShaderParam shaderParam)
{
return GenerateProperty(shaderParam, "float", "GetValueSingle");
}
public static void WriteFMATXML(MaterialData mat, Mesh msh)
{
SaveFileDialog sfd = new SaveFileDialog();
sfd.Filter = "XML|*.xml|All files(*.*)|*.*";
sfd.FileName = mat.Name;
if (sfd.ShowDialog() == DialogResult.OK)
{
/* StreamWriter file = new StreamWriter(sfd.FileName);
* using (JsonWriter writer = new JsonTextWriter(file))
* {
* writer.Formatting = Formatting.Indented;
*
* writer.WriteStartObject();
* writer.WritePropertyName("Material");
* writer.WriteValue(mat.Name);
* writer.WritePropertyName("TextureArray");
* writer.WriteStartArray();
* int s = 0;
* foreach (var tex in mat.textures)
* {
* writer.WritePropertyName("TextureArray");
* writer.WriteValue(mat.Samplers.Keys.ElementAt(s));
* s++;
* }
* writer.WriteEnd();
* writer.WriteEndObject();
*
* }*/
XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = true;
XmlWriter writer = XmlWriter.Create(sfd.FileName, settings);
writer.WriteStartDocument();
writer.WriteStartElement("Materials");
writer.WriteStartElement("SamplerArray");
int s = 0;
foreach (var tex in mat.textures)
{
writer.WriteStartElement("Sampler");
writer.WriteAttributeString("Name", mat.Samplers.Keys.ElementAt(s));
writer.WriteAttributeString("Texture_Name", tex.Name);
writer.WriteAttributeString("Index", s.ToString());
writer.WriteStartElement("WrapMode");
writer.WriteAttributeString("U", wrapmode[mat.samplerinfo[s].WrapModeU].ToString());
writer.WriteAttributeString("V", wrapmode[mat.samplerinfo[s].WrapModeV].ToString());
writer.WriteAttributeString("W", wrapmode[mat.samplerinfo[s].WrapModeW].ToString());
writer.WriteEndElement();
writer.WriteEndElement();
s++;
}
writer.WriteEndElement();
writer.WriteStartElement("Sampler");
foreach (var smp in mat.Samplers)
{
writer.WriteStartElement("SamplerInfo");
writer.WriteString(smp.Key);
writer.WriteEndElement();
}
writer.WriteEndElement();
writer.WriteStartElement("RenderInfo");
int p = 0;
foreach (var rnd in mat.renderinfo)
{
writer.WriteStartElement("Info");
writer.WriteAttributeString("Index", p.ToString());
switch (rnd.Type)
{
case RenderInfoType.String:
writer.WriteAttributeString(rnd.Name, rnd.Value_String);
break;
case RenderInfoType.Int32:
writer.WriteAttributeString(rnd.Name, rnd.Value_Int.ToString());
break;
case RenderInfoType.Single:
writer.WriteAttributeString(rnd.Name, rnd.Value_Float.ToString());
break;
}
writer.WriteAttributeString("Type", rnd.Type.ToString());
writer.WriteEndElement();
p++;
}
writer.WriteEndElement();
writer.WriteStartElement("ShaderAssign");
writer.WriteAttributeString("ShaderFile", mat.shaderassign.ShaderModel);
p = 0;
foreach (var op in mat.shaderassign.options)
{
writer.WriteStartElement("Option");
writer.WriteAttributeString("Index", p.ToString());
writer.WriteAttributeString(op.Key, op.Value);
writer.WriteEndElement();
p++;
}
foreach (var smp in mat.shaderassign.samplers)
{
writer.WriteStartElement("SamplersFragmentShader");
writer.WriteAttributeString(smp.Key, smp.Value);
writer.WriteEndElement();
}
foreach (var att in mat.shaderassign.attributes)
{
writer.WriteStartElement("AttributesVertexShader");
writer.WriteAttributeString(att.Key, att.Value);
writer.WriteEndElement();
}
writer.WriteEndElement();
p = 0;
writer.WriteStartElement("ShaderParam");
foreach (var prm in mat.matparam)
{
ShaderParam param = prm.Value;
writer.WriteStartElement("ShaderParam");
writer.WriteAttributeString("Index", p.ToString());
switch (param.Type)
{
case ShaderParamType.Float:
writer.WriteAttributeString(prm.Key, param.Value_float.ToString());
break;
case ShaderParamType.Float2:
writer.WriteAttributeString(prm.Key, param.Value_float2.ToString());
break;
case ShaderParamType.Float3:
writer.WriteAttributeString(prm.Key, param.Value_float3.ToString());
break;
case ShaderParamType.Float4:
writer.WriteAttributeString(prm.Key, param.Value_float4.ToString());
break;
case ShaderParamType.TexSrt:
writer.WriteAttributeString(prm.Key, param.Value_TexSrt.scale.ToString() +
" " + param.Value_TexSrt.rotate.ToString() +
" " + param.Value_TexSrt.translate.ToString());
break;
case ShaderParamType.Bool:
writer.WriteAttributeString(prm.Key, param.Value_bool.ToString());
break;
}
writer.WriteAttributeString("Type", param.Type.ToString());
writer.WriteEndElement();
p++;
}
writer.WriteEndElement();
writer.WriteEndDocument();
writer.Close();
}
}
