public SBAnimation ImportSBAnimation(string FileName, SBSkeleton skeleton)
{
SBAnimation anim = new SBAnimation();
ISSBH_File File;
if (SSBH.TryParseSSBHFile(FileName, out File))
{
if (File is ANIM animation)
{
anim.Name = animation.Name;
anim.FrameCount = animation.FrameCount;
foreach (var group in animation.Animations)
{
if (group.Type == ANIM_TYPE.Visibilty)
{
ReadVisibilityAnimations(animation, group, anim);
}
if (group.Type == ANIM_TYPE.Transform)
{
ReadTransformAnimations(animation, group, anim);
}
if (group.Type == ANIM_TYPE.Material)
{
ReadMaterialAnimations(animation, group, anim);
}
}
}
}
return(anim);
}
public static void Open(string FileName, SBScene Scene)
{
ISSBH_File File;
if (SSBH.TryParseSSBHFile(FileName, out File))
{
if (File is MESH mesh)
{
if (mesh.VersionMajor != 1 && mesh.VersionMinor != 10)
{
SBConsole.WriteLine($"Mesh Version {mesh.VersionMajor}.{mesh.VersionMinor} not supported");
return;
}
if (mesh.UnknownOffset != 0 || mesh.UnknownSize != 0)
{
SBConsole.WriteLine($"Warning: Unknown Mesh format detected");
}
SBUltimateModel model = new SBUltimateModel();
model.Name = mesh.ModelName;
model.BoundingSphere = new Vector4(mesh.BoundingSphereX, mesh.BoundingSphereY, mesh.BoundingSphereZ, mesh.BoundingSphereRadius);
((SBSceneSSBH)Scene).Model = model;
SSBHVertexAccessor accessor = new SSBHVertexAccessor(mesh);
{
foreach (var meshObject in mesh.Objects)
{
SBUltimateMesh sbMesh = new SBUltimateMesh();
foreach (var attr in meshObject.Attributes)
{
foreach (var atstring in attr.AttributeStrings)
{
UltimateVertexAttribute at;
if (Enum.TryParse(atstring.Name, out at))
{
sbMesh.EnableAttribute(at);
}
}
}
sbMesh.Name = meshObject.Name;
sbMesh.ParentBone = meshObject.ParentBoneName;
sbMesh.BoundingSphere = new BoundingSphere(meshObject.BoundingSphereX, meshObject.BoundingSphereY, meshObject.BoundingSphereZ, meshObject.BoundingSphereRadius);
sbMesh.AABoundingBox = new AABoundingBox(new Vector3(meshObject.MinBoundingBoxX, meshObject.MinBoundingBoxY, meshObject.MinBoundingBoxZ),
new Vector3(meshObject.MaxBoundingBoxX, meshObject.MaxBoundingBoxY, meshObject.MaxBoundingBoxZ));
sbMesh.OrientedBoundingBox = new OrientedBoundingBox(new Vector3(meshObject.OBBCenterX, meshObject.OBBCenterY, meshObject.OBBCenterZ),
new Vector3(meshObject.OBBSizeX, meshObject.OBBSizeY, meshObject.OBBSizeZ),
new Matrix3(meshObject.M11, meshObject.M12, meshObject.M13,
meshObject.M21, meshObject.M22, meshObject.M23,
meshObject.M31, meshObject.M32, meshObject.M33));
sbMesh.Indices = new List <uint>(accessor.ReadIndices(0, meshObject.IndexCount, meshObject));
sbMesh.Vertices = CreateVertices(mesh, Scene.Skeleton, meshObject, accessor, sbMesh.Indices.ToArray());
model.Meshes.Add(sbMesh);
}
}
}
}
}
public static void Open(string FileName, SBScene Scene)
{
ISSBH_File File;
if (SSBH.TryParseSSBHFile(FileName, out File))
{
if (File is MESH mesh)
{
if (mesh.VersionMajor != 1 && mesh.VersionMinor != 10)
{
SBConsole.WriteLine($"Mesh Version {mesh.VersionMajor}.{mesh.VersionMinor} not supported");
return;
}
if (mesh.UnknownOffset != 0 || mesh.UnknownSize != 0)
{
SBConsole.WriteLine($"Warning: Unknown Mesh format detected");
}
SBUltimateModel model = new SBUltimateModel();
model.Name = mesh.ModelName;
model.BoundingSphere = new Vector4(mesh.BoundingSphereX, mesh.BoundingSphereY, mesh.BoundingSphereZ, mesh.BoundingSphereRadius / 2);
Vector3 min = new Vector3(mesh.MinBoundingBoxX, mesh.MinBoundingBoxY, mesh.MinBoundingBoxZ);
Vector3 max = new Vector3(mesh.MaxBoundingBoxX, mesh.MaxBoundingBoxY, mesh.MaxBoundingBoxZ);
model.VolumeCenter = (max + min) / 2;
model.VolumeSize = (max - min) / 2;
((SBSceneSSBH)Scene).Model = model;
using (SSBHVertexAccessor accessor = new SSBHVertexAccessor(mesh))
{
foreach (var meshObject in mesh.Objects)
{
SBUltimateMesh <UltimateVertex> sbMesh = new SBUltimateMesh <UltimateVertex>();
foreach (var attr in meshObject.Attributes)
{
foreach (var atstring in attr.AttributeStrings)
{
MESHAttribute at;
if (Enum.TryParse <MESHAttribute>(atstring.Name, out at))
{
//SBConsole.WriteLine("\tLoaded:" + at.ToString());
sbMesh.ExportAttributes.Add(at);
}
}
}
sbMesh.Name = meshObject.Name;
sbMesh.BoundingSphere = new Vector4(meshObject.BoundingSphereX, meshObject.BoundingSphereY, meshObject.BoundingSphereZ, meshObject.BoundingSphereRadius);
sbMesh.ParentBone = meshObject.ParentBoneName;
sbMesh.Indices = new List <uint>(accessor.ReadIndices(0, meshObject.IndexCount, meshObject));
sbMesh.Vertices = CreateVertices(mesh, Scene.Skeleton, meshObject, accessor, sbMesh.Indices.ToArray());
model.Meshes.Add(sbMesh);
}
}
}
}
}
public override void Open(string Path)
{
if (SSBH.TryParseSSBHFile(Path, out ISSBH_File ssbhFile))
{
if (ssbhFile is MODL)
{
_model = (MODL)ssbhFile;
}
}
}
public override void Open()
{
if (SSBH.TryParseSSBHFile(AbsolutePath, out ISSBH_File SSBHFile))
{
if (SSBHFile is ANIM anim)
{
animation = anim;
}
}
}
public override void Open()
{
if (SSBH.TryParseSSBHFile(AbsolutePath, out ISSBH_File ssbhFile))
{
if (ssbhFile is MATL)
{
Material = (MATL)ssbhFile;
}
}
}
public override void Open(string Path)
{
if (SSBH.TryParseSSBHFile(Path, out ISSBH_File ssbhFile))
{
if (ssbhFile is MESH)
{
mesh = (MESH)ssbhFile;
}
}
}
public override void Open()
{
if (SSBH.TryParseSSBHFile(AbsolutePath, out ISSBH_File ssbhFile))
{
if (ssbhFile is MODL)
{
_model = (MODL)ssbhFile;
}
}
}
public override void Open()
{
if (SSBH.TryParseSSBHFile(AbsolutePath, out ISSBH_File ssbhFile))
{
if (ssbhFile is HLPB)
{
helperBones = (HLPB)ssbhFile;
}
}
}
public override void Open(string Path)
{
if (SSBH.TryParseSSBHFile(Path, out ISSBH_File ssbhFile))
{
if (ssbhFile is MATL)
{
Material = (MATL)ssbhFile;
}
}
}
private static void DeserializeXml(string inputPath, string outputPath, XmlSerializer serializer)
{
Console.WriteLine($"Converting {Path.GetFileName(inputPath)} to {outputPath}_out.numatb...");
using (TextReader reader = new StringReader(File.ReadAllText(inputPath)))
{
var result = (MaterialLibrary)serializer.Deserialize(reader);
MATL newmatl = LibraryToMATL(result);
SSBH.TrySaveSSBHFile(outputPath + "_out.numatb", newmatl);
}
}
public override void Open(string Path)
{
ISSBH_File SSBHFile;
if (SSBH.TryParseSSBHFile(Path, out SSBHFile))
{
if (SSBHFile is ANIM anim)
{
animation = anim;
}
}
}
public override void Open()
{
ISSBH_File SSBHFile;
if (SSBH.TryParseSSBHFile(AbsolutePath, out SSBHFile))
{
if (SSBHFile is SKEL)
{
_skel = (SKEL)SSBHFile;
}
}
}
public override void Open(string Path)
{
ISSBH_File SSBHFile;
if (SSBH.TryParseSSBHFile(Path, out SSBHFile))
{
if (SSBHFile is SKEL)
{
_skel = (SKEL)SSBHFile;
}
}
}
public static void Save(string FileName, SBScene Scene)
{
var Skeleton = Scene.Skeleton;
var skelFile = new SKEL();
skelFile.MajorVersion = 1;
skelFile.MinorVersion = 0;
List <SKEL_BoneEntry> BoneEntries = new List <SKEL_BoneEntry>();
List <SKEL_Matrix> Transforms = new List <SKEL_Matrix>();
List <SKEL_Matrix> InvTransforms = new List <SKEL_Matrix>();
List <SKEL_Matrix> WorldTransforms = new List <SKEL_Matrix>();
List <SKEL_Matrix> InvWorldTransforms = new List <SKEL_Matrix>();
short index = 0;
Dictionary <SBBone, short> BoneToIndex = new Dictionary <SBBone, short>();
var OrderedBones = SortBones(Skeleton.Bones);
foreach (var bone in OrderedBones)
{
BoneToIndex.Add(bone, index);
var boneentry = new SKEL_BoneEntry();
boneentry.Name = bone.Name;
boneentry.Type = bone.Type;
boneentry.ID = index++;
boneentry.Type = 1;
boneentry.ParentID = -1;
if (bone.Parent != null)// && BoneToIndex.ContainsKey(bone.Parent))
{
boneentry.ParentID = (short)OrderedBones.IndexOf(bone.Parent);
}
BoneEntries.Add(boneentry);
Transforms.Add(TKMatrix_to_Skel(bone.Transform));
InvTransforms.Add(TKMatrix_to_Skel(bone.Transform.Inverted()));
WorldTransforms.Add(TKMatrix_to_Skel(bone.WorldTransform));
InvWorldTransforms.Add(TKMatrix_to_Skel(bone.InvWorldTransform));
}
skelFile.BoneEntries = BoneEntries.ToArray();
skelFile.Transform = Transforms.ToArray();
skelFile.InvTransform = InvTransforms.ToArray();
skelFile.WorldTransform = WorldTransforms.ToArray();
skelFile.InvWorldTransform = InvWorldTransforms.ToArray();
SSBH.TrySaveSSBHFile(FileName, skelFile);
}
public override void Open()
{
string ADJB = System.IO.Path.GetDirectoryName(AbsolutePath) + "/model.adjb";
System.Console.WriteLine(ADJB);
if (File.Exists(ADJB))
{
ExtendedMesh = new ADJB();
ExtendedMesh.Read(ADJB);
}
if (SSBH.TryParseSSBHFile(AbsolutePath, out ISSBH_File ssbhFile))
{
if (ssbhFile is MESH)
{
mesh = (MESH)ssbhFile;
}
}
}
/// <summary>
/// Creates a vertex accessor from given MESH filepath
/// </summary>
/// <param name="FilePath"></param>
public SSBHVertexAccessor(string meshFilePath)
{
if (SSBH.TryParseSSBHFile(meshFilePath, out ISSBH_File file))
{
if (file == null)
{
throw new FileNotFoundException("File was null");
}
if (file is MESH mesh)
{
meshFile = mesh;
}
else
{
throw new FormatException("Given file was not a MESH file");
}
}
}
private static void SerializeMatl(string inputPath, string outputPath, XmlSerializer serializer)
{
Console.WriteLine($"Converting {Path.GetFileName(inputPath)} to {outputPath}_out.xml...");
if (SSBH.TryParseSSBHFile(inputPath, out ISSBH_File 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 + "_out.xml", serial);
}
}
else
{
Console.WriteLine("Error reading matl file");
}
}
public static SBSkeleton Open(string FileName, SBScene Scene)
{
ISSBH_File File;
if (SSBH.TryParseSSBHFile(FileName, out File))
{
if (File is SKEL skel)
{
var Skeleton = new SBSkeleton();
Scene.Skeleton = Skeleton;
Dictionary <int, SBBone> idToBone = new Dictionary <int, SBBone>();
Dictionary <SBBone, int> needParent = new Dictionary <SBBone, int>();
foreach (var b in skel.BoneEntries)
{
SBBone bone = new SBBone();
bone.Name = b.Name;
bone.Type = b.Type;
bone.Transform = Skel_to_TKMatrix(skel.Transform[b.ID]);
idToBone.Add(b.ID, bone);
if (b.ParentID == -1)
{
Skeleton.AddRoot(bone);
}
else
{
needParent.Add(bone, b.ParentID);
}
}
foreach (var v in needParent)
{
v.Key.Parent = idToBone[v.Value];
}
return(Skeleton);
}
}
return(null);
}
/// <summary>
///
/// </summary>
/// <param name="FileName"></param>
public override void ExportSceneToFile(string FileName)
{
if (Model == null)
{
return;
}
string name = Path.GetDirectoryName(FileName) + "/" + Path.GetFileNameWithoutExtension(FileName);
string simpleName = Path.GetFileNameWithoutExtension(FileName);
SBConsole.WriteLine("Creating MODL...");
var modl = MODL_Loader.CreateMODLFile((SBUltimateModel)Model);
modl.ModelFileName = simpleName;
modl.SkeletonFileName = $"{simpleName}.nusktb";
modl.MeshString = $"{simpleName}.numshb";
modl.UnknownFileName = "";
modl.MaterialFileNames = new MODL_MaterialName[] { new MODL_MaterialName()
{
MaterialFileName = $"{simpleName}.numatb"
} };
SBConsole.WriteLine("Done");
SSBH.TrySaveSSBHFile(FileName, modl);
SBConsole.WriteLine($"Creating MESH... {name}.numshb");
var mesh = MESH_Loader.CreateMESH((SBUltimateModel)Model, (SBSkeleton)Skeleton);
SBConsole.WriteLine("Done");
SSBH.TrySaveSSBHFile(name + ".numshb", mesh);
SBConsole.WriteLine($"Creating SKEL.. {name}.nusktb");
SKEL_Loader.Save(name + ".nusktb", this);
SBConsole.WriteLine("Done");
//SBConsole.WriteLine("Creating MATL...");
}
/// <summary>
/// Generates and saves the new ANIM file
/// </summary>
/// <param name="fname"></param>
public void Save(string fname)
{
// Prep Anim File
animFile.Name = Path.GetFileName(fname);
animFile.Animations = groups.ToArray();
// Create Buffer
MemoryStream buffer = new MemoryStream();
using (BinaryWriter w = new BinaryWriter(buffer))
{
foreach (var animation in animFile.Animations)
{
foreach (var node in animation.Nodes)
{
foreach (var track in node.Tracks) // TODO: these nodes need to be in ordinal order
{
var values = trackToValues[track];
track.DataOffset = (uint)buffer.Position;
track.FrameCount = (uint)values.Count;
if (values.Count > 0)
{
track.Flags |= (uint)GetTrackTypeFlag(values[0]);
}
if (values.Count == 1)
{
if (animation.Type == ANIM_TYPE.Transform)
{
track.Flags |= (int)ANIM_TRACKFLAGS.ConstTransform;
}
else
{
track.Flags |= (int)ANIM_TRACKFLAGS.Constant;
}
track.FrameCount = 1;
WriteValues(w, (int)track.Flags, values);
}
else
{
if (WriteValues(w, (int)track.Flags, values))
{
track.Flags |= (int)ANIM_TRACKFLAGS.Compressed;
}
else
{
track.Flags |= (int)ANIM_TRACKFLAGS.Direct;
}
}
track.DataSize = (uint)(buffer.Position - track.DataOffset);
int padding = (int)(0x40 - (w.BaseStream.Position % 0x40));
w.Write(new byte[padding]);
//Console.WriteLine(w.BaseStream.Position.ToString("X") + " " + values.Count + " " + track.Flags.ToString("X"));
}
}
}
}
animFile.Buffer = buffer.ToArray();
buffer.Close();
buffer.Dispose();
SSBH.TrySaveSSBHFile(fname, animFile);
}
static void Main(string[] args)
{
/*string[] files = Directory.GetFiles("", "*.numshb*", SearchOption.AllDirectories);
*
* List<string> ErrorReading = new List<string>();
* List<string> VertexAttributes = new List<string>();
* int Unk8 = 0;
* int Bid = 0;
* int VersionM = 0;
* int Versionm = 0;
* foreach(string s in files)
* {
* ISSBH_File File;
* try
* {
* if (SSBH.TryParseSSBHFile(s, out File))
* {
* if (File is MESH)
* {
* VersionM = Math.Max(VersionM, ((MESH)File).VersionMajor);
* Versionm = Math.Max(Versionm, ((MESH)File).VersionMinor);
* foreach (MESH_Object o in ((MESH)File).Objects)
* {
* Unk8 = Math.Max(Unk8, o.Unk8);
* Bid = Math.Max(Bid, o.BID);
* foreach (MESH_Attribute a in o.Attributes)
* {
* if (!VertexAttributes.Contains(a.AttributeStrings[0].Name))
* VertexAttributes.Add(a.AttributeStrings[0].Name);
* }
* }
* }
* }
* }
* catch(Exception)
* {
* ErrorReading.Add(s);
* }
*
* }
*
* StreamWriter w = new StreamWriter(new FileStream("outmsh.txt", FileMode.Create));
*
* w.WriteLine("Unk8 " + Unk8.ToString("X"));
* w.WriteLine("M " + VersionM.ToString("X"));
* w.WriteLine(", " + Versionm.ToString("X"));
* w.WriteLine("BID " + Bid.ToString("X"));
* w.WriteLine("Attributes: ");
* foreach(string s in VertexAttributes)
* {
* w.WriteLine(s);
* }
*
* w.WriteLine("Errors: ");
* foreach (string s in ErrorReading)
* {
* w.WriteLine(s);
* }
*
* w.Close();*/
ISSBH_File File;
if (SSBH.TryParseSSBHFile(Directory.GetCurrentDirectory() + "//" + args[0], out File))
{
if (File is ANIM anim)
{
var decoder = new SSBHAnimTrackDecoder(anim);
XmlWriterSettings settings = new XmlWriterSettings
{
Indent = true,
IndentChars = " ",
NewLineChars = "\r\n",
NewLineHandling = NewLineHandling.Replace
};
string FileName = Directory.GetCurrentDirectory() + "//" + Path.GetDirectoryName(args[0]) + "\\" + Path.GetFileNameWithoutExtension(args[0]) + ".xml";
XmlWriter o = XmlWriter.Create(new FileStream(FileName, FileMode.Create), settings);
o.WriteStartDocument();
o.WriteStartElement("NamcoAnimation");
foreach (var an in anim.Animations)
{
o.WriteStartElement("Animation");
o.WriteAttributeString("Type", an.Type.ToString());
foreach (var node in an.Nodes)
{
o.WriteStartElement("Node");
o.WriteAttributeString("Name", node.Name);
foreach (var track in node.Tracks)
{
o.WriteStartElement("Track");
o.WriteAttributeString("Name", track.Name);
o.WriteAttributeString("FrameCount", track.FrameCount.ToString());
//o.WriteAttributeString("Flags", track.Flags.ToString("X"));
var values = decoder.ReadTrack(track);
if (values != null && values.Length > 0)
{
o.WriteAttributeString("Type", values[0].GetType().Name);
}
for (int i = 0; i < values.Length; i++)
{
o.WriteStartElement("Key");
o.WriteAttributeString("Frame", (i + 1).ToString());
o.WriteString(values[i].ToString());
o.WriteEndElement();
}
o.WriteEndElement();
}
o.WriteEndElement();
}
o.WriteEndElement();
}
o.WriteEndElement();
o.Close();
}
}
/*ISSBH_File File;
* if(SSBH.TryParseSSBHFile("", out File))
* {
* ExportFileAsXML("Test.xml", File);
* }*/
//Console.ReadLine();
}
/// <summary>
/// Loads the scene from a NUMDLB file
/// </summary>
/// <param name="FileName"></param>
public override void LoadFromFile(string FileName)
{
string folderPath = Path.GetDirectoryName(FileName);
ISSBH_File File;
if (!SSBH.TryParseSSBHFile(FileName, out File))
{
return;
}
MODL modl = (MODL)File;
string meshPath = "";
string skelPath = "";
string matlPath = "";
foreach (string file in Directory.EnumerateFiles(folderPath))
{
// load textures
if (file.EndsWith(".nutexb"))
{
NUTEX_Loader.Open(file, this);
}
string fileName = Path.GetFileName(file);
if (fileName.Equals(modl.SkeletonFileName))
{
skelPath = file;
}
if (fileName.Equals(modl.MeshString))
{
meshPath = file;
}
if (fileName.Equals(modl.MaterialFileNames[0].MaterialFileName))
{
matlPath = file;
}
}
// import order Skeleton+Textures->Materials->Mesh
// mesh needs to be loaded after skeleton
if (skelPath != "")
{
SBConsole.WriteLine($"Importing skeleton: {Path.GetFileName(skelPath)}");
SKEL_Loader.Open(skelPath, this);
}
if (matlPath != "")
{
SBConsole.WriteLine($"Importing materials: {Path.GetFileName(matlPath)}");
MATL_Loader.Open(matlPath, this);
}
if (meshPath != "")
{
SBConsole.WriteLine($"Importing mesh: {Path.GetFileName(meshPath)}");
MESH_Loader.Open(meshPath, this);
// set materials
foreach (var entry in modl.ModelEntries)
{
UltimateMaterial currentMaterial = null;
foreach (UltimateMaterial matentry in Materials)
{
if (matentry.Label.Equals(entry.MaterialName))
{
currentMaterial = matentry;
break;
}
}
if (currentMaterial == null)
{
continue;
}
int subindex = 0;
string prevMesh = "";
if (Model != null)
{
foreach (var mesh in Model.Meshes)
{
if (prevMesh.Equals(mesh.Name))
{
subindex++;
}
else
{
subindex = 0;
}
prevMesh = mesh.Name;
if (subindex == entry.SubIndex && mesh.Name.Equals(entry.MeshName))
{
mesh.Material = currentMaterial;
break;
}
}
}
}
}
}
/// <summary>
/// Load an ultimate mesh from file to the given scene
/// </summary>
/// <param name="FileName"></param>
/// <param name="Scene"></param>
public static void Open(string FileName, SBScene Scene)
{
ISSBH_File File;
if (SSBH.TryParseSSBHFile(FileName, out File))
{
if (File is MATL matl)
{
if (matl.MajorVersion != 1 && matl.MinorVersion != 6)
{
SBConsole.WriteLine($"Warning: Mesh Version {matl.MajorVersion}.{matl.MinorVersion} not supported");
}
var MaterialProps = typeof(UltimateMaterial).GetProperties();
// use dictionary for faster lookup
Dictionary <string, PropertyInfo> NameToProperty = new Dictionary <string, PropertyInfo>();
foreach (var prop in MaterialProps)
{
var attrName = prop.Name;
if (attrName != null)
{
NameToProperty.Add(attrName, prop);
}
}
foreach (var entry in matl.Entries)
{
UltimateMaterial material = new UltimateMaterial();
material.Name = entry.MaterialName;
material.Label = entry.MaterialLabel;
Scene.Materials.Add(material);
foreach (var attr in entry.Attributes)
{
if (NameToProperty.ContainsKey(attr.ParamID.ToString()))
{
var prop = NameToProperty[attr.ParamID.ToString()];
if (prop.PropertyType == typeof(SBMatAttrib <string>))
{
material.SetProperty(attr.ParamID.ToString(), attr.DataObject.ToString());
}
else
if (prop.PropertyType == typeof(SBMatAttrib <Vector4>))
{
material.SetProperty(attr.ParamID.ToString(), MATLVectorToGLVector((MatlAttribute.MatlVector4)attr.DataObject));
}
else
{
material.SetProperty(attr.ParamID.ToString(), attr.DataObject);
}
}
else
{
switch (attr.ParamID)
{
case MatlEnums.ParamId.RasterizerState0:
material.RasterizerState = (MatlAttribute.MatlRasterizerState)attr.DataObject;
break;
case MatlEnums.ParamId.BlendState0:
material.BlendState = (MatlAttribute.MatlBlendState)attr.DataObject;
break;
default:
//SBConsole.WriteLine("Extra Param: " + attr.ParamID.ToString() + " = " + attr.DataObject.ToString());
material.extraParams.Add(attr.ParamID, attr.DataObject);
break;
}
}
}
}
}
}
}
static void Main(string[] args)
{
/*string[] files = Directory.GetFiles("", "*.numshb*", SearchOption.AllDirectories);
*
* List<string> ErrorReading = new List<string>();
* List<string> VertexAttributes = new List<string>();
* int Unk8 = 0;
* int Bid = 0;
* int VersionM = 0;
* int Versionm = 0;
* foreach(string s in files)
* {
* ISSBH_File File;
* try
* {
* if (SSBH.TryParseSSBHFile(s, out File))
* {
* if (File is MESH)
* {
* VersionM = Math.Max(VersionM, ((MESH)File).VersionMajor);
* Versionm = Math.Max(Versionm, ((MESH)File).VersionMinor);
* foreach (MESH_Object o in ((MESH)File).Objects)
* {
* Unk8 = Math.Max(Unk8, o.Unk8);
* Bid = Math.Max(Bid, o.BID);
* foreach (MESH_Attribute a in o.Attributes)
* {
* if (!VertexAttributes.Contains(a.AttributeStrings[0].Name))
* VertexAttributes.Add(a.AttributeStrings[0].Name);
* }
* }
* }
* }
* }
* catch(Exception)
* {
* ErrorReading.Add(s);
* }
*
* }
*
* StreamWriter w = new StreamWriter(new FileStream("outmsh.txt", FileMode.Create));
*
* w.WriteLine("Unk8 " + Unk8.ToString("X"));
* w.WriteLine("M " + VersionM.ToString("X"));
* w.WriteLine(", " + Versionm.ToString("X"));
* w.WriteLine("BID " + Bid.ToString("X"));
* w.WriteLine("Attributes: ");
* foreach(string s in VertexAttributes)
* {
* w.WriteLine(s);
* }
*
* w.WriteLine("Errors: ");
* foreach (string s in ErrorReading)
* {
* w.WriteLine(s);
* }
*
* w.Close();*/
ISSBH_File File;
if (SSBH.TryParseSSBHFile("", out File))
{
ExportFileAsXML("Test.xml", File);
}
//Console.ReadLine();
}
