mirror of
https://github.com/KillzXGaming/Switch-Toolbox
synced 2024-12-23 19:33:10 +00:00
1276 lines
53 KiB
C#
1276 lines
53 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
using Switch_Toolbox;
|
|
using System.Windows.Forms;
|
|
using Switch_Toolbox.Library;
|
|
using Switch_Toolbox.Library.IO;
|
|
using Switch_Toolbox.Library.Forms;
|
|
using Switch_Toolbox.Library.Rendering;
|
|
using OpenTK;
|
|
|
|
namespace FirstPlugin
|
|
{
|
|
public class GFBMDL : TreeNodeFile, IFileFormat
|
|
{
|
|
public FileType FileType { get; set; } = FileType.Model;
|
|
|
|
public bool CanSave { get; set; }
|
|
public string[] Description { get; set; } = new string[] { "Graphic Model" };
|
|
public string[] Extension { get; set; } = new string[] { "*.gfbmdl" };
|
|
public string FileName { get; set; }
|
|
public string FilePath { get; set; }
|
|
public IFileInfo IFileInfo { get; set; }
|
|
|
|
public bool Identify(System.IO.Stream stream)
|
|
{
|
|
using (var reader = new Switch_Toolbox.Library.IO.FileReader(stream, true))
|
|
{
|
|
reader.ByteOrder = Syroot.BinaryData.ByteOrder.BigEndian;
|
|
|
|
bool IsMatch = reader.ReadUInt32() == 0x20000000;
|
|
reader.Position = 0;
|
|
|
|
return IsMatch;
|
|
}
|
|
}
|
|
|
|
public Type[] Types
|
|
{
|
|
get
|
|
{
|
|
List<Type> types = new List<Type>();
|
|
return types.ToArray();
|
|
}
|
|
}
|
|
|
|
Viewport viewport
|
|
{
|
|
get
|
|
{
|
|
var editor = LibraryGUI.Instance.GetObjectEditor();
|
|
return editor.GetViewport();
|
|
}
|
|
set
|
|
{
|
|
var editor = LibraryGUI.Instance.GetObjectEditor();
|
|
editor.LoadViewport(value);
|
|
}
|
|
}
|
|
|
|
bool DrawablesLoaded = false;
|
|
public override void OnClick(TreeView treeView)
|
|
{
|
|
if (Runtime.UseOpenGL)
|
|
{
|
|
if (viewport == null)
|
|
{
|
|
viewport = new Viewport(ObjectEditor.GetDrawableContainers());
|
|
viewport.Dock = DockStyle.Fill;
|
|
}
|
|
|
|
if (!DrawablesLoaded)
|
|
{
|
|
ObjectEditor.AddContainer(DrawableContainer);
|
|
DrawablesLoaded = true;
|
|
}
|
|
|
|
viewport.ReloadDrawables(DrawableContainer);
|
|
LibraryGUI.Instance.LoadEditor(viewport);
|
|
|
|
viewport.Text = Text;
|
|
}
|
|
}
|
|
|
|
public Header header;
|
|
public GFBMDL_Render Renderer;
|
|
|
|
public DrawableContainer DrawableContainer = new DrawableContainer();
|
|
|
|
public void Load(System.IO.Stream stream)
|
|
{
|
|
Text = FileName;
|
|
DrawableContainer.Name = FileName;
|
|
Renderer = new GFBMDL_Render();
|
|
|
|
header = new Header();
|
|
header.Read(new FileReader(stream), this);
|
|
|
|
ContextMenuStrip = new STContextMenuStrip();
|
|
ContextMenuStrip.Items.Add(new ToolStripMenuItem("Export Model", null, ExportModelAction, Keys.Control | Keys.E));
|
|
}
|
|
|
|
private void ExportModelAction(object sender, EventArgs args) {
|
|
ExportModel();
|
|
}
|
|
|
|
private void ExportModel()
|
|
{
|
|
SaveFileDialog sfd = new SaveFileDialog();
|
|
sfd.Filter = "Supported Formats|*.dae;";
|
|
if (sfd.ShowDialog() == DialogResult.OK)
|
|
{
|
|
ExportModel(sfd.FileName);
|
|
}
|
|
}
|
|
|
|
private void ExportModel(string FileName)
|
|
{
|
|
AssimpSaver assimp = new AssimpSaver();
|
|
ExportModelSettings settings = new ExportModelSettings();
|
|
|
|
var model = new STGenericModel();
|
|
model.Materials = header.GenericMaterials;
|
|
model.Objects = Renderer.Meshes;
|
|
|
|
assimp.SaveFromModel(model, FileName, new List<STGenericTexture>(), ((STSkeleton)DrawableContainer.Drawables[0]));
|
|
}
|
|
|
|
public void Unload()
|
|
{
|
|
|
|
}
|
|
|
|
public byte[] Save()
|
|
{
|
|
var mem = new System.IO.MemoryStream();
|
|
header.Write(new FileWriter(mem));
|
|
return mem.ToArray();
|
|
}
|
|
|
|
//Todo replace tedius offset handling with a class to store necessary data and methods to execute
|
|
public class Header
|
|
{
|
|
public STSkeleton Skeleton { get; set; }
|
|
|
|
public uint Version { get; set; }
|
|
public float[] Boundings { get; set; }
|
|
public List<string> TextureMaps = new List<string>();
|
|
public List<string> MaterialNames = new List<string>();
|
|
public List<VertexBuffer> VertexBuffers = new List<VertexBuffer>();
|
|
public List<VisGroup> VisualGroups = new List<VisGroup>();
|
|
public List<MaterialShaderData> Materials = new List<MaterialShaderData>();
|
|
|
|
public List<GFBMaterial> GenericMaterials = new List<GFBMaterial>();
|
|
|
|
public void Read(FileReader reader, GFBMDL Root)
|
|
{
|
|
Skeleton = new STSkeleton();
|
|
Root.DrawableContainer.Drawables.Add(Skeleton);
|
|
Root.DrawableContainer.Drawables.Add(Root.Renderer);
|
|
|
|
reader.SetByteOrder(false);
|
|
|
|
Version = reader.ReadUInt32();
|
|
Boundings = reader.ReadSingles(9);
|
|
long TextureOffset = reader.ReadOffset(true, typeof(uint));
|
|
long MaterialOffset = reader.ReadOffset(true, typeof(uint));
|
|
long Unknown1ffset = reader.ReadOffset(true, typeof(uint));
|
|
long Unknown2Offset = reader.ReadOffset(true, typeof(uint));
|
|
long ShaderOffset = reader.ReadOffset(true, typeof(uint));
|
|
long VisGroupOffset = reader.ReadOffset(true, typeof(uint));
|
|
long VerteBufferOffset = reader.ReadOffset(true, typeof(uint));
|
|
long BoneDataOffset = reader.ReadOffset(true, typeof(uint));
|
|
|
|
if (TextureOffset != 0)
|
|
{
|
|
reader.SeekBegin(TextureOffset);
|
|
uint Count = reader.ReadUInt32();
|
|
TextureMaps = reader.ReadNameOffsets(Count, true, typeof(uint), true);
|
|
}
|
|
|
|
if (MaterialOffset != 0)
|
|
{
|
|
reader.SeekBegin(MaterialOffset);
|
|
uint Count = reader.ReadUInt32();
|
|
MaterialNames = reader.ReadNameOffsets(Count, true, typeof(uint));
|
|
}
|
|
|
|
|
|
if (ShaderOffset != 0)
|
|
{
|
|
reader.SeekBegin(ShaderOffset);
|
|
uint Count = reader.ReadUInt32();
|
|
for (int i = 0; i < Count; i++)
|
|
{
|
|
MaterialShaderData shaderData = new MaterialShaderData();
|
|
shaderData.Read(reader);
|
|
Materials.Add(shaderData);
|
|
}
|
|
}
|
|
|
|
if (VisGroupOffset != 0)
|
|
{
|
|
reader.SeekBegin(VisGroupOffset);
|
|
uint Count = reader.ReadUInt32();
|
|
for (int i = 0; i < Count; i++)
|
|
{
|
|
VisGroup visualGroup = new VisGroup();
|
|
visualGroup.Read(reader);
|
|
VisualGroups.Add(visualGroup);
|
|
}
|
|
}
|
|
|
|
if (VerteBufferOffset != 0)
|
|
{
|
|
reader.SeekBegin(VerteBufferOffset);
|
|
uint Count = reader.ReadUInt32();
|
|
for (int i = 0; i < Count; i++)
|
|
{
|
|
VertexBuffer vertexBuffer = new VertexBuffer();
|
|
vertexBuffer.Read(reader);
|
|
VertexBuffers.Add(vertexBuffer);
|
|
}
|
|
}
|
|
|
|
if (BoneDataOffset != 0)
|
|
{
|
|
TreeNode SkeletonWrapper = new TreeNode("Skeleton");
|
|
Root.Nodes.Add(SkeletonWrapper);
|
|
|
|
reader.SeekBegin(BoneDataOffset);
|
|
uint Count = reader.ReadUInt32();
|
|
for (int i = 0; i < Count; i++)
|
|
{
|
|
var bone = new Bone(Skeleton);
|
|
bone.Read(reader);
|
|
Skeleton.bones.Add(bone);
|
|
}
|
|
|
|
foreach (var bone in Skeleton.bones)
|
|
{
|
|
if (bone.Parent == null)
|
|
SkeletonWrapper.Nodes.Add(bone);
|
|
}
|
|
}
|
|
|
|
TreeNode MaterialFolderWrapper = new TreeNode("Materials");
|
|
Root.Nodes.Add(MaterialFolderWrapper);
|
|
|
|
for (int i = 0; i < Materials.Count; i++)
|
|
{
|
|
GFBMaterial mat = new GFBMaterial(Root, Materials[i]);
|
|
mat.Text = Materials[i].Name;
|
|
|
|
int textureUnit = 1;
|
|
foreach (var textureMap in Materials[i].TextureMaps)
|
|
{
|
|
textureMap.Name = TextureMaps[(int)textureMap.Index];
|
|
|
|
STGenericMatTexture matTexture = new STGenericMatTexture();
|
|
matTexture.Name = textureMap.Name;
|
|
matTexture.textureUnit = textureUnit++;
|
|
matTexture.wrapModeS = 1;
|
|
matTexture.wrapModeT = 0;
|
|
|
|
if (textureMap.Effect == "Col0Tex")
|
|
{
|
|
matTexture.Type = STGenericMatTexture.TextureType.Diffuse;
|
|
}
|
|
|
|
mat.TextureMaps.Add(matTexture);
|
|
|
|
if (textureMap.Effect != string.Empty)
|
|
mat.Nodes.Add($"{textureMap.Name} ({textureMap.Effect})");
|
|
else
|
|
mat.Nodes.Add($"{textureMap.Name}");
|
|
}
|
|
|
|
GenericMaterials.Add(mat);
|
|
MaterialFolderWrapper.Nodes.Add(mat);
|
|
}
|
|
|
|
TreeNode VisualGroupWrapper = new TreeNode("Visual Groups");
|
|
Root.Nodes.Add(VisualGroupWrapper);
|
|
|
|
for (int i = 0; i < VisualGroups.Count; i++)
|
|
{
|
|
GFBMesh mesh = new GFBMesh(Root);
|
|
mesh.Checked = true;
|
|
mesh.ImageKey = "model";
|
|
mesh.SelectedImageKey = "model";
|
|
|
|
mesh.BoneIndex = (int)VisualGroups[i].BoneIndex;
|
|
mesh.Text = Skeleton.bones[(int)VisualGroups[i].BoneIndex].Text;
|
|
Root.Renderer.Meshes.Add(mesh);
|
|
|
|
var Buffer = VertexBuffers[i];
|
|
for (int v= 0; v < Buffer.Positions.Count; v++)
|
|
{
|
|
Vertex vertex = new Vertex();
|
|
vertex.pos = Buffer.Positions[v];
|
|
|
|
if (Buffer.Normals.Count > 0)
|
|
vertex.nrm = Buffer.Normals[v];
|
|
if (Buffer.TexCoord1.Count > 0)
|
|
vertex.uv0 = Buffer.TexCoord1[v];
|
|
if (Buffer.TexCoord2.Count > 0)
|
|
vertex.uv1 = Buffer.TexCoord2[v];
|
|
if (Buffer.TexCoord3.Count > 0)
|
|
vertex.uv2 = Buffer.TexCoord3[v];
|
|
if (Buffer.Weights.Count > 0)
|
|
vertex.boneWeights = new List<float>(Buffer.Weights[v]);
|
|
if (Buffer.BoneIndex.Count > 0)
|
|
vertex.boneIds = new List<int>(Buffer.BoneIndex[v]);
|
|
if (Buffer.Colors1.Count > 0)
|
|
vertex.col = Buffer.Colors1[v];
|
|
if (Buffer.Binormals.Count > 0)
|
|
vertex.bitan = Buffer.Binormals[v];
|
|
|
|
mesh.vertices.Add(vertex);
|
|
}
|
|
|
|
mesh.FlipUvsVertical();
|
|
|
|
int polyIndex = 0;
|
|
foreach (var group in Buffer.PolygonGroups)
|
|
{
|
|
TreeNode polyWrapper = new TreeNode($"Polygon Group {polyIndex++}");
|
|
polyWrapper.ImageKey = "mesh";
|
|
polyWrapper.SelectedImageKey = "mesh";
|
|
|
|
var polygonGroup = new STGenericPolygonGroup();
|
|
polygonGroup.faces = group.Faces.ToList();
|
|
polygonGroup.MaterialIndex = group.MaterialID;
|
|
mesh.PolygonGroups.Add(polygonGroup);
|
|
|
|
mesh.Nodes.Add(polyWrapper);
|
|
}
|
|
|
|
VisualGroupWrapper.Nodes.Add(mesh);
|
|
}
|
|
|
|
|
|
Skeleton.update();
|
|
Skeleton.reset();
|
|
}
|
|
|
|
public void Write(FileWriter writer)
|
|
{
|
|
writer.Write(Version);
|
|
}
|
|
}
|
|
|
|
public class VisGroup
|
|
{
|
|
public Vector3 BoundingBoxMax = new Vector3(0);
|
|
public Vector3 BoundingBoxMin = new Vector3(0);
|
|
|
|
public uint BoneIndex { get; set; }
|
|
|
|
public void Read(FileReader reader)
|
|
{
|
|
long DataPosition = reader.Position;
|
|
var DataOffset = reader.ReadOffset(true, typeof(uint));
|
|
|
|
reader.SeekBegin(DataOffset);
|
|
long InfoPosition = reader.Position;
|
|
|
|
int InfoOffset = reader.ReadInt32();
|
|
|
|
//Read the info section for position data
|
|
reader.SeekBegin(InfoPosition - InfoOffset);
|
|
ushort HeaderLength = reader.ReadUInt16();
|
|
ushort UnknownPosition = 0;
|
|
ushort VisBonePosition = 0;
|
|
ushort Unknown2Position = 0;
|
|
ushort VisBoundsPosition = 0;
|
|
ushort Unknown3Position = 0;
|
|
|
|
if (HeaderLength == 0x0A)
|
|
{
|
|
UnknownPosition = reader.ReadUInt16();
|
|
VisBonePosition = reader.ReadUInt16();
|
|
Unknown2Position = reader.ReadUInt16();
|
|
VisBoundsPosition = reader.ReadUInt16();
|
|
}
|
|
else if (HeaderLength == 0x0C)
|
|
{
|
|
UnknownPosition = reader.ReadUInt16();
|
|
VisBonePosition = reader.ReadUInt16();
|
|
Unknown2Position = reader.ReadUInt16();
|
|
VisBoundsPosition = reader.ReadUInt16();
|
|
Unknown3Position = reader.ReadUInt16();
|
|
}
|
|
else
|
|
throw new Exception("Unexpected Header Length! " + HeaderLength);
|
|
|
|
if (VisBoundsPosition != 0)
|
|
{
|
|
reader.SeekBegin(InfoPosition + VisBoundsPosition);
|
|
BoundingBoxMin = reader.ReadVec3();
|
|
BoundingBoxMax = reader.ReadVec3();
|
|
}
|
|
|
|
if (VisBonePosition != 0)
|
|
{
|
|
reader.SeekBegin(InfoPosition + VisBonePosition);
|
|
BoneIndex = reader.ReadUInt32();
|
|
}
|
|
|
|
//Seek back to next in array
|
|
reader.SeekBegin(DataPosition + sizeof(uint));
|
|
}
|
|
}
|
|
|
|
public class MaterialShaderData
|
|
{
|
|
public string Name { get; set; }
|
|
public string ShaderName { get; set; }
|
|
|
|
public List<TextureMap> TextureMaps = new List<TextureMap>();
|
|
|
|
public Dictionary<string, SwitchParam> SwitchParams = new Dictionary<string, SwitchParam>();
|
|
public Dictionary<string, ValueParam> ValueParams = new Dictionary<string, ValueParam>();
|
|
public Dictionary<string, ColorParam> ColorParams = new Dictionary<string, ColorParam>();
|
|
|
|
public void Read(FileReader reader)
|
|
{
|
|
long DataPosition = reader.Position;
|
|
var DataOffset = reader.ReadOffset(true, typeof(uint));
|
|
|
|
reader.SeekBegin(DataOffset);
|
|
long InfoPosition = reader.Position;
|
|
|
|
int InfoOffset = reader.ReadInt32();
|
|
|
|
//Read the info section for position data
|
|
reader.SeekBegin(InfoPosition - InfoOffset);
|
|
ushort HeaderLength = reader.ReadUInt16();
|
|
ushort ShaderPropertyPosition = reader.ReadUInt16();
|
|
ushort MaterialStringNamePosition = reader.ReadUInt16();
|
|
ushort ShaderStringNamePosition = reader.ReadUInt16();
|
|
ushort Unknown1Position = reader.ReadUInt16();
|
|
ushort Unknown2Position = reader.ReadUInt16();
|
|
ushort Unknown3Position = reader.ReadUInt16();
|
|
ushort ShaderParam1Position = reader.ReadUInt16();
|
|
ushort ShaderParam2Position = reader.ReadUInt16();
|
|
ushort ShaderParam3Position = reader.ReadUInt16();
|
|
ushort ShaderParam4Position = reader.ReadUInt16();
|
|
ushort ShaderParam5Position = reader.ReadUInt16();
|
|
ushort ShaderParam6Position = reader.ReadUInt16();
|
|
ushort TextureMapsPosition = reader.ReadUInt16();
|
|
ushort ShaderParamAPosition = reader.ReadUInt16();
|
|
ushort ShaderParamBPosition = reader.ReadUInt16();
|
|
ushort ShaderParamCPosition = reader.ReadUInt16();
|
|
ushort Unknown4Position = reader.ReadUInt16();
|
|
ushort Unknown5Position = reader.ReadUInt16();
|
|
ushort Unknown6Position = reader.ReadUInt16();
|
|
ushort Unknown7Position = reader.ReadUInt16();
|
|
ushort Unknown8Position = reader.ReadUInt16();
|
|
ushort ShaderProperty2Position = reader.ReadUInt16();
|
|
|
|
if (MaterialStringNamePosition != 0)
|
|
{
|
|
reader.SeekBegin(InfoPosition + MaterialStringNamePosition);
|
|
Name = reader.ReadNameOffset(true, typeof(uint), true);
|
|
}
|
|
|
|
if (ShaderStringNamePosition != 0)
|
|
{
|
|
reader.SeekBegin(InfoPosition + ShaderStringNamePosition);
|
|
ShaderName = reader.ReadNameOffset(true, typeof(uint), true);
|
|
}
|
|
|
|
if (ShaderParamAPosition != 0)
|
|
{
|
|
reader.SeekBegin(InfoPosition + ShaderParamAPosition);
|
|
var ParamOffset = reader.ReadOffset(true, typeof(uint));
|
|
reader.SeekBegin(ParamOffset);
|
|
|
|
uint Count = reader.ReadUInt32();
|
|
for (int i = 0; i < Count; i++)
|
|
{
|
|
SwitchParam param = new SwitchParam();
|
|
param.ReadParam(reader);
|
|
SwitchParams.Add(param.Name, param);
|
|
}
|
|
}
|
|
|
|
if (ShaderParamBPosition != 0)
|
|
{
|
|
reader.SeekBegin(InfoPosition + ShaderParamBPosition);
|
|
var ParamOffset = reader.ReadOffset(true, typeof(uint));
|
|
reader.SeekBegin(ParamOffset);
|
|
|
|
uint Count = reader.ReadUInt32();
|
|
for (int i = 0; i < Count; i++)
|
|
{
|
|
ValueParam param = new ValueParam();
|
|
param.ReadParam(reader);
|
|
ValueParams.Add(param.Name, param);
|
|
}
|
|
}
|
|
|
|
|
|
if (ShaderParamCPosition != 0)
|
|
{
|
|
reader.SeekBegin(InfoPosition + ShaderParamCPosition);
|
|
var ParamOffset = reader.ReadOffset(true, typeof(uint));
|
|
reader.SeekBegin(ParamOffset);
|
|
|
|
uint Count = reader.ReadUInt32();
|
|
for (int i = 0; i < Count; i++)
|
|
{
|
|
ColorParam param = new ColorParam();
|
|
param.ReadParam(reader);
|
|
ColorParams.Add(param.Name, param);
|
|
}
|
|
}
|
|
|
|
|
|
if (TextureMapsPosition != 0)
|
|
{
|
|
reader.SeekBegin(InfoPosition + TextureMapsPosition);
|
|
var TextureMapOffset = reader.ReadOffset(true, typeof(uint));
|
|
reader.SeekBegin(TextureMapOffset);
|
|
|
|
uint Count = reader.ReadUInt32();
|
|
for (int i = 0; i < Count; i++)
|
|
{
|
|
TextureMap textureMap = new TextureMap();
|
|
textureMap.Read(reader);
|
|
TextureMaps.Add(textureMap);
|
|
}
|
|
}
|
|
|
|
//Seek back to next in array
|
|
reader.SeekBegin(DataPosition + sizeof(uint));
|
|
}
|
|
}
|
|
|
|
public class ColorParam : BaseParam
|
|
{
|
|
public void ReadParam(FileReader reader)
|
|
{
|
|
base.Read(reader);
|
|
|
|
if (ValuePosition != 0)
|
|
{
|
|
reader.SeekBegin(InfoPosition + ValuePosition);
|
|
if (Format == 4)
|
|
Value = new Vector3(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
|
|
else if (Format == 8)
|
|
Value = new Vector3(reader.ReadUInt32(), reader.ReadUInt32(), reader.ReadUInt32());
|
|
else
|
|
throw new Exception("Unknown format for switch param! " + Format);
|
|
}
|
|
else
|
|
Value = 0;
|
|
|
|
Console.WriteLine($"Param {Name} {Value}");
|
|
|
|
//Seek back to next in array
|
|
reader.SeekBegin(DataPosition + sizeof(uint));
|
|
}
|
|
}
|
|
|
|
public class ValueParam : BaseParam
|
|
{
|
|
public void ReadParam(FileReader reader)
|
|
{
|
|
base.Read(reader);
|
|
|
|
if (ValuePosition != 0)
|
|
{
|
|
reader.SeekBegin(InfoPosition + ValuePosition);
|
|
if (Format == 4)
|
|
Value = reader.ReadUInt32();
|
|
else if (Format == 8)
|
|
Value = reader.ReadSingle();
|
|
else
|
|
throw new Exception("Unknown format for switch param! " + Format);
|
|
}
|
|
else
|
|
Value = 0;
|
|
|
|
//Seek back to next in array
|
|
reader.SeekBegin(DataPosition + sizeof(uint));
|
|
}
|
|
}
|
|
|
|
public class SwitchParam : BaseParam
|
|
{
|
|
public void ReadParam(FileReader reader)
|
|
{
|
|
base.Read(reader);
|
|
|
|
if (ValuePosition != 0)
|
|
{
|
|
reader.SeekBegin(InfoPosition + ValuePosition);
|
|
if (Format == 4)
|
|
Value = (reader.ReadByte() == 1);
|
|
else
|
|
throw new Exception("Unknown format for switch param! " + Format);
|
|
}
|
|
else
|
|
Value = false;
|
|
|
|
Console.WriteLine($"Param {Name} {Value}");
|
|
|
|
//Seek back to next in array
|
|
reader.SeekBegin(DataPosition + sizeof(uint));
|
|
}
|
|
}
|
|
|
|
public class BaseParam
|
|
{
|
|
public string Effect { get; set; }
|
|
public string Name { get; set; }
|
|
|
|
public uint Index { get; set; } = 0;
|
|
|
|
public uint Format { get; set; }
|
|
|
|
public object Value { get; set; }
|
|
|
|
internal long DataPosition;
|
|
internal long InfoPosition;
|
|
|
|
internal ushort NamePosition;
|
|
internal ushort FormatPosition;
|
|
internal ushort ValuePosition;
|
|
|
|
public void Read(FileReader reader)
|
|
{
|
|
DataPosition = reader.Position;
|
|
var DataOffset = reader.ReadOffset(true, typeof(uint));
|
|
|
|
reader.SeekBegin(DataOffset);
|
|
InfoPosition = reader.Position;
|
|
int InfoOffset = reader.ReadInt32();
|
|
|
|
//Read the info section for position data
|
|
reader.SeekBegin(InfoPosition - InfoOffset);
|
|
ushort HeaderSize = reader.ReadUInt16();
|
|
NamePosition = 0;
|
|
FormatPosition = 0;
|
|
ValuePosition = 0;
|
|
|
|
if (HeaderSize == 0x06)
|
|
{
|
|
NamePosition = reader.ReadUInt16();
|
|
FormatPosition = reader.ReadUInt16();
|
|
}
|
|
else if (HeaderSize == 0x08)
|
|
{
|
|
NamePosition = reader.ReadUInt16();
|
|
FormatPosition = reader.ReadUInt16();
|
|
ValuePosition = reader.ReadUInt16();
|
|
}
|
|
else
|
|
throw new Exception("Unexpected header size! " + HeaderSize);
|
|
|
|
if (NamePosition != 0)
|
|
{
|
|
reader.SeekBegin(InfoPosition + NamePosition);
|
|
uint NameLength = reader.ReadUInt32();
|
|
Name = reader.ReadString((int)NameLength);
|
|
}
|
|
|
|
if (FormatPosition != 0)
|
|
{
|
|
reader.SeekBegin(InfoPosition + FormatPosition);
|
|
Format = reader.ReadUInt32();
|
|
}
|
|
}
|
|
}
|
|
|
|
public class TextureMap
|
|
{
|
|
public string Effect { get; set; }
|
|
public string Name { get; set; }
|
|
|
|
public uint Index { get; set; } = 0;
|
|
|
|
public void Read(FileReader reader)
|
|
{
|
|
long DataPosition = reader.Position;
|
|
var DataOffset = reader.ReadOffset(true, typeof(uint));
|
|
|
|
reader.SeekBegin(DataOffset);
|
|
long InfoPosition = reader.Position;
|
|
int InfoOffset = reader.ReadInt32();
|
|
|
|
//Read the info section for position data
|
|
reader.SeekBegin(InfoPosition - InfoOffset);
|
|
ushort HeaderSize = reader.ReadUInt16();
|
|
ushort EffectPosition = 0;
|
|
ushort UnknownPosition = 0;
|
|
ushort IdPosition = 0;
|
|
ushort UnknownPosition2 = 0;
|
|
|
|
if (HeaderSize == 0x0A)
|
|
{
|
|
EffectPosition = reader.ReadUInt16();
|
|
UnknownPosition = reader.ReadUInt16();
|
|
IdPosition = reader.ReadUInt16();
|
|
UnknownPosition2 = reader.ReadUInt16();
|
|
}
|
|
else
|
|
throw new Exception("Unexpected header size! " + HeaderSize);
|
|
|
|
if (EffectPosition != 0)
|
|
{
|
|
reader.SeekBegin(InfoPosition + EffectPosition);
|
|
uint NameLength = reader.ReadUInt32();
|
|
Effect = reader.ReadString((int)NameLength);
|
|
}
|
|
|
|
if (IdPosition != 0)
|
|
{
|
|
reader.SeekBegin(InfoPosition + IdPosition);
|
|
Index = reader.ReadUInt32();
|
|
}
|
|
|
|
//Seek back to next in array
|
|
reader.SeekBegin(DataPosition + sizeof(uint));
|
|
}
|
|
}
|
|
|
|
public class VertexBuffer
|
|
{
|
|
public List<VertexAttribute> Attributes = new List<VertexAttribute>();
|
|
public List<PolygonGroup> PolygonGroups = new List<PolygonGroup>();
|
|
|
|
public List<Vector3> Positions = new List<Vector3>();
|
|
public List<Vector3> Normals = new List<Vector3>();
|
|
public List<Vector2> TexCoord1 = new List<Vector2>();
|
|
public List<Vector2> TexCoord2 = new List<Vector2>();
|
|
public List<Vector2> TexCoord3 = new List<Vector2>();
|
|
public List<Vector2> TexCoord4 = new List<Vector2>();
|
|
public List<int[]> BoneIndex = new List<int[]>();
|
|
public List<float[]> Weights = new List<float[]>();
|
|
public List<Vector4> Colors1 = new List<Vector4>();
|
|
public List<Vector4> Colors2 = new List<Vector4>();
|
|
public List<Vector4> Binormals = new List<Vector4>();
|
|
|
|
public void Read(FileReader reader)
|
|
{
|
|
long DataPosition = reader.Position;
|
|
var VertexBufferDataOffset = reader.ReadOffset(true, typeof(uint));
|
|
|
|
reader.SeekBegin(VertexBufferDataOffset);
|
|
long InfoPosition = reader.Position;
|
|
int InfoOffset = reader.ReadInt32();
|
|
|
|
//Read the info section for position data
|
|
reader.SeekBegin(InfoPosition - InfoOffset);
|
|
ushort InfoSize = reader.ReadUInt16();
|
|
ushort VerticesPosition = 0;
|
|
ushort FacesPosition = 0;
|
|
ushort AttributeInfoPosition = 0;
|
|
ushort BufferUnknownPosition = 0;
|
|
|
|
if (InfoSize == 0x0A)
|
|
{
|
|
BufferUnknownPosition = reader.ReadUInt16();
|
|
FacesPosition = reader.ReadUInt16();
|
|
AttributeInfoPosition = reader.ReadUInt16();
|
|
VerticesPosition = reader.ReadUInt16();
|
|
}
|
|
else
|
|
throw new Exception("Unexpected Vertex Buffer Info Header Size! " + InfoSize);
|
|
|
|
uint VertBufferStride = 0;
|
|
|
|
if (AttributeInfoPosition != 0)
|
|
{
|
|
reader.SeekBegin(InfoPosition + AttributeInfoPosition);
|
|
var AttributeOffset = reader.ReadOffset(true, typeof(uint));
|
|
|
|
reader.SeekBegin(AttributeOffset);
|
|
uint AttributeCount = reader.ReadUInt32();
|
|
|
|
for (int i = 0; i < AttributeCount; i++)
|
|
{
|
|
var attribute = new VertexAttribute();
|
|
attribute.Read(reader);
|
|
Attributes.Add(attribute);
|
|
|
|
switch (attribute.Type)
|
|
{
|
|
case VertexAttribute.BufferType.Position:
|
|
if (attribute.Format == VertexAttribute.BufferFormat.HalfFloat)
|
|
VertBufferStride += 0x08;
|
|
else if (attribute.Format == VertexAttribute.BufferFormat.Float)
|
|
VertBufferStride += 0x0C;
|
|
else
|
|
throw new Exception($"Unknown Combination! {attribute.Type} {attribute.Format}");
|
|
break;
|
|
case VertexAttribute.BufferType.Normal:
|
|
if (attribute.Format == VertexAttribute.BufferFormat.HalfFloat)
|
|
VertBufferStride += 0x08;
|
|
else if (attribute.Format == VertexAttribute.BufferFormat.Float)
|
|
VertBufferStride += 0x0C;
|
|
else
|
|
throw new Exception($"Unknown Combination! {attribute.Type} {attribute.Format}");
|
|
break;
|
|
case VertexAttribute.BufferType.Binormal:
|
|
if (attribute.Format == VertexAttribute.BufferFormat.HalfFloat)
|
|
VertBufferStride += 0x08;
|
|
else if (attribute.Format == VertexAttribute.BufferFormat.Float)
|
|
VertBufferStride += 0x0C;
|
|
else
|
|
throw new Exception($"Unknown Combination! {attribute.Type} {attribute.Format}");
|
|
break;
|
|
case VertexAttribute.BufferType.TexCoord1:
|
|
case VertexAttribute.BufferType.TexCoord2:
|
|
case VertexAttribute.BufferType.TexCoord3:
|
|
case VertexAttribute.BufferType.TexCoord4:
|
|
if (attribute.Format == VertexAttribute.BufferFormat.HalfFloat)
|
|
VertBufferStride += 0x04;
|
|
else if (attribute.Format == VertexAttribute.BufferFormat.Float)
|
|
VertBufferStride += 0x08;
|
|
else
|
|
throw new Exception($"Unknown Combination! {attribute.Type} {attribute.Format}");
|
|
break;
|
|
case VertexAttribute.BufferType.Color1:
|
|
case VertexAttribute.BufferType.Color2:
|
|
if (attribute.Format == VertexAttribute.BufferFormat.Byte)
|
|
VertBufferStride += 0x04;
|
|
else
|
|
throw new Exception($"Unknown Combination! {attribute.Type} {attribute.Format}");
|
|
break;
|
|
case VertexAttribute.BufferType.BoneIndex:
|
|
if (attribute.Format == VertexAttribute.BufferFormat.Short)
|
|
VertBufferStride += 0x08;
|
|
else if (attribute.Format == VertexAttribute.BufferFormat.Byte)
|
|
VertBufferStride += 0x04;
|
|
else
|
|
throw new Exception($"Unknown Combination! {attribute.Type} {attribute.Format}");
|
|
break;
|
|
case VertexAttribute.BufferType.Weights:
|
|
if (attribute.Format == VertexAttribute.BufferFormat.BytesAsFloat)
|
|
VertBufferStride += 0x04;
|
|
else
|
|
throw new Exception($"Unknown Combination! {attribute.Type} {attribute.Format}");
|
|
break;
|
|
}
|
|
|
|
Console.WriteLine($"{attribute.Format} {attribute.Type} VertBufferStride {VertBufferStride}");
|
|
}
|
|
}
|
|
|
|
if (FacesPosition != 0)
|
|
{
|
|
reader.SeekBegin(InfoPosition + FacesPosition);
|
|
var BufferOffset = reader.ReadOffset(true, typeof(uint));
|
|
|
|
reader.SeekBegin(BufferOffset);
|
|
uint GroupCount = reader.ReadUInt32();
|
|
|
|
for (int i = 0; i < GroupCount; i++)
|
|
{
|
|
var polygonGroup = new PolygonGroup();
|
|
polygonGroup.Read(reader);
|
|
PolygonGroups.Add(polygonGroup);
|
|
}
|
|
}
|
|
|
|
if (VerticesPosition != 0)
|
|
{
|
|
reader.SeekBegin(InfoPosition + VerticesPosition);
|
|
var VertexOffset = reader.ReadOffset(true, typeof(uint));
|
|
|
|
reader.SeekBegin(VertexOffset);
|
|
uint VertexBufferSize = reader.ReadUInt32();
|
|
|
|
for (int v = 0; v < VertexBufferSize / VertBufferStride; v++)
|
|
{
|
|
for (int att = 0; att < Attributes.Count; att++)
|
|
{
|
|
switch (Attributes[att].Type)
|
|
{
|
|
case VertexAttribute.BufferType.Position:
|
|
var pos = ParseBuffer(reader, Attributes[att].Format, Attributes[att].Type);
|
|
Positions.Add(new Vector3(pos.X, pos.Y, pos.Z));
|
|
break;
|
|
case VertexAttribute.BufferType.Normal:
|
|
var normal = ParseBuffer(reader, Attributes[att].Format, Attributes[att].Type);
|
|
Normals.Add(new Vector3(normal.X, normal.Y, normal.Z));
|
|
break;
|
|
case VertexAttribute.BufferType.TexCoord1:
|
|
var texcoord1 = ParseBuffer(reader, Attributes[att].Format, Attributes[att].Type);
|
|
TexCoord1.Add(new Vector2(texcoord1.X, texcoord1.Y));
|
|
break;
|
|
case VertexAttribute.BufferType.TexCoord2:
|
|
var texcoord2 = ParseBuffer(reader, Attributes[att].Format, Attributes[att].Type);
|
|
TexCoord2.Add(new Vector2(texcoord2.X, texcoord2.Y));
|
|
break;
|
|
case VertexAttribute.BufferType.TexCoord3:
|
|
var texcoord3 = ParseBuffer(reader, Attributes[att].Format, Attributes[att].Type);
|
|
TexCoord3.Add(new Vector2(texcoord3.X, texcoord3.Y));
|
|
break;
|
|
case VertexAttribute.BufferType.TexCoord4:
|
|
var texcoord4 = ParseBuffer(reader, Attributes[att].Format, Attributes[att].Type);
|
|
TexCoord4.Add(new Vector2(texcoord4.X, texcoord4.Y));
|
|
break;
|
|
case VertexAttribute.BufferType.Weights:
|
|
var weights = ParseBuffer(reader, Attributes[att].Format, Attributes[att].Type);
|
|
Weights.Add(new float[] { weights.X, weights.Y, weights.Z, weights.W });
|
|
break;
|
|
case VertexAttribute.BufferType.BoneIndex:
|
|
var boneIndices = ParseBuffer(reader, Attributes[att].Format, Attributes[att].Type);
|
|
BoneIndex.Add(new int[] { (int)boneIndices.X, (int)boneIndices.Y, (int)boneIndices.Z, (int)boneIndices.W });
|
|
break;
|
|
case VertexAttribute.BufferType.Color1:
|
|
var colors1 = ParseBuffer(reader, Attributes[att].Format, Attributes[att].Type);
|
|
Colors1.Add(new Vector4(colors1.X, colors1.Y, colors1.Z, colors1.W));
|
|
break;
|
|
case VertexAttribute.BufferType.Color2:
|
|
var colors2 = ParseBuffer(reader, Attributes[att].Format, Attributes[att].Type);
|
|
Colors2.Add(new Vector4(colors2.X, colors2.Y, colors2.Z, colors2.W));
|
|
break;
|
|
case VertexAttribute.BufferType.Binormal:
|
|
var binormals = ParseBuffer(reader, Attributes[att].Format, Attributes[att].Type);
|
|
Binormals.Add(new Vector4(binormals.X, binormals.Y, binormals.Z, binormals.W));
|
|
break;
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//Seek back to next in array
|
|
reader.SeekBegin(DataPosition + sizeof(uint));
|
|
}
|
|
|
|
private Vector4 ParseBuffer(FileReader reader, VertexAttribute.BufferFormat Format, VertexAttribute.BufferType AttributeType)
|
|
{
|
|
if (AttributeType == VertexAttribute.BufferType.Position)
|
|
{
|
|
switch (Format)
|
|
{
|
|
case VertexAttribute.BufferFormat.Float:
|
|
return new Vector4(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle(), 0);
|
|
case VertexAttribute.BufferFormat.HalfFloat:
|
|
return new Vector4(reader.ReadHalfSingle(), reader.ReadHalfSingle(),
|
|
reader.ReadHalfSingle(), reader.ReadHalfSingle());
|
|
default:
|
|
throw new Exception($"Unknown Combination! {AttributeType} {Format}");
|
|
}
|
|
}
|
|
else if (AttributeType == VertexAttribute.BufferType.Normal)
|
|
{
|
|
switch (Format)
|
|
{
|
|
case VertexAttribute.BufferFormat.Float:
|
|
return new Vector4(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle(), 0);
|
|
case VertexAttribute.BufferFormat.HalfFloat:
|
|
return new Vector4(reader.ReadHalfSingle(), reader.ReadHalfSingle(),
|
|
reader.ReadHalfSingle(), reader.ReadHalfSingle());
|
|
default:
|
|
throw new Exception($"Unknown Combination! {AttributeType} {Format}");
|
|
}
|
|
}
|
|
else if (AttributeType == VertexAttribute.BufferType.Binormal)
|
|
{
|
|
switch (Format)
|
|
{
|
|
case VertexAttribute.BufferFormat.Float:
|
|
return new Vector4(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle(), 0);
|
|
case VertexAttribute.BufferFormat.HalfFloat:
|
|
return new Vector4(reader.ReadHalfSingle(), reader.ReadHalfSingle(),
|
|
reader.ReadHalfSingle(), reader.ReadHalfSingle());
|
|
default:
|
|
throw new Exception($"Unknown Combination! {AttributeType} {Format}");
|
|
}
|
|
}
|
|
else if (AttributeType == VertexAttribute.BufferType.TexCoord1 ||
|
|
AttributeType == VertexAttribute.BufferType.TexCoord2 ||
|
|
AttributeType == VertexAttribute.BufferType.TexCoord3 ||
|
|
AttributeType == VertexAttribute.BufferType.TexCoord4)
|
|
{
|
|
switch (Format)
|
|
{
|
|
case VertexAttribute.BufferFormat.Float:
|
|
return new Vector4(reader.ReadSingle(), reader.ReadSingle(), 0, 0);
|
|
case VertexAttribute.BufferFormat.HalfFloat:
|
|
return new Vector4(reader.ReadHalfSingle(), reader.ReadHalfSingle(), 0, 0);
|
|
default:
|
|
throw new Exception($"Unknown Combination! {AttributeType} {Format}");
|
|
}
|
|
}
|
|
else if (AttributeType == VertexAttribute.BufferType.Color1 ||
|
|
AttributeType == VertexAttribute.BufferType.Color2)
|
|
{
|
|
switch (Format)
|
|
{
|
|
case VertexAttribute.BufferFormat.Byte:
|
|
return new Vector4(reader.ReadByte(), reader.ReadByte(), reader.ReadByte(), reader.ReadByte());
|
|
default:
|
|
throw new Exception($"Unknown Combination! {AttributeType} {Format}");
|
|
}
|
|
}
|
|
else if (AttributeType == VertexAttribute.BufferType.BoneIndex)
|
|
{
|
|
switch (Format)
|
|
{
|
|
case VertexAttribute.BufferFormat.Short:
|
|
return new Vector4(reader.ReadInt16(), reader.ReadInt16(), reader.ReadInt16(), reader.ReadInt16());
|
|
case VertexAttribute.BufferFormat.Byte:
|
|
return new Vector4(reader.ReadByte(), reader.ReadByte(), reader.ReadByte(), reader.ReadByte());
|
|
default:
|
|
throw new Exception($"Unknown Combination! {AttributeType} {Format}");
|
|
}
|
|
}
|
|
else if (AttributeType == VertexAttribute.BufferType.Weights)
|
|
{
|
|
switch (Format)
|
|
{
|
|
case VertexAttribute.BufferFormat.BytesAsFloat:
|
|
return new Vector4(reader.ReadByteAsFloat(), reader.ReadByteAsFloat(),
|
|
reader.ReadByteAsFloat(), reader.ReadByteAsFloat());
|
|
default:
|
|
throw new Exception($"Unknown Combination! {AttributeType} {Format}");
|
|
}
|
|
}
|
|
|
|
return new Vector4(0);
|
|
}
|
|
}
|
|
|
|
//Represents an offset which points to another
|
|
public class OffsetInfo
|
|
{
|
|
|
|
}
|
|
|
|
public class PolygonGroup
|
|
{
|
|
public int MaterialID { get; set; }
|
|
public int[] Faces { get; set; }
|
|
|
|
public void Read(FileReader reader)
|
|
{
|
|
long DataPosition = reader.Position;
|
|
var DataOffset = reader.ReadOffset(true, typeof(uint));
|
|
|
|
reader.SeekBegin(DataOffset);
|
|
long InfoPosition = reader.Position;
|
|
|
|
int InfoOffset = reader.ReadInt32();
|
|
|
|
//Read the info section for position data
|
|
reader.SeekBegin(InfoPosition - InfoOffset);
|
|
ushort PolygonHeaderSize = reader.ReadUInt16();
|
|
ushort PolygonStartPosition = 0;
|
|
ushort PolgonMaterialId = 0;
|
|
ushort PolygonUnknown = 0;
|
|
|
|
if (PolygonHeaderSize == 0x08)
|
|
{
|
|
PolygonStartPosition = reader.ReadUInt16();
|
|
PolgonMaterialId = reader.ReadUInt16();
|
|
PolygonUnknown = reader.ReadUInt16();
|
|
}
|
|
else
|
|
throw new Exception("Unexpected Polygon Buffer Info Header Size! " + PolygonHeaderSize);
|
|
|
|
if (PolgonMaterialId != 0)
|
|
{
|
|
reader.SeekBegin(InfoPosition + PolgonMaterialId);
|
|
MaterialID = reader.ReadInt32();
|
|
}
|
|
|
|
if (PolygonStartPosition != 0)
|
|
{
|
|
reader.SeekBegin(InfoPosition + PolygonStartPosition);
|
|
uint FaceCount = reader.ReadUInt32();
|
|
Faces = new int[FaceCount];
|
|
for (int i = 0; i < FaceCount; i++)
|
|
Faces[i] = reader.ReadUInt16();
|
|
}
|
|
|
|
//Seek back to next in array
|
|
reader.SeekBegin(DataPosition + sizeof(uint));
|
|
}
|
|
}
|
|
|
|
public class VertexAttribute
|
|
{
|
|
public BufferFormat Format { get; set; } = BufferFormat.Float;
|
|
public BufferType Type { get; set; } = BufferType.Position;
|
|
|
|
public enum BufferType
|
|
{
|
|
Position = 0,
|
|
Normal = 1,
|
|
Binormal = 2,
|
|
TexCoord1 = 3,
|
|
TexCoord2 = 4,
|
|
TexCoord3 = 5,
|
|
TexCoord4 = 6,
|
|
Color1 = 7,
|
|
Color2 = 8,
|
|
BoneIndex = 11,
|
|
Weights = 12,
|
|
}
|
|
|
|
public enum BufferFormat
|
|
{
|
|
Float = 0,
|
|
HalfFloat = 1,
|
|
Byte = 3,
|
|
Short = 5,
|
|
BytesAsFloat = 8,
|
|
}
|
|
|
|
public void Read(FileReader reader)
|
|
{
|
|
long DataPosition = reader.Position;
|
|
var DataOffset = reader.ReadOffset(true, typeof(uint));
|
|
|
|
reader.SeekBegin(DataOffset);
|
|
long InfoPosition = reader.Position;
|
|
int InfoOffset = reader.ReadInt32();
|
|
|
|
//Read the info section for position data
|
|
reader.SeekBegin(InfoPosition - InfoOffset);
|
|
ushort LayoutHeaderLength = reader.ReadUInt16();
|
|
ushort LayoutSizePosition = 0;
|
|
ushort LayoutTypePosition = 0;
|
|
ushort LayoutFormatPosition = 0;
|
|
ushort LayoutUnknownPosition = 0;
|
|
|
|
if (LayoutHeaderLength == 0x0A)
|
|
{
|
|
LayoutSizePosition = reader.ReadUInt16();
|
|
LayoutTypePosition = reader.ReadUInt16();
|
|
LayoutFormatPosition = reader.ReadUInt16();
|
|
LayoutUnknownPosition = reader.ReadUInt16();
|
|
}
|
|
else
|
|
throw new Exception("Unexpected Attribute Layout Header Size! " + LayoutHeaderLength);
|
|
|
|
if (LayoutFormatPosition != 0)
|
|
{
|
|
reader.SeekBegin(InfoPosition + LayoutFormatPosition);
|
|
Format = reader.ReadEnum<BufferFormat>(true);
|
|
}
|
|
|
|
if (LayoutTypePosition != 0)
|
|
{
|
|
reader.SeekBegin(InfoPosition + LayoutTypePosition);
|
|
Type = reader.ReadEnum<BufferType>(true);
|
|
}
|
|
|
|
//Seek back to next in array
|
|
reader.SeekBegin(DataPosition + sizeof(uint));
|
|
}
|
|
}
|
|
|
|
public class Bone : STBone
|
|
{
|
|
internal BoneInfo BoneInfo { get; set; }
|
|
|
|
public Bone(STSkeleton skeleton) : base(skeleton) { }
|
|
|
|
public void Read(FileReader reader)
|
|
{
|
|
long DataPosition = reader.Position;
|
|
var BoneDataOffset = reader.ReadOffset(true, typeof(uint));
|
|
|
|
reader.SeekBegin(BoneDataOffset);
|
|
long InfoPosition = reader.Position;
|
|
|
|
int BoneInfoOffset = reader.ReadInt32();
|
|
|
|
//Read the info section for position data
|
|
reader.SeekBegin(InfoPosition - BoneInfoOffset);
|
|
|
|
BoneInfo = new BoneInfo();
|
|
BoneInfo.Read(reader);
|
|
|
|
RotationType = BoneRotationType.Euler;
|
|
Checked = true;
|
|
|
|
if (BoneInfo.NamePosition != 0)
|
|
{
|
|
reader.SeekBegin(InfoPosition + BoneInfo.NamePosition);
|
|
uint NameLength = reader.ReadUInt32();
|
|
Text = reader.ReadString((int)NameLength);
|
|
}
|
|
|
|
if (BoneInfo.RotationPosition != 0)
|
|
{
|
|
reader.SeekBegin(InfoPosition + BoneInfo.RotationPosition);
|
|
float RotationX = reader.ReadSingle();
|
|
float RotationY = reader.ReadSingle();
|
|
float RotationZ = reader.ReadSingle();
|
|
rotation = new float[] { RotationX,RotationY, RotationZ };
|
|
}
|
|
|
|
if (BoneInfo.TranslationPosition != 0)
|
|
{
|
|
reader.SeekBegin(InfoPosition + BoneInfo.TranslationPosition);
|
|
float TranslateX = reader.ReadSingle();
|
|
float TranslateY = reader.ReadSingle();
|
|
float TranslateZ = reader.ReadSingle();
|
|
position = new float[] { TranslateX, TranslateY, TranslateZ };
|
|
}
|
|
|
|
if (BoneInfo.ScalePosition != 0)
|
|
{
|
|
reader.SeekBegin(InfoPosition + BoneInfo.ScalePosition);
|
|
float ScaleX = reader.ReadSingle();
|
|
float ScaleY = reader.ReadSingle();
|
|
float ScaleZ = reader.ReadSingle();
|
|
scale = new float[] { ScaleX, ScaleY, ScaleZ };
|
|
}
|
|
|
|
if (BoneInfo.ParentPosition != 0)
|
|
{
|
|
reader.SeekBegin(InfoPosition + BoneInfo.ParentPosition);
|
|
parentIndex = reader.ReadInt32();
|
|
}
|
|
|
|
//Seek back to next bone in array
|
|
reader.SeekBegin(DataPosition + sizeof(uint));
|
|
}
|
|
}
|
|
|
|
//A section that stores position info for bone data
|
|
public class BoneInfo
|
|
{
|
|
internal ushort SectionSize { get; set; }
|
|
internal ushort NamePosition { get; set; }
|
|
internal ushort UnknownPosition { get; set; }
|
|
internal ushort Unknown2Position { get; set; }
|
|
internal ushort ParentPosition { get; set; }
|
|
internal ushort Unknown3Position { get; set; }
|
|
internal ushort IsVisiblePosition { get; set; }
|
|
internal ushort ScalePosition { get; set; }
|
|
internal ushort RotationPosition { get; set; }
|
|
internal ushort TranslationPosition { get; set; }
|
|
internal ushort Unknown4Position { get; set; }
|
|
internal ushort Unknown5Position { get; set; }
|
|
|
|
public void Read(FileReader reader)
|
|
{
|
|
SectionSize = reader.ReadUInt16();
|
|
NamePosition = reader.ReadUInt16();
|
|
UnknownPosition = reader.ReadUInt16();
|
|
Unknown2Position = reader.ReadUInt16();
|
|
ParentPosition = reader.ReadUInt16();
|
|
Unknown3Position = reader.ReadUInt16(); //Padding
|
|
IsVisiblePosition = reader.ReadUInt16(); //Points to byte. 0 or 1 for visibilty
|
|
ScalePosition = reader.ReadUInt16();
|
|
RotationPosition = reader.ReadUInt16();
|
|
TranslationPosition = reader.ReadUInt16();
|
|
Unknown4Position = reader.ReadUInt16(); //Padding
|
|
Unknown5Position = reader.ReadUInt16(); //Padding
|
|
}
|
|
}
|
|
|
|
public class Material
|
|
{
|
|
|
|
}
|
|
}
|
|
}
|