public static Matl LibraryToMATL(MaterialLibrary library)
{
Matl matl = new Matl
{
Entries = new MatlEntry[library.material.Length]
};
for (int i = 0; i < library.material.Length; i++)
{
MatlEntry entry = new MatlEntry
{
MaterialLabel = library.material[i].label,
MaterialName = library.material[i].name,
Attributes = new MatlAttribute[library.material[i].param.Length]
};
for (int j = 0; j < library.material[i].param.Length; j++)
{
entry.Attributes[j] = new MatlAttribute
{
ParamId = library.material[i].param[j].name,
DataObject = library.material[i].param[j].value
};
}
matl.Entries[i] = entry;
}
return(matl);
}
public static MaterialLibrary MATLtoLibrary(Matl matlFile)
{
MaterialLibrary library = new MaterialLibrary
{
material = new Material[matlFile.Entries.Length]
};
int entryIndex = 0;
foreach (var entry in matlFile.Entries)
{
Material mat = new Material();
mat.name = entry.MaterialName;
mat.label = entry.MaterialLabel;
mat.param = new MatlXmlAttribute[entry.Attributes.Length];
int attribIndex = 0;
foreach (var attr in entry.Attributes)
{
MatlXmlAttribute attrib = new MatlXmlAttribute();
attrib.name = attr.ParamId;
attrib.value = attr.DataObject;
mat.param[attribIndex++] = attrib;
}
library.material[entryIndex] = mat;
entryIndex++;
}
return(library);
}
public override void Open()
{
if (Ssbh.TryParseSsbhFile(AbsolutePath, out Matl newMaterial))
{
Material = newMaterial;
}
}
private static void SerializeMatl(string inputPath, string outputPath, XmlSerializer serializer)
{
if (outputPath == null)
{
outputPath = GetFullPathWithoutExtension(inputPath) + "_out.xml";
}
Console.WriteLine($"Converting {Path.GetFileName(inputPath)} to {outputPath}...");
if (Ssbh.TryParseSsbhFile(inputPath, out SsbhFile file))
{
Matl matlFile = (Matl)file;
MaterialLibrary library = MATLtoLibrary(matlFile);
using (TextWriter writer = new StringWriter())
{
serializer.Serialize(writer, library);
string serial = writer.ToString();
File.WriteAllText(outputPath, serial);
}
}
else
{
Console.WriteLine("Error reading matl file");
}
}
private static MaterialLibrary MatlToLibrary(Matl matlFile)
{
var library = new MaterialLibrary
{
materials = matlFile.Entries.Select(e => CreateMaterial(e)).ToArray()
};
return(library);
}
public override void Open()
{
if (Ssbh.TryParseSsbhFile(AbsolutePath, out SsbhFile ssbhFile))
{
if (ssbhFile is Matl)
{
Material = (Matl)ssbhFile;
}
}
}
private static Matl LibraryToMATL(MaterialLibrary library)
{
var matl = new Matl();
if (library.materials != null)
{
matl.Entries = library.materials.Select(m => CreateEntry(m)).ToArray();
}
return(matl);
}
public void SetAutoMaterial(int id)
{
Matl FemapMaterial = FemapModel.feMatl;
FemapMaterial.Active = 1;
FemapMaterial.type = zMaterialType.FMT_ISOTROPIC;
FemapMaterial.GetLibrary(id);
FemapMaterial.Put(1);
FemapMaterial.Reset();
FemapModel.feView.Regenerate();
}
public void EmptyMatl()
{
var matl = new Matl();
var writer = new StringWriter();
MatlSerialization.SerializeMatl(writer, matl);
var expected = @"<?xml version=""1.0"" encoding=""utf-16""?>
<MaterialLibrary xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"" xmlns:xsd=""http://www.w3.org/2001/XMLSchema"" />";
Assert.AreEqual(expected, writer.ToString());
}
private static void DeserializeXml(string inputPath, string outputPath, XmlSerializer serializer)
{
Console.WriteLine($"Converting {Path.GetFileName(inputPath)} to {outputPath}.numatb...");
using (TextReader reader = new StringReader(File.ReadAllText(inputPath)))
{
var result = (MaterialLibrary)serializer.Deserialize(reader);
Matl newmatl = LibraryToMATL(result);
Ssbh.TrySaveSsbhFile(outputPath, newmatl);
}
}
private IRenderable CreateRenderableModel()
{
NumsbhNode meshNode = null;
NuhlpbNode hlpbNode = null;
RSkeleton skeleton = null;
Matl material = null;
var textureByName = new Dictionary <string, SFGraphics.GLObjects.Textures.Texture>();
GetNodesForRendering(ref meshNode, ref hlpbNode, ref skeleton, ref material, textureByName);
return(new RNumdl(model, skeleton, material, meshNode, hlpbNode, textureByName));
}
private IRenderable CreateRenderableModel()
{
NumsbhNode meshNode = null;
NuhlpbNode hlpbNode = null;
RSkeleton skeleton = null;
Matl material = null;
XmbNode modelXmb = null;
XmbNode lodXmb = null;
var textureByName = new Dictionary <string, RTexture>();
GetNodesForRendering(ref meshNode, ref hlpbNode, ref skeleton, ref material, ref modelXmb, ref lodXmb, textureByName);
return(new RNumdl(model, skeleton, material, meshNode, hlpbNode, modelXmb, lodXmb, textureByName));
}
public FEAForm(model FemapModel)
{
InitializeComponent();
this.FemapModel = FemapModel;
newPropertyRadioButton.IsChecked = true;
propertyComboBox.Enabled = false;
Matl materials = FemapModel.feMatl;
materials.GetTitleList(1, FemapModel.feMatl.CountSet(),
out CountMaterials, out MaterialsIDs, out MaterialsTitles);
List <ListData> materialList = new List <ListData>();
if (CountMaterials > 0)
{
for (int i = 0; i < ((string[])MaterialsTitles).Length; i++)
{
materialList.Add(new ListData(((string[])MaterialsTitles)[i]));
}
MaterialComboBox.DataSource = materialList;
UpdateCombo(CountMaterials, (string[])MaterialsTitles, (int[])MaterialsIDs);
}
Prop properties = FemapModel.feProp;
properties.GetTitleList(1, FemapModel.feProp.CountSet(),
out CountOfProperties, out PropertyIDs, out PropertyTitles);
List <ListData> propertyList = new List <ListData>();
if (CountOfProperties > 0)
{
for (int i = 0; i < ((string[])PropertyTitles).Length; i++)
{
propertyList.Add(new ListData(((string[])PropertyTitles)[i]));
}
propertyComboBox.DataSource = propertyList;
UpdateCombo(CountOfProperties, (string[])PropertyTitles, (int[])PropertyIDs);
listOfPropertyRadioButton.IsChecked = true;
TitleBox.Enabled = false;
propertyComboBox.Enabled = true;
}
}
public RNumdl(Modl modl, RSkeleton skeleton, Matl matl, NumshbNode meshNode, NuhlpbNode hlpbNode, XmbNode modelXmb, XmbNode lodXmb,
Dictionary <string, RTexture> textureByName)
{
Modl = modl;
Skeleton = skeleton;
Matl = matl;
ModelXmb = modelXmb?.Xmb;
LodXmb = lodXmb?.Xmb;
TextureByName = textureByName;
if (meshNode != null)
{
RenderModel = meshNode.GetRenderModel(Skeleton);
}
UpdateMaterials(matl);
if (Skeleton != null)
{
hlpbNode?.AddToRenderSkeleton(Skeleton);
}
}
private IRenderable CreateRenderableModel()
{
NumsbhNode meshNode = null;
NuhlpbNode hlpbNode = null;
RSkeleton skeleton = null;
Matl material = null;
// TODO: Add remaining default textures.
var textureByName = new Dictionary <string, SFGraphics.GLObjects.Textures.Texture>
{
{ "#replace_cubemap", Rendering.Resources.DefaultTextures.Instance.SpecularPbr },
{ "/common/shader/sfxpbs/default_normal", Rendering.Resources.DefaultTextures.Instance.DefaultNormal },
{ "/common/shader/sfxpbs/default_params", Rendering.Resources.DefaultTextures.Instance.DefaultPrm },
{ "/common/shader/sfxpbs/default_black", Rendering.Resources.DefaultTextures.Instance.DefaultBlack },
{ "/common/shader/sfxpbs/default_white", Rendering.Resources.DefaultTextures.Instance.DefaultWhite },
{ "/common/shader/sfxpbs/default_color", Rendering.Resources.DefaultTextures.Instance.DefaultWhite }
};
GetNodesForRendering(ref meshNode, ref hlpbNode, ref skeleton, ref material, textureByName);
return(new RNumdl(model, skeleton, material, meshNode, hlpbNode, textureByName));
}
private MaterialCollection CreateMaterialCollection(string name, Dictionary <string, RMaterial> materialByName, Matl matl)
{
var collection = new MaterialCollection(name);
for (int i = 0; i < matl.Entries.Length; i++)
{
// Pass a reference to the render material to enable real time updates.
materialByName.TryGetValue(matl.Entries[i].MaterialLabel, out RMaterial? rMaterial);
var material = CreateMaterial(matl.Entries[i], i, rMaterial);
collection.Materials.Add(material);
}
return(collection);
}
private void GetNodesForRendering(ref NumshbNode meshNode, ref NuhlpbNode hlpbNode, ref RSkeleton skeleton, ref Matl material, ref XmbNode modelXmb, ref XmbNode lodXmb,
Dictionary <string, RTexture> textureByName)
{
// TODO: There's probably a cleaner way of doing this.
foreach (FileNode fileNode in Parent.Nodes)
{
if (fileNode is NuhlpbNode node)
{
hlpbNode = node;
}
else if (fileNode is NutexbNode nutexNode)
{
var texture = (RTexture)nutexNode.Renderable.Value;
// Use the file name instead of the internal name.
// Ignore case.
var textureName = System.IO.Path.GetFileNameWithoutExtension(fileNode.Text).ToLower();
textureByName[textureName] = texture;
}
else if (fileNode.Text.Equals(model.MeshString))
{
meshNode = (NumshbNode)fileNode;
}
else if (fileNode.Text.Equals(model.SkeletonFileName))
{
skeleton = (RSkeleton)((NusktbNode)fileNode).Renderable.Value;
}
else if (fileNode.Text.Equals(model.MaterialFileNames[0].MaterialFileName))
{
material = ((NumatbNode)fileNode).Material;
}
else if (fileNode.Text.Equals("model.xmb"))
{
modelXmb = (XmbNode)fileNode;
}
else if (fileNode.Text.Equals("lod.xmb"))
{
lodXmb = (XmbNode)fileNode;
}
}
}
private void GetNodesForRendering(ref NumsbhNode meshNode, ref NuhlpbNode hlpbNode, ref RSkeleton skeleton, ref Matl material, Dictionary <string, SFGraphics.GLObjects.Textures.Texture> textureByName)
{
foreach (FileNode fileNode in Parent.Nodes)
{
if (fileNode is NuhlpbNode node)
{
hlpbNode = node;
}
else if (fileNode is NutexNode nutexNode)
{
var texture = (RTexture)nutexNode.GetRenderableNode();
textureByName[nutexNode.TexName.ToLower()] = texture.RenderTexture;
}
else if (fileNode.Text.Equals(model.MeshString))
{
meshNode = (NumsbhNode)fileNode;
}
else if (fileNode.Text.Equals(model.SkeletonFileName))
{
skeleton = (RSkeleton)((SkelNode)fileNode).GetRenderableNode();
}
else if (fileNode.Text.Equals(model.MaterialFileNames[0].MaterialFileName))
{
material = ((MatlNode)fileNode).Material;
}
}
}
public IOModel GetIOModel()
{
IOModel outModel = new IOModel();
Mesh meshFile = null;
Matl materialFile = null;
foreach (FileNode n in Parent.Nodes)
{
if (n.Text.Equals(model.MeshString))
{
meshFile = ((NumsbhNode)n).mesh;
}
if (n.Text.Equals(model.SkeletonFileName))
{
outModel.Skeleton = (RSkeleton)((SkelNode)n).GetRenderableNode();
}
if (n.Text.Equals(model.MaterialFileNames[0].MaterialFileName))
{
materialFile = ((MatlNode)n).Material;
}
}
Dictionary <string, int> indexByBoneName = new Dictionary <string, int>();
if (outModel.Skeleton != null)
{
for (int i = 0; i < outModel.Skeleton.Bones.Count; i++)
{
indexByBoneName.Add(outModel.Skeleton.Bones[i].Name, i);
}
}
Dictionary <string, int> materialNameToIndex = new Dictionary <string, int>();
if (materialFile != null)
{
int materialIndex = 0;
foreach (var entry in materialFile.Entries)
{
materialNameToIndex.Add(entry.ShaderLabel, materialIndex++);
IOMaterial material = new IOMaterial
{
Name = entry.ShaderLabel
};
outModel.Materials.Add(material);
foreach (var attr in entry.Attributes)
{
if (attr.ParamId == MatlEnums.ParamId.Texture0)
{
IOTexture dif = new IOTexture
{
Name = attr.DataObject.ToString()
};
material.DiffuseTexture = dif;
}
}
}
}
if (meshFile != null)
{
SsbhVertexAccessor vertexAccessor = new SsbhVertexAccessor(meshFile);
{
SsbhRiggingAccessor riggingAccessor = new SsbhRiggingAccessor(meshFile);
foreach (MeshObject obj in meshFile.Objects)
{
IOMesh outMesh = new IOMesh()
{
Name = obj.Name,
};
outModel.Meshes.Add(outMesh);
// get material
if (materialFile != null)
{
foreach (var entry in model.ModelEntries)
{
if (entry.MeshName.Equals(obj.Name) && entry.SubIndex == obj.SubMeshIndex)
{
outMesh.MaterialIndex = materialNameToIndex[entry.MaterialLabel];
break;
}
}
}
IOVertex[] vertices = new IOVertex[obj.VertexCount];
for (int i = 0; i < vertices.Length; i++)
{
vertices[i] = new IOVertex();
}
foreach (MeshAttribute attr in obj.Attributes)
{
SsbhVertexAttribute[] values = vertexAccessor.ReadAttribute(attr.AttributeStrings[0].Name, 0, obj.VertexCount, obj);
if (attr.AttributeStrings[0].Name.Equals("Position0"))
{
outMesh.HasPositions = true;
for (int i = 0; i < values.Length; i++)
{
vertices[i].Position = new OpenTK.Vector3(values[i].X, values[i].Y, values[i].Z);
}
}
if (attr.AttributeStrings[0].Name.Equals("Normal0"))
{
outMesh.HasNormals = true;
for (int i = 0; i < values.Length; i++)
{
vertices[i].Normal = new OpenTK.Vector3(values[i].X, values[i].Y, values[i].Z);
}
}
// Flip UVs vertically for export.
if (attr.AttributeStrings[0].Name.Equals("map1"))
{
outMesh.HasUV0 = true;
for (int i = 0; i < values.Length; i++)
{
vertices[i].UV0 = new OpenTK.Vector2(values[i].X, 1 - values[i].Y);
}
}
if (attr.AttributeStrings[0].Name.Equals("uvSet"))
{
outMesh.HasUV1 = true;
for (int i = 0; i < values.Length; i++)
{
vertices[i].UV1 = new OpenTK.Vector2(values[i].X, 1 - values[i].Y);
}
}
if (attr.AttributeStrings[0].Name.Equals("uvSet1"))
{
outMesh.HasUV2 = true;
for (int i = 0; i < values.Length; i++)
{
vertices[i].UV2 = new OpenTK.Vector2(values[i].X, 1 - values[i].Y);
}
}
if (attr.AttributeStrings[0].Name.Equals("uvSet2"))
{
outMesh.HasUV3 = true;
for (int i = 0; i < values.Length; i++)
{
vertices[i].UV3 = new OpenTK.Vector2(values[i].X, 1 - values[i].Y);
}
}
if (attr.AttributeStrings[0].Name.Equals("colorSet1"))
{
outMesh.HasColor = true;
for (int i = 0; i < values.Length; i++)
{
vertices[i].Color = new OpenTK.Vector4(values[i].X, values[i].Y, values[i].Z, values[i].W) / 127f;
}
}
}
// Fix SingleBinds
if (outModel.Skeleton != null && !obj.ParentBoneName.Equals(""))
{
int parentIndex = outModel.Skeleton.GetBoneIndex(obj.ParentBoneName);
if (parentIndex != -1)
{
for (int i = 0; i < vertices.Length; i++)
{
vertices[i].Position = OpenTK.Vector3.TransformPosition(vertices[i].Position, outModel.Skeleton.Bones[parentIndex].WorldTransform);
vertices[i].Normal = OpenTK.Vector3.TransformNormal(vertices[i].Normal, outModel.Skeleton.Bones[parentIndex].WorldTransform);
vertices[i].BoneIndices.X = indexByBoneName[obj.ParentBoneName];
vertices[i].BoneWeights.X = 1;
outMesh.HasBoneWeights = true;
}
}
}
// Apply Rigging
SsbhVertexInfluence[] influences = riggingAccessor.ReadRiggingBuffer(obj.Name, (int)obj.SubMeshIndex);
foreach (SsbhVertexInfluence influence in influences)
{
outMesh.HasBoneWeights = true;
// Some influences refer to bones that don't exist in the skeleton.
// _eff bones?
if (!indexByBoneName.ContainsKey(influence.BoneName))
{
continue;
}
if (vertices[influence.VertexIndex].BoneWeights.X == 0)
{
vertices[influence.VertexIndex].BoneIndices.X = indexByBoneName[influence.BoneName];
vertices[influence.VertexIndex].BoneWeights.X = influence.Weight;
}
else if (vertices[influence.VertexIndex].BoneWeights.Y == 0)
{
vertices[influence.VertexIndex].BoneIndices.Y = indexByBoneName[influence.BoneName];
vertices[influence.VertexIndex].BoneWeights.Y = influence.Weight;
}
else if (vertices[influence.VertexIndex].BoneWeights.Z == 0)
{
vertices[influence.VertexIndex].BoneIndices.Z = indexByBoneName[influence.BoneName];
vertices[influence.VertexIndex].BoneWeights.Z = influence.Weight;
}
else if (vertices[influence.VertexIndex].BoneWeights.W == 0)
{
vertices[influence.VertexIndex].BoneIndices.W = indexByBoneName[influence.BoneName];
vertices[influence.VertexIndex].BoneWeights.W = influence.Weight;
}
}
outMesh.Vertices.AddRange(vertices);
outMesh.Indices.AddRange(vertexAccessor.ReadIndices(0, obj.IndexCount, obj));
}
}
}
return(outModel);
}
public static void SerializeMatl(TextWriter writer, Matl matl)
{
var library = MatlToLibrary(matl);
serializer.Serialize(writer, library);
}
private void GetNodesForRendering(ref NumsbhNode meshNode, ref NuhlpbNode hlpbNode, ref RSkeleton skeleton, ref Matl material, ref XmbNode modelXmb, ref XmbNode lodXmb,
Dictionary <string, RTexture> textureByName)
{
// TODO: There's probably a cleaner way of doing this.
foreach (FileNode fileNode in Parent.Nodes)
{
if (fileNode is NuhlpbNode node)
{
hlpbNode = node;
}
else if (fileNode is NutexNode nutexNode)
{
var texture = (RTexture)nutexNode.GetRenderableNode();
textureByName[nutexNode.TexName.ToLower()] = texture;
}
else if (fileNode.Text.Equals(model.MeshString))
{
meshNode = (NumsbhNode)fileNode;
}
else if (fileNode.Text.Equals(model.SkeletonFileName))
{
skeleton = (RSkeleton)((SkelNode)fileNode).GetRenderableNode();
}
else if (fileNode.Text.Equals(model.MaterialFileNames[0].MaterialFileName))
{
material = ((MatlNode)fileNode).Material;
}
else if (fileNode.Text.Equals("model.xmb"))
{
modelXmb = (XmbNode)fileNode;
}
else if (fileNode.Text.Equals("lod.xmb"))
{
lodXmb = (XmbNode)fileNode;
}
}
}
