public void ReadFromFile(BinaryReader reader)
{
if (reader.ReadInt16() != Magic)
{
return;
}
ushort animalInsCount = reader.ReadUInt16();
instances = new AnimalTrafficInstance[animalInsCount];
if (reader.ReadInt32() != Version)
{
return;
}
for (int i = 0; i < animalInsCount; i++)
{
AnimalTrafficInstance instance = new AnimalTrafficInstance();
instance.Name = new HashName();
instance.Name.ReadFromFile(reader);
instances[i] = instance;
}
ushort pathCount = reader.ReadUInt16();
paths = new AnimalTrafficPath[pathCount];
for (int i = 0; i < pathCount; i++)
{
AnimalTrafficPath path = new AnimalTrafficPath();
byte pathSize = reader.ReadByte();
byte count1 = reader.ReadByte();
byte count2 = reader.ReadByte();
byte count3 = reader.ReadByte();
path.Data0 = reader.ReadBytes(count1);
path.Data1 = reader.ReadBytes(count2);
path.Data2 = reader.ReadBytes(count3);
path.BoundingBox = BoundingBoxExtenders.ReadFromFile(reader);
path.Hash = new HashName();
path.Hash.ReadFromFile(reader); //decompiled exe says this is a hash but its always empty
path.Unk0 = reader.ReadSingle(); //5
path.Unk1 = reader.ReadSingle(); //15
path.Unk2 = reader.ReadByte(); //1 257 or 513.
path.Unk3 = reader.ReadBytes(path.Unk2);
path.Vectors = new PathVectors[pathSize];
for (int x = 0; x < pathSize; x++)
{
PathVectors vector = new PathVectors();
vector.Position = Vector3Utils.ReadFromFile(reader); //Very large differences between these two
vector.Rotation = Vector3Utils.ReadFromFile(reader); //2nd one could be rotation, in radians.
vector.Unk0 = reader.ReadByte(); //7 or 4
path.Vectors[x] = vector;
}
paths[i] = path;
}
}
/// <summary>
/// Create objects from model. Requires FrameMesh/FrameModel to be already set and a model already read into the data.
/// </summary>
public void CreateObjectsFromModel()
{
frameGeometry = new FrameGeometry();
frameMaterial = new FrameMaterial();
//set lods for all data.
indexBuffers = new IndexBuffer[model.Lods.Length];
vertexBuffers = new VertexBuffer[model.Lods.Length];
List <Vertex[]> vertData = new List <Vertex[]>();
for (int i = 0; i != model.Lods.Length; i++)
{
vertData.Add(model.Lods[i].Vertices);
if (model.Lods[i].VertexDeclaration.HasFlag(VertexFlags.Tangent))
{
model.Lods[i].VertexDeclaration -= VertexFlags.Tangent;
}
}
frameMesh.Boundings = BoundingBoxExtenders.CalculateBounds(vertData);
frameMaterial.Bounds = FrameMesh.Boundings;
CalculateDecompression();
UpdateObjectsFromModel();
BuildIndexBuffer();
BuildVertexBuffer();
for (int i = 0; i < model.Lods.Length; i++)
{
frameGeometry.LOD[i].IndexBufferRef = new Hash("M2TK." + model.Name + ".IB" + i);
frameGeometry.LOD[i].VertexBufferRef = new Hash("M2TK." + model.Name + ".VB" + i);
}
}
public void ConvertMTKToRenderModel(M2TStructure structure)
{
List <Vertex[]> vertices = new List <Vertex[]>();
LODs = new LOD[structure.Lods.Length];
for (int i = 0; i != structure.Lods.Length; i++)
{
M2TStructure.Lod lod = structure.Lods[i];
vertices.Add(lod.Vertices);
LOD lod2 = new LOD();
lod2.Indices = lod.Indices;
lod2.ModelParts = new ModelPart[lod.Parts.Length];
for (int y = 0; y != lod.Parts.Length; y++)
{
ModelPart part = new ModelPart();
part.NumFaces = lod.Parts[y].NumFaces;
part.StartIndex = lod.Parts[y].StartIndex;
part.MaterialHash = lod.Parts[y].Hash;
switch (part.MaterialHash)
{
case 1337:
part.Material = RenderStorageSingleton.Instance.Prefabs.GizmoRed;
break;
case 1338:
part.Material = RenderStorageSingleton.Instance.Prefabs.GizmoBlue;
break;
case 1339:
part.Material = RenderStorageSingleton.Instance.Prefabs.GizmoGreen;
break;
default:
part.Material = MaterialsManager.LookupMaterialByHash(part.MaterialHash);
break;
}
lod2.ModelParts[y] = part;
}
lod2.Vertices = new VertexLayouts.NormalLayout.Vertex[lod.Vertices.Length];
for (int y = 0; y != lod.Vertices.Length; y++)
{
var vertice = new VertexLayouts.NormalLayout.Vertex();
vertice.Position = lod.Vertices[y].Position;
vertice.Normal = lod.Vertices[y].Normal;
vertice.TexCoord0 = lod.Vertices[y].UVs[0];
vertice.TexCoord7 = lod.Vertices[y].UVs[3];
lod2.Vertices[y] = vertice;
}
LODs[i] = lod2;
}
BoundingBox = new RenderBoundingBox();
BoundingBox.Init(BoundingBoxExtenders.CalculateBounds(vertices));
BoundingBox.SetTransform(Transform);
BoundingBox.DoRender = false;
SetupShaders();
}
public override void ReadFromFile(MemoryStream reader, bool isBigEndian)
{
base.ReadFromFile(reader, isBigEndian);
flags = (SingleMeshFlags)reader.ReadInt32(isBigEndian);
bounds = BoundingBoxExtenders.ReadFromFile(reader, isBigEndian);
unk14 = reader.ReadByte8();
meshIndex = reader.ReadInt32(isBigEndian);
materialIndex = reader.ReadInt32(isBigEndian);
omTextureHash = new HashName(reader, isBigEndian);
unk18_1 = reader.ReadByte8();
unk18_2 = reader.ReadByte8();
unk18_3 = reader.ReadByte8();
}
public override void ReadFromFile(MemoryStream reader, bool isBigEndian)
{
base.ReadFromFile(reader, isBigEndian);
unk01 = reader.ReadInt32(isBigEndian);
planesSize = reader.ReadInt32(isBigEndian);
planes = new Vector4[planesSize];
for (int i = 0; i != planes.Length; i++)
{
planes[i] = Vector4Extenders.ReadFromFile(reader, isBigEndian);
}
bounds = BoundingBoxExtenders.ReadFromFile(reader, isBigEndian);
}
public override void ReadFromFile(MemoryStream reader, bool isBigEndian)
{
base.ReadFromFile(reader, isBigEndian);
unk_08_int = reader.ReadInt32(isBigEndian);
planesSize = reader.ReadInt32(isBigEndian);
planes = new Vector4[planesSize];
for (int i = 0; i != planes.Length; i++)
{
planes[i] = Vector4Extenders.ReadFromFile(reader, isBigEndian);
}
bounds = BoundingBoxExtenders.ReadFromFile(reader, isBigEndian);
unk_13_vector3 = Vector3Utils.ReadFromFile(reader, isBigEndian);
unk_14_vector3 = Vector3Utils.ReadFromFile(reader, isBigEndian);
sectorName = new HashName(reader, isBigEndian);
}
public void WriteToFile()
{
using (BinaryWriter writer = new BinaryWriter(File.Open(file.FullName + "1", FileMode.Create)))
{
writer.Write((ushort)21569); //magic
writer.Write((ushort)instances.Length);
writer.Write(1595612873);
for (int i = 0; i < instances.Length; i++)
{
instances[i].Name.WriteToFile(writer);
}
writer.Write((ushort)paths.Length);
for (int i = 0; i < paths.Length; i++)
{
AnimalTrafficPath path = paths[i];
writer.Write(path.numPaths);
writer.Write((byte)path.unkSet0.Length);
writer.Write((byte)path.unkSet1.Length);
writer.Write((byte)path.unkSet2.Length);
writer.Write(path.unkSet0);
writer.Write(path.unkSet1);
writer.Write(path.unkSet2);
BoundingBoxExtenders.WriteToFile(path.bbox, writer);
path.unkHash.WriteToFile(writer);
writer.Write(path.Unk0);
writer.Write(path.Unk1);
writer.Write(path.Unk2);
for (int x = 0; x < path.numPaths; x++)
{
Vector3Extenders.WriteToFile(path.vectors[x].vectors[0], writer);
Vector3Extenders.WriteToFile(path.vectors[x].vectors[1], writer);
writer.Write(path.vectors[x].unk0);
}
if (path.Unk2 == 2)
{
writer.Write(path.unk3);
}
}
}
}
public void ReadFromFile(MemoryStream reader, bool isBigEndian)
{
int numBones = reader.ReadInt32(isBigEndian);
byte numLods = reader.ReadByte8();
//index infos
boneIndexInfos = new BoneIndexInfo[numLods];
for (int i = 0; i != boneIndexInfos.Length; i++)
{
boneIndexInfos[i].NumIDs = reader.ReadInt32(isBigEndian);
boneIndexInfos[i].NumMaterials = reader.ReadInt32(isBigEndian);
}
//bounds for all bones together?
bounds = BoundingBoxExtenders.ReadFromFile(reader, isBigEndian);
//Bone Transforms
boneTransforms = new BoneTransform[numBones];
for (int i = 0; i != boneTransforms.Length; i++)
{
boneTransforms[i] = new BoneTransform();
boneTransforms[i].ReadFromFile(reader, isBigEndian);
}
for (int i = 0; i != boneIndexInfos.Length; i++)
{
boneIndexInfos[i].BonesPerPool = reader.ReadBytes(8);
//IDs..
boneIndexInfos[i].IDs = reader.ReadBytes(boneIndexInfos[i].NumIDs);
//Material blendings..
boneIndexInfos[i].MatBlends = new ushort[boneIndexInfos[i].NumMaterials];
boneIndexInfos[i].BonesSlot = new byte[boneIndexInfos[i].NumMaterials];
boneIndexInfos[i].NumWeightsPerVertex = new int[boneIndexInfos[i].NumMaterials];
for (int x = 0; x != boneIndexInfos[i].NumMaterials; x++)
{
boneIndexInfos[i].MatBlends[x] = reader.ReadUInt16(isBigEndian);
ushort value = boneIndexInfos[i].MatBlends[x];
boneIndexInfos[i].BonesSlot[x] = (byte)(value & 0xFF);
boneIndexInfos[i].NumWeightsPerVertex[x] = (value >> 8);
}
}
}
/// <summary>
/// Create objects from model. Requires FrameMesh/FrameModel to be already set and a model already read into the data.
/// </summary>
public void CreateObjectsFromModel()
{
frameGeometry = new FrameGeometry();
frameMaterial = new FrameMaterial();
//set lods for all data.
indexBuffers = new IndexBuffer[model.Lods.Length];
vertexBuffers = new VertexBuffer[model.Lods.Length];
List <Vertex[]> vertData = new List <Vertex[]>();
for (int i = 0; i != model.Lods.Length; i++)
{
vertData.Add(model.Lods[i].Vertices);
}
frameMesh.Boundings = BoundingBoxExtenders.CalculateBounds(vertData);
frameMaterial.Bounds = FrameMesh.Boundings;
CalculateDecompression();
UpdateObjectsFromModel();
BuildIndexBuffer();
BuildVertexBuffer();
for (int i = 0; i < model.Lods.Length; i++)
{
var lod = frameGeometry.LOD[i];
var size = 0;
lod.GetVertexOffsets(out size);
if (vertexBuffers[i].Data.Length != (size * lod.NumVerts))
{
throw new SystemException();
}
lod.IndexBufferRef = new HashName("M2TK." + model.Name + ".IB" + i);
lod.VertexBufferRef = new HashName("M2TK." + model.Name + ".VB" + i);
}
if (model.IsSkinned)
{
CreateSkinnedObjectsFromModel();
}
}
public void WriteToFile()
{
using (BinaryWriter writer = new BinaryWriter(File.Open(file.FullName + "1", FileMode.Create)))
{
writer.Write(Magic); //magic
writer.Write((ushort)instances.Length);
writer.Write(Version);
for (int i = 0; i < instances.Length; i++)
{
instances[i].Name.WriteToFile(writer);
}
writer.Write((ushort)paths.Length);
for (int i = 0; i < paths.Length; i++)
{
AnimalTrafficPath path = paths[i];
writer.Write((byte)path.Vectors.Length);
writer.Write((byte)path.Data0.Length);
writer.Write((byte)path.Data1.Length);
writer.Write((byte)path.Data2.Length);
writer.Write(path.Data0);
writer.Write(path.Data1);
writer.Write(path.Data2);
BoundingBoxExtenders.WriteToFile(path.BoundingBox, writer);
path.Hash.WriteToFile(writer);
writer.Write(path.Unk0);
writer.Write(path.Unk1);
writer.Write(path.Unk2);
writer.Write(path.Unk3);
for (int x = 0; x < path.Vectors.Length; x++)
{
Vector3Utils.WriteToFile(path.Vectors[x].Position, writer);
Vector3Utils.WriteToFile(path.Vectors[x].Rotation, writer);
writer.Write(path.Vectors[x].Unk0);
}
}
}
}
public void ReadFromFile(MemoryStream reader, bool isBigEndian)
{
numLods = reader.ReadByte8();
lodMatCount = new int[numLods];
for (int i = 0; i != numLods; i++)
{
lodMatCount[i] = reader.ReadInt32(isBigEndian);
}
materials = new List <MaterialStruct[]>();
bounds = BoundingBoxExtenders.ReadFromFile(reader, isBigEndian);
for (int i = 0; i != numLods; i++)
{
MaterialStruct[] array = new MaterialStruct[lodMatCount[i]];
for (int d = 0; d != array.Length; d++)
{
array[d] = new MaterialStruct(reader, isBigEndian);
}
materials.Add(array);
}
}
public void ReadFromFile(BinaryReader reader)
{
if (reader.ReadInt16() != 21569)
{
return;
}
ushort animalInsCount = reader.ReadUInt16();
instances = new AnimalTrafficInstance[animalInsCount];
if (reader.ReadInt32() != 1595612873)
{
return;
}
for (int i = 0; i < animalInsCount; i++)
{
AnimalTrafficInstance instance = new AnimalTrafficInstance();
instance.Name = new Hash();
instance.Name.ReadFromFile(reader);
instances[i] = instance;
}
ushort pathCount = reader.ReadUInt16();
paths = new AnimalTrafficPath[pathCount];
for (int i = 0; i < pathCount; i++)
{
AnimalTrafficPath path = new AnimalTrafficPath();
path.numPaths = reader.ReadByte();
byte count1 = reader.ReadByte();
byte count2 = reader.ReadByte();
byte count3 = reader.ReadByte();
path.unkSet0 = reader.ReadBytes(count1);
path.unkSet1 = reader.ReadBytes(count2);
path.unkSet2 = reader.ReadBytes(count3);
path.bbox = BoundingBoxExtenders.ReadFromFile(reader);
path.unkHash = new Hash();
path.unkHash.ReadFromFile(reader); //decompiled exe says this is a hash but its always empty
path.Unk0 = reader.ReadSingle(); //5
path.Unk1 = reader.ReadSingle(); //15
path.Unk2 = reader.ReadInt16(); //1 257 or 513.
path.vectors = new PathVectors[path.numPaths];
for (int x = 0; x < path.numPaths; x++)
{
PathVectors vector = new PathVectors();
vector.vectors = new Vector3[2];
vector.vectors[0] = Vector3Extenders.ReadFromFile(reader); //Very large differences between these two
vector.vectors[1] = Vector3Extenders.ReadFromFile(reader); //2nd one could be rotation, in radians.
vector.unk0 = reader.ReadByte(); //7 or 4
path.vectors[x] = vector;
}
if (path.Unk2 == 2)
{
path.unk3 = reader.ReadByte();
}
paths[i] = path;
}
}
public void WriteToFile(BinaryWriter writer)
{
StringHelpers.WriteString(writer, "KynogonRuntimeMesh", false);
writer.Write((ushort)0); //magic is name with two extra 00
writer.Write(2); //version
writer.Write(Unk0);
writer.Write(Unk1);
writer.Write(Unk2);
writer.Write(Unk3);
Vector2Extenders.WriteToFile(BoundMin, writer);
Vector2Extenders.WriteToFile(BoundMax, writer);
writer.Write(CellSizeX);
writer.Write(CellSizeY);
writer.Write(Radius);
writer.Write(Unk4);
writer.Write(Height);
writer.Write(Offset);
for (int i = 0; i < Grid.Length; i++)
{
writer.Write(Grid[i]);
}
for (int i = 0; i < Grid.Length; i++)
{
Cell cell = Cells[i];
writer.Write(cell.Sets.Length);
if (cell.Sets.Length == 0)
{
continue;
}
writer.Write(cell.Offset);
for (int x = 0; x < cell.Sets.Length; x++)
{
var set = cell.Sets[x];
writer.Write(set.X);
writer.Write(set.Y);
writer.Write(set.Offset);
}
for (int x = 0; x < cell.Sets.Length; x++)
{
var set = cell.Sets[x];
writer.Write(set.cellUnk0);
writer.Write(set.cellUnk1);
writer.Write(set.cellUnk2);
writer.Write(set.cellUnk3);
writer.Write(set.cellUnk4);
writer.Write(set.cellUnk5);
writer.Write(set.cellUnk6);
writer.Write(set.cellUnk7);
writer.Write(set.cellUnk8);
writer.Write(set.cellUnk9);
writer.Write(set.cellUnk10);
writer.Write(set.cellUnk11);
writer.Write(set.cellUnk12);
writer.Write(set.cellUnk13);
writer.Write(set.cellUnk14);
writer.Write(set.cellUnk15);
writer.Write(set.NumEdges);
writer.Write(set.cellUnk17);
writer.Write(set.cellUnk18);
writer.Write(set.cellUnk19);
foreach (var dataSet in set.unk10Boxes)
{
BoundingBoxExtenders.WriteToFile(dataSet.B1, writer);
writer.Write(dataSet.UnkOffset);
writer.Write(dataSet.Unk20);
}
foreach (var dataSet in set.unk12Boxes)
{
BoundingBoxExtenders.WriteToFile(dataSet.B1, writer);
writer.Write(dataSet.Unk01);
writer.Write(dataSet.Unk02);
writer.Write(dataSet.Unk03);
writer.Write(dataSet.Unk04);
writer.Write(dataSet.Unk05);
}
if (set.cellUnk14 > 0)
{
foreach (var offset in set.unk14Offsets)
{
writer.Write(offset);
}
writer.Write(set.unk14End);
foreach (var dataSet in set.unk14Boxes)
{
foreach (var point in dataSet.Points)
{
Vector3Extenders.WriteToFile(point, writer);
}
}
}
foreach (var offset in set.unk16Offsets)
{
writer.Write(offset);
}
if (set.NumEdges > 0)
{
writer.Write(set.EdgesDataEndOffset);
foreach (var dataSet in set.EdgeBoxes)
{
dataSet.WriteToFile(writer);
}
}
if (set.cellUnk18 > 0)
{
writer.Write(set.unk18End);
foreach (var dataSet in set.unk18Set)
{
writer.Write(dataSet.Unk0);
writer.Write(dataSet.Unk1);
writer.Write(dataSet.Unk2);
writer.Write(dataSet.Offset);
}
writer.Write(new byte[12]);
foreach (var dataSet in set.unk18Set)
{
foreach (var point in dataSet.Points)
{
Vector3Extenders.WriteToFile(point, writer);
}
}
}
}
}
}
public void BuildBasicCollision(Lod model)
{
nxs = Convert.ToString(22239310);
mesh = Convert.ToString(1213416781);
ver = 1;
flags = MeshSerialFlags.MSF_MATERIALS;
convexEdgeThreshold = 0.001f;
maxVertices = 255;
num4 = 0;
nPoints = model.Vertices.Length;
nTriangles = model.Indices.Length / 3;
points = new Vector3[nPoints];
indices = new uint[model.Indices.Length];
materials = new CollisionMaterials[model.Indices.Length];
int idx = 0;
for (int i = 0; i != model.Parts.Length; i++)
{
ModelPart part = model.Parts[i];
for (int x = (int)part.StartIndex; x < part.StartIndex + part.NumFaces * 3; x++)
{
indices[x] = model.Indices[x];
Enum.TryParse(model.Parts[i].Material, true, out materials[x]);
}
}
for (int i = 0; i != points.Length; i++)
{
points[i] = model.Vertices[i].Position;
}
numConvexParts = 0;
numFlatParts = 0;
convexParts = new short[nTriangles];
flatParts = new short[nTriangles];
opcHbmData = new HBMOPCDataClass();
opcHbmData.BuildBasicOPCHBM();
boundingBox = new BoundingBox();
unkFloats = new float[14];
//sort out bounding box/sphere
List <Vertex[]> data = new List <Vertex[]>();
data.Add(model.Vertices);
boundingBox = new BoundingBox();
boundingSphere = new BoundingSphere();
boundingBox = BoundingBoxExtenders.CalculateBounds(data);
boundingSphere = BoundingSphereExtenders.CalculateFromBBox(boundingBox);
unkSize = nTriangles;
unkSizeData = new byte[unkSize];
for (int i = 0; i != unkSizeData.Length; i++)
{
unkSizeData[i] = 0;
}
}
public void ReadFromFile(BinaryReader reader)
{
nxs = new string(reader.ReadChars(4));
mesh = new string(reader.ReadChars(4));
ver = reader.ReadInt32();
flags = (MeshSerialFlags)reader.ReadInt32();
convexEdgeThreshold = reader.ReadSingle();
maxVertices = reader.ReadInt32();
num4 = reader.ReadInt32();
nPoints = reader.ReadInt32();
nTriangles = reader.ReadInt32();
points = new Vector3[nPoints];
indices = new uint[nTriangles * 3];
materials = new CollisionMaterials[nTriangles];
for (int i = 0; i != points.Length; i++)
{
points[i] = Vector3Extenders.ReadFromFile(reader);
}
if (flags.HasFlag(MeshSerialFlags.MSF_8BIT_INDICES))
{
for (int i = 0; i != indices.Length; i++)
{
indices[i] = reader.ReadByte();
}
}
else if (flags.HasFlag(MeshSerialFlags.MSF_16BIT_INDICES))
{
for (int i = 0; i != indices.Length; i++)
{
indices[i] = reader.ReadUInt16();
}
}
else
{
for (int i = 0; i != indices.Length; i++)
{
indices[i] = reader.ReadUInt32();
}
}
if (flags.HasFlag(MeshSerialFlags.MSF_MATERIALS))
{
for (int i = 0; i != materials.Length; i++)
{
materials[i] = (CollisionMaterials)reader.ReadInt16();
}
}
if (flags.HasFlag(MeshSerialFlags.MSF_FACE_REMAP))
{
max = reader.ReadInt32();
remapData = new int[nTriangles];
for (int i = 0; i < nTriangles; i++)
{
if (max > 0xFFFF)
{
remapData[i] = reader.ReadInt32();
}
else if (max > 0xFF)
{
remapData[i] = reader.ReadInt16();
}
else
{
remapData[i] = reader.ReadByte();
}
}
}
numConvexParts = reader.ReadInt32();
numFlatParts = reader.ReadInt32();
if (numConvexParts > 0)
{
convexParts = new short[nTriangles];
for (int i = 0; i != nTriangles; i++)
{
convexParts[i] = reader.ReadInt16();
}
}
if (numFlatParts > 0)
{
if (numFlatParts < 256)
{
flatParts = new short[nTriangles];
for (int i = 0; i != nTriangles; i++)
{
flatParts[i] = reader.ReadByte();
}
}
else
{
flatParts = new short[nTriangles];
for (int i = 0; i != nTriangles; i++)
{
flatParts[i] = reader.ReadInt16();
}
}
}
opcHbmData = new HBMOPCDataClass(reader);
unkFloats = new float[14];
unkFloats[0] = reader.ReadSingle();
boundingSphere = BoundingSphereExtenders.ReadFromFile(reader);
boundingBox = BoundingBoxExtenders.ReadFromFile(reader);
for (int i = 1; i != unkFloats.Length; i++)
{
unkFloats[i] = reader.ReadSingle();
}
unkSize = reader.ReadInt32();
unkSizeData = reader.ReadBytes(unkSize);
if (unkSize != nTriangles)
{
throw new FormatException("UnkSize does not equal nTriangles:");
}
}
private void InternalWriteToFile(BinaryWriter writer)
{
writer.Write(version);
writer.Write(unk1);
writer.Write(unk2);
BoundingBoxExtenders.WriteToFile(bounds, writer);
writer.Write(Grids.Length);
for (int i = 0; i < Grids.Length; i++)
{
Grid grid = Grids[i];
writer.Write(grid.Key);
Vector3Extenders.WriteToFile(grid.Origin, writer);
Vector2Extenders.WriteToFile(grid.CellSize, writer);
writer.Write(grid.Width);
writer.Write(grid.Height);
for (int y = 0; y != grid.Data.Length; y++)
{
writer.Write(grid.Data[y]);
}
}
writer.Write(unk3.Length / 2);
for (int i = 0; i < unk3.Length; i++)
{
writer.Write(unk3[i]);
}
writer.Write(ObjectGroups.Length);
for (int i = 0; i != ObjectGroups.Length; i++)
{
ObjectGroup objectGroup = ObjectGroups[i];
writer.Write(objectGroup.Unk01);
writer.Write(objectGroup.Objects.Length);
for (int x = 0; x != objectGroup.NumObjects; x++)
{
Object obj = objectGroup.Objects[x];
writer.Write(obj.NumInstance2);
writer.Write(obj.Unk02);
writer.Write(obj.Name.Hash);
StringHelpers.WriteString(writer, obj.Name.String);
writer.Write(obj.UnkBytes1);
writer.Write(obj.GridMax);
writer.Write(obj.GridMin);
writer.Write(obj.NumInstances);
for (int y = 0; y != obj.NumInstances; y++)
{
Instance instance = obj.Instances[y];
writer.Write(instance.W0);
writer.Write(instance.W1);
writer.Write(instance.W2);
writer.Write(instance.D5);
writer.Write(instance.ID);
writer.Write(instance.D4);
}
objectGroup.Objects[x] = obj;
}
ObjectGroups[i] = objectGroup;
}
}
public override void ReadFromFile(MemoryStream reader, bool isBigEndian)
{
base.ReadFromFile(reader, isBigEndian);
bounds = BoundingBoxExtenders.ReadFromFile(reader, isBigEndian);
}
public void ReadFromFile(BinaryReader reader)
{
if (reader.ReadInt32() != type)
{
return;
}
if (StringHelpers.ReadString32(reader) != name)
{
return;
}
unk0 = reader.ReadInt32();
unk1 = reader.ReadInt32();
numVerts1 = reader.ReadInt32();
unk2 = reader.ReadInt64();
unkFlags = reader.ReadBytes(5);
unk3 = reader.ReadInt32();
unk4 = reader.ReadInt64();
padding = reader.ReadByte();
numVerts2 = reader.ReadInt32();
vertices = new Vector3[numVerts2];
for (int i = 0; i != numVerts2; i++)
{
vertices[i] = Vector3Extenders.ReadFromFile(reader);
}
numVerts3 = reader.ReadInt32();
unkVectors1 = new Vector3[numVerts3];
for (int i = 0; i != numVerts3; i++)
{
unkVectors1[i] = Vector3Extenders.ReadFromFile(reader);
}
numVerts4 = reader.ReadInt32();
unkVectors2 = new Vector3[numVerts4];
for (int i = 0; i != numVerts4; i++)
{
unkVectors2[i] = Vector3Extenders.ReadFromFile(reader);
}
numVerts5 = reader.ReadInt32();
unkVectors3 = new Vector3[numVerts5];
for (int i = 0; i != numVerts5; i++)
{
unkVectors3[i] = Vector3Extenders.ReadFromFile(reader);
}
numVerts6 = reader.ReadInt32();
boneIdx = new int[numVerts6];
for (int i = 0; i != numVerts6; i++)
{
boneIdx[i] = reader.ReadInt32();
}
unkShorts = new short[numVerts6 * 4];
for (int i = 0; i != numVerts6 * 4; i++)
{
unkShorts[i] = reader.ReadInt16();
}
unk6 = reader.ReadInt16();
unk7 = reader.ReadInt16();
unk8 = reader.ReadInt32();
unk8Collection = new float[unk8];
unk8Collection2 = new int[unk8];
for (int i = 0; i != unk8; i++)
{
unk8Collection[i] = reader.ReadSingle();
}
for (int i = 0; i != unk8; i++)
{
unk8Collection2[i] = reader.ReadInt32();
}
numTriangles = reader.ReadInt32();
triangles = new Int3[numTriangles];
for (int i = 0; i != numTriangles; i++)
{
Int3 int3 = new Int3();
int3.X = reader.ReadInt32();
int3.Y = reader.ReadInt32();
int3.Z = reader.ReadInt32();
triangles[i] = int3;
}
unk20 = reader.ReadInt64();
unk20_1 = reader.ReadInt32();
unk21 = reader.ReadInt64();
unk21_1 = reader.ReadInt32();
numMaterials = reader.ReadInt32();
materialNames = new string[numMaterials];
for (int i = 0; i != numMaterials; i++)
{
materialNames[i] = StringHelpers.ReadString32(reader);
}
unk22 = reader.ReadInt32();
bbox = BoundingBoxExtenders.ReadFromFile(reader);
unk23 = reader.ReadInt32();
List <string> data = new List <string>();
for (int z = 0; z != unkVectors1.Length; z++)
{
data.Add(string.Format("v {0} {1} {2}", unkVectors1[z].X, unkVectors1[z].Y, unkVectors1[z].Z));
}
data.Add("");
data.Add("g " + "Object");
for (int z = 0; z != numTriangles; z++)
{
data.Add(string.Format("f {0} {1} {2}", triangles[z].X + 1, triangles[z].Y + 1, triangles[z].Z + 1));
}
File.WriteAllLines("Object.obj", data.ToArray());
}
public void ReadFromFile(MemoryStream stream, bool isBigEndian)
{
//all the same values?
for (int i = 0; i != numBones.Length; i++)
{
numBones[i] = stream.ReadInt32(isBigEndian);
}
numBlendIDs = stream.ReadInt32(isBigEndian);
numLods = stream.ReadInt32(isBigEndian);
//unknown lod data;
unkLodData = new int[numLods];
for (int i = 0; i != unkLodData.Length; i++)
{
unkLodData[i] = stream.ReadInt32(isBigEndian);
}
idType = stream.ReadByte8();
//Bone Names and LOD data.
boneNames = new Hash[numBones[0]];
for (int i = 0; i != boneNames.Length; i++)
{
boneNames[i] = new Hash(stream, isBigEndian);
}
//Matrices;
matrices1 = new Matrix[numBones[1]];
matrices2 = new Matrix[numBones[3]];
for (int i = 0; i != matrices1.Length; i++)
{
matrices1[i] = MatrixExtensions.ReadFromFile(stream, isBigEndian);
}
numUnkCount2 = stream.ReadInt32(isBigEndian);
boneLODUsage = stream.ReadBytes(numUnkCount2);
for (int i = 0; i != matrices2.Length; i++)
{
matrices2[i] = MatrixExtensions.ReadFromFile(stream, isBigEndian);
}
//BoneMappings.
mappingForBlendingInfos = new MappingForBlendingInfo[numLods];
for (int i = 0; i != mappingForBlendingInfos.Length; i++)
{
mappingForBlendingInfos[i].Bounds = new BoundingBox[numBones[2]];
for (int x = 0; x != mappingForBlendingInfos[i].Bounds.Length; x++)
{
mappingForBlendingInfos[i].Bounds[x] = BoundingBoxExtenders.ReadFromFile(stream, isBigEndian);
}
if (stream.ReadByte() != 0)
{
throw new System.Exception("oops");
}
mappingForBlendingInfos[i].RefToUsageArray = stream.ReadBytes(numBones[2]);
mappingForBlendingInfos[i].UsageArray = stream.ReadBytes(unkLodData[i]);
}
}
public void ReadFromFile(BinaryReader reader)
{
StreamWriter writer = File.CreateText("NAV_AI_OBJ_DATA.txt");
unk0 = reader.ReadInt32();
unk2 = reader.ReadInt32();
unk3 = reader.ReadInt32();
unk4 = reader.ReadInt32();
vertSize = reader.ReadInt32();
triSize = reader.ReadInt32();
//writer.WriteLine(string.Format("{0}, )
//List<string> data = new List<string>();
vertices = new VertexStruct[vertSize];
for (int i = 0; i < vertSize; i++)
{
VertexStruct vertex = new VertexStruct();
vertex.unk7 = reader.ReadUInt32() & 0x7FFFFFFF;
vertex.position = Vector3Extenders.ReadFromFile(reader);
//float pos = vertex.position.Y;
//vertex.position.Y = vertex.position.Z;
//vertex.position.Z = pos;
vertex.unk0 = reader.ReadSingle();
vertex.unk1 = reader.ReadSingle();
vertex.unk2 = reader.ReadInt32();
vertex.unk3 = reader.ReadInt16();
vertex.unk4 = reader.ReadInt16();
vertex.unk5 = reader.ReadInt32();
vertex.unk6 = reader.ReadInt32();
//data.Add(string.Format("v {0} {1} {2}", vertex.position.X, vertex.position.Z, vertex.position.Y));
vertices[i] = vertex;
}
//data.Add("");
//data.Add("g mesh");
indices = new uint[triSize * 3];
int index = 0;
for (int i = 0; i < triSize; i++)
{
indices[index] = reader.ReadUInt32() & 0x7FFFFFFF;
indices[index + 1] = reader.ReadUInt32() & 0x7FFFFFFF;
indices[index + 2] = reader.ReadUInt32() & 0x7FFFFFFF;
//data.Add(string.Format("f {0} {1} {2}", indices[index] + 1, indices[index + 1] + 1, indices[index + 2] + 1));
index += 3;
}
//KynogonRuntimeMesh
long mesh_pos = reader.BaseStream.Position;
string magicName = new string(reader.ReadChars(18));
if (magicName != "KynogonRuntimeMesh")
{
throw new FormatException("Did not find KynogonRuntimeMesh");
}
short mesh_unk0 = reader.ReadInt16();
int magicVersion = reader.ReadInt32();
if (magicVersion != 2)
{
throw new FormatException("Version did not equal 2");
}
int mesh_unk1 = reader.ReadInt32();
int mesh_unk2 = reader.ReadInt32();
BoundingBox bbox = BoundingBoxExtenders.ReadFromFile(reader);
int cellSizeX = reader.ReadInt32();
int cellSizeY = reader.ReadInt32();
float radius = reader.ReadSingle();
int map_unk3 = reader.ReadInt32();
int height = reader.ReadInt32();
int offset = reader.ReadInt32(); //this is a potential offset;
int[] grid = new int[(cellSizeX * cellSizeY) + 1];
List <UnkSet0[]> gridSets = new List <UnkSet0[]>();
for (int i = 0; i < grid.Length; i++)
{
grid[i] = reader.ReadInt32();
}
for (int i = 0; i < grid.Length; i++)
{
if (i + 1 >= grid.Length)
{
break;
}
if (i == 189)
{
Console.WriteLine("st");
}
int numSet0 = reader.ReadInt32();
UnkSet0[] set0s = new UnkSet0[numSet0];
gridSets.Add(set0s);
writer.WriteLine("-----------------------");
writer.WriteLine(string.Format("{0} {1}", i, numSet0));
writer.WriteLine("");
if (numSet0 == 0)
{
continue;
}
//NOTE: EVERY OFFSET IN UNKSET0 BEGINS FROM MESH_POS HIGHER IN THE CODE FILE.
int offset0 = reader.ReadInt32();
for (int x = 0; x < numSet0; x++)
{
UnkSet0 set = new UnkSet0();
set.X = reader.ReadSingle();
set.Y = reader.ReadSingle();
set.Offset = reader.ReadInt32();
set0s[x] = set;
}
//NOTE: EVERY BLOCK OF DATA SEEMS TO START WITH 96, THIS IS HOWEVER UNCONFIRMED.
for (int z = 0; z < numSet0; z++)
{
UnkSet0 set = set0s[z];
//NOTE: MOST OF THE OFFSETS BEGIN HERE, JUST AFTER THE SETS HAVE BEEN DEFINED ABOVE.
set.cellUnk0 = reader.ReadInt32();
if (set.cellUnk0 != mesh_unk2)
{
throw new FormatException();
}
writer.WriteLine("");
set.cellUnk1 = reader.ReadInt32();
set.cellUnk2 = reader.ReadInt32();
set.cellUnk3 = reader.ReadInt32();
set.cellUnk4 = reader.ReadSingle();
set.cellUnk5 = reader.ReadSingle();
set.cellUnk6 = reader.ReadSingle();
set.cellUnk7 = reader.ReadSingle();
set.cellUnk8 = reader.ReadInt32();
set.cellUnk9 = reader.ReadInt32(); //-1?
set.cellUnk10 = reader.ReadInt32(); //1;
set.cellUnk11 = reader.ReadInt32();
set.cellUnk12 = reader.ReadInt32(); //0
set.cellUnk13 = reader.ReadInt32(); //-1;
set.cellUnk14 = reader.ReadInt32(); //0
set.cellUnk15 = reader.ReadInt32(); //-1;
set.cellUnk16 = reader.ReadInt32(); //8;
set.cellUnk17 = reader.ReadInt32(); //112;
set.cellUnk18 = reader.ReadInt32(); //0;
set.cellUnk19 = reader.ReadInt32(); //-1;
writer.WriteLine(string.Format("Unk1: {0}", set.cellUnk1));
writer.WriteLine(string.Format("Unk2: {0}", set.cellUnk2));
writer.WriteLine(string.Format("Unk3: {0}", set.cellUnk3));
writer.WriteLine(string.Format("Unk4: {0}", set.cellUnk4));
writer.WriteLine(string.Format("Unk5: {0}", set.cellUnk5));
writer.WriteLine(string.Format("Unk6: {0}", set.cellUnk6));
writer.WriteLine(string.Format("Unk7: {0}", set.cellUnk7));
writer.WriteLine(string.Format("Unk8: {0}", set.cellUnk8));
writer.WriteLine(string.Format("Unk9: {0}", set.cellUnk9));
writer.WriteLine(string.Format("Unk10: {0}", set.cellUnk10));
writer.WriteLine(string.Format("Unk11: {0}", set.cellUnk11));
writer.WriteLine(string.Format("Unk12: {0}", set.cellUnk12));
writer.WriteLine(string.Format("Unk13: {0}", set.cellUnk13));
writer.WriteLine(string.Format("Unk14: {0}", set.cellUnk14));
writer.WriteLine(string.Format("Unk15: {0}", set.cellUnk15));
writer.WriteLine(string.Format("Unk16: {0}", set.cellUnk16));
writer.WriteLine(string.Format("Unk17: {0}", set.cellUnk17));
writer.WriteLine(string.Format("Unk18: {0}", set.cellUnk18));
writer.WriteLine(string.Format("Unk19: {0}", set.cellUnk19));
writer.WriteLine("");
//THIS BIT IS UNKNOWN, UPTO CELLUNK20
set.unk10Boxes = new Unk10DataSet[set.cellUnk10];
writer.WriteLine("Unk10 Boxes");
for (int x = 0; x < set.cellUnk10; x++)
{
Unk10DataSet unk10Set = new Unk10DataSet();
unk10Set.B1 = BoundingBoxExtenders.ReadFromFile(reader);
unk10Set.UnkOffset = reader.ReadInt32();
unk10Set.Unk20 = reader.ReadInt32();
set.unk10Boxes[x] = unk10Set;
writer.WriteLine(string.Format("Minimum: {0} ", unk10Set.B1.Minimum.ToString()));
writer.WriteLine(string.Format("Maximum: {0} ", unk10Set.B1.Maximum.ToString()));
writer.WriteLine(string.Format("UnkOffset: {0} ", unk10Set.UnkOffset));
writer.WriteLine(string.Format("Unk20: {0} ", unk10Set.Unk20));
writer.WriteLine("");
}
//END OF CONFUSING BIT.
//THIS BIT IS UNKNOWN, BUT IS CELLUNK12
set.unk12Boxes = new Unk12DataSet[set.cellUnk12];
writer.WriteLine("Unk12 Boxes");
for (int x = 0; x < set.cellUnk12; x++)
{
Unk12DataSet unk12Set = new Unk12DataSet();
unk12Set.B1 = BoundingBoxExtenders.ReadFromFile(reader);
unk12Set.Unk01 = reader.ReadInt32();
unk12Set.Unk02 = reader.ReadInt32();
unk12Set.Unk03 = reader.ReadSingle();
unk12Set.Unk04 = reader.ReadSingle();
unk12Set.Unk05 = reader.ReadSingle();
set.unk12Boxes[x] = unk12Set;
writer.WriteLine(string.Format("Minimum: {0} ", unk12Set.B1.Minimum.ToString()));
writer.WriteLine(string.Format("Maximum: {0} ", unk12Set.B1.Maximum.ToString()));
writer.WriteLine(string.Format("Unk01: {0} ", unk12Set.Unk01));
writer.WriteLine(string.Format("Unk02: {0} ", unk12Set.Unk02));
writer.WriteLine(string.Format("Unk03: {0} ", unk12Set.Unk03));
writer.WriteLine(string.Format("Unk04: {0} ", unk12Set.Unk04));
writer.WriteLine(string.Format("Unk05: {0} ", unk12Set.Unk05));
writer.WriteLine("");
}
//END OF CONFUSING BIT.
//THIS LOOPS THROUGH OFFSETS TO BBOX'S
writer.WriteLine("Unk14 Offsets");
set.unk14Offsets = new int[set.cellUnk14];
for (int x = 0; x < set.cellUnk14; x++)
{
set.unk14Offsets[x] = reader.ReadInt32();
writer.WriteLine(string.Format("{0} ", set.unk14Offsets[x]));
}
//ALWAYS A 4-BYTE INTEGER WHICH DENOTES THE END OF THE BATCH
if (set.cellUnk14 > 0)
{
set.unk14End = reader.ReadInt32();
}
if (set.cellUnk14 > 0)
{
set.unk14Data = reader.ReadBytes(set.unk14End - set.unk14Offsets[0]);
}
writer.WriteLine("");
//set.unk14Boxes = new BoundingBox[set.cellUnk14];
//writer.WriteLine("Unk14 Boxes");
//for (int x = 0; x < set.cellUnk14; x++)
//{
// set.unk14Boxes[x] = BoundingBoxExtenders.ReadFromFile(reader);
// writer.WriteLine(string.Format("{0} ", set.unk14Boxes[x].ToString()));
//}
//writer.WriteLine("");
//CONTINUE ONTO THE NEXT BATCH
set.unk16Offsets = new int[set.cellUnk16];
writer.WriteLine("Unk16 Offsets");
for (int x = 0; x < set.cellUnk16; x++)
{
set.unk16Offsets[x] = reader.ReadInt32();
writer.WriteLine(string.Format("{0} ", set.unk16Offsets[x]));
}
writer.WriteLine("");
//ALWAYS A 4-BYTE INTEGER WHICH DENOTES THE END OF THE BATCH
if (set.cellUnk16 > 0)
{
set.unk16End = reader.ReadInt32();
}
set.unk16Boxes = new BoundingBox[set.cellUnk16];
writer.WriteLine("Unk16 Boxes");
for (int x = 0; x < set.cellUnk16; x++)
{
set.unk16Boxes[x] = BoundingBoxExtenders.ReadFromFile(reader);
writer.WriteLine(string.Format("{0} ", set.unk16Boxes[x]));
}
writer.WriteLine("");
if (set.cellUnk18 > 1)
{
throw new FormatException();
}
set.unk18Set = new Unk18DataSet[set.cellUnk18];
writer.WriteLine("Unk18 Boxes");
for (int x = 0; x < set.cellUnk18; x++)
{
//THIS COULD BE AN OFFSET LIST WITH SOMEKIND OF FLOAT/ROTATION DATA
Unk18DataSet dataSet = new Unk18DataSet();
dataSet.Unk0 = reader.ReadInt32();
dataSet.Unk1 = reader.ReadSingle();
dataSet.Unk2 = reader.ReadSingle();
dataSet.Unk3 = reader.ReadSingle();
//THIS COULD BE THE FINAL AREA WITH THE 12 BYTES SIMPLY PADDING OUT
dataSet.Unk4 = reader.ReadInt32();
dataSet.Unk5 = reader.ReadBytes(12);
//BOUNDING BOX FOR THIS KIND OF DATA.
dataSet.B1 = BoundingBoxExtenders.ReadFromFile(reader);
dataSet.B2 = BoundingBoxExtenders.ReadFromFile(reader);
dataSet.B3 = BoundingBoxExtenders.ReadFromFile(reader);
set.unk18Set[x] = dataSet;
writer.WriteLine(string.Format("Unk01: {0} ", dataSet.Unk1));
writer.WriteLine(string.Format("Unk02: {0} ", dataSet.Unk2));
writer.WriteLine(string.Format("Unk03: {0} ", dataSet.Unk3));
writer.WriteLine(string.Format("Unk04: {0} ", dataSet.Unk4));
writer.WriteLine(string.Format("Unk05: {0} ", dataSet.Unk5));
writer.WriteLine(string.Format("Minimum: {0} ", dataSet.B1.Minimum.ToString()));
writer.WriteLine(string.Format("Maximum: {0} ", dataSet.B1.Maximum.ToString()));
writer.WriteLine(string.Format("Minimum: {0} ", dataSet.B2.Minimum.ToString()));
writer.WriteLine(string.Format("Maximum: {0} ", dataSet.B2.Maximum.ToString()));
writer.WriteLine(string.Format("Minimum: {0} ", dataSet.B3.Minimum.ToString()));
writer.WriteLine(string.Format("Maximum: {0} ", dataSet.B3.Maximum.ToString()));
}
writer.WriteLine("");
set0s[z] = set;
}
Console.WriteLine("Completed: " + i);
//byte[] data = reader.ReadBytes(size);
//File.WriteAllBytes("grid_" + i + ".bin", data);
}
//File.WriteAllLines("model.obj", data.ToArray());
}
public override void ReadFromFile(MemoryStream reader, bool bIsBigEndian)
{
base.ReadFromFile(reader, bIsBigEndian);
Flags = reader.ReadInt32(bIsBigEndian);
LUnk0 = reader.ReadSingle(bIsBigEndian);
LUnk1 = reader.ReadSingle(bIsBigEndian);
LUnk2 = reader.ReadSingle(bIsBigEndian);
LUnk3 = reader.ReadSingle(bIsBigEndian);
LUnk4 = reader.ReadSingle(bIsBigEndian);
LUnk5 = reader.ReadSingle(bIsBigEndian);
LUnk6 = reader.ReadSingle(bIsBigEndian);
UnkInt1 = reader.ReadInt32(bIsBigEndian);
UnkVector_0 = Vector3Utils.ReadFromFile(reader, bIsBigEndian);
LUnk7 = reader.ReadSingle(bIsBigEndian);
LUnk8 = reader.ReadSingle(bIsBigEndian);
UnkByte1 = reader.ReadByte8();
LUnk9 = reader.ReadSingle(bIsBigEndian);
LUnk10 = reader.ReadSingle(bIsBigEndian);
LUnk11 = reader.ReadSingle(bIsBigEndian);
LUnk12 = reader.ReadSingle(bIsBigEndian);
UnkVector_1 = Vector3Utils.ReadFromFile(reader, bIsBigEndian);
UnkVector_2 = Vector3Utils.ReadFromFile(reader, bIsBigEndian);
LUnk13 = reader.ReadSingle(bIsBigEndian);
UnkVector_3 = Vector3Utils.ReadFromFile(reader, bIsBigEndian);
LUnk14 = reader.ReadSingle(bIsBigEndian);
LUnk15 = reader.ReadSingle(bIsBigEndian);
LUnk16 = reader.ReadSingle(bIsBigEndian);
UnkByte2 = reader.ReadByte8();
LUnk17 = reader.ReadSingle(bIsBigEndian);
LUnk18 = reader.ReadSingle(bIsBigEndian);
LUnk19 = reader.ReadSingle(bIsBigEndian);
LUnk20 = reader.ReadSingle(bIsBigEndian);
LUnk21 = reader.ReadSingle(bIsBigEndian);
ProjectionTexture = new HashName(reader, bIsBigEndian);
UnkInt2 = reader.ReadInt32(bIsBigEndian);
LUnk22 = reader.ReadSingle(bIsBigEndian);
LUnk23 = reader.ReadSingle(bIsBigEndian);
UnkVector_4 = Vector3Utils.ReadFromFile(reader, bIsBigEndian);
LUnk24 = reader.ReadSingle(bIsBigEndian);
LUnk25 = reader.ReadSingle(bIsBigEndian);
LUnk26 = reader.ReadSingle(bIsBigEndian);
LUnk27 = reader.ReadSingle(bIsBigEndian);
LUnk28 = reader.ReadSingle(bIsBigEndian);
UnkVector_5 = Vector3Utils.ReadFromFile(reader, bIsBigEndian);
LUnk29 = reader.ReadSingle(bIsBigEndian);
LUnk30 = reader.ReadSingle(bIsBigEndian);
LUnk31 = reader.ReadSingle(bIsBigEndian);
LUnk32 = reader.ReadSingle(bIsBigEndian);
LUnk33 = reader.ReadSingle(bIsBigEndian);
LUnk34 = reader.ReadSingle(bIsBigEndian);
LUnk35 = reader.ReadSingle(bIsBigEndian);
// Read Textures
for (int i = 0; i < 4; i++)
{
TextureHashes[i] = new HashName(reader, bIsBigEndian);
}
UnkBox = BoundingBoxExtenders.ReadFromFile(reader, bIsBigEndian);
UnkByte3 = reader.ReadByte8();
UnknownMatrix = MatrixUtils.ReadFromFile(reader, bIsBigEndian);
}
public void ReadFromFile(BinaryReader reader)
{
//KynogonRuntimeMesh
long mesh_pos = reader.BaseStream.Position;
string magicName = new string(reader.ReadChars(18));
if (magicName != "KynogonRuntimeMesh")
{
throw new FormatException("Did not find KynogonRuntimeMesh");
}
short mesh_unk0 = reader.ReadInt16();
int magicVersion = reader.ReadInt32();
if (magicVersion != 2)
{
throw new FormatException("Version did not equal 2");
}
Unk0 = reader.ReadInt32();
Unk1 = reader.ReadInt32();
Unk2 = reader.ReadSingle();
Unk3 = reader.ReadSingle();
float boundMinX = reader.ReadSingle();
float boundMaxX = reader.ReadSingle();
float boundMaxY = -reader.ReadSingle();
float boundMinY = -reader.ReadSingle();
BoundMin = new Vector2(boundMinX, boundMinY);
BoundMax = new Vector2(boundMaxX, boundMaxY);
//BoundingBox = BoundingBoxExtenders.ReadFromFile(reader);
CellSizeX = reader.ReadInt32();
CellSizeY = reader.ReadInt32();
Radius = reader.ReadSingle();
Unk4 = reader.ReadInt32();
Height = reader.ReadInt32();
Offset = reader.ReadInt32(); //this is a potential offset;
Grid = new int[(CellSizeX * CellSizeY)];
Cells = new Cell[Grid.Length];
for (int i = 0; i < Grid.Length; i++)
{
Grid[i] = reader.ReadInt32();
}
int end = reader.ReadInt32();
int Count = 0;
for (int i = 0; i < Cells.Length; i++)
{
//if (i + 1 >= Cells.Length)
// break;
Cell cell = new Cell();
int numSet0 = reader.ReadInt32();
cell.Sets = new UnkSet0[numSet0];
Cells[i] = cell;
if (numSet0 == 0)
{
continue;
}
//NOTE: EVERY OFFSET IN UNKSET0 BEGINS FROM MESH_POS HIGHER IN THE CODE FILE.
cell.Offset = reader.ReadInt32(); /// start offset (excluding sets)
for (int x = 0; x < numSet0; x++)
{
UnkSet0 set = new UnkSet0();
set.X = reader.ReadSingle();
set.Y = reader.ReadSingle();
set.Offset = reader.ReadInt32(); // End offset
cell.Sets[x] = set;
}
//NOTE: EVERY BLOCK OF DATA SEEMS TO START WITH 96, THIS IS HOWEVER UNCONFIRMED.
for (int z = 0; z < numSet0; z++)
{
long set_offset = reader.BaseStream.Position - mesh_pos;
UnkSet0 set = cell.Sets[z];
//NOTE: MOST OF THE OFFSETS BEGIN HERE, JUST AFTER THE SETS HAVE BEEN DEFINED ABOVE.
set.cellUnk0 = reader.ReadInt32();
if (set.cellUnk0 != Unk1)
{
throw new FormatException();
}
set.cellUnk1 = reader.ReadInt32();
set.cellUnk2 = reader.ReadInt32();
set.cellUnk3 = reader.ReadInt32();
set.cellUnk4 = reader.ReadSingle();
set.cellUnk5 = reader.ReadSingle();
set.cellUnk6 = reader.ReadSingle();
set.cellUnk7 = reader.ReadSingle();
set.cellUnk8 = reader.ReadInt32();
set.cellUnk9 = reader.ReadInt32(); //-1?
set.NumUnk10Boxes = reader.ReadInt32(); //1;
set.cellUnk11 = reader.ReadInt32(); // offset is start - setpos
set.NumUnk12Boxes = reader.ReadInt32(); //0
set.cellUnk13 = reader.ReadInt32(); // offset is start - setpos
set.NumUn14Boxes = reader.ReadInt32(); //0
set.cellUnk15 = reader.ReadInt32(); // offset is start - setpos
set.NumEdges = reader.ReadInt32(); //8;
set.cellUnk17 = reader.ReadInt32(); // offset is start - setpos
set.NumUnk18Boxes = reader.ReadInt32(); //0;
set.cellUnk19 = reader.ReadInt32(); // offset is start - setpos
Count += set.NumUnk12Boxes;
// First set of boxes
set.unk10Boxes = new Unk10DataSet[set.NumUnk10Boxes];
for (int x = 0; x < set.NumUnk10Boxes; x++)
{
Unk10DataSet unk10Set = new Unk10DataSet();
unk10Set.B1 = BoundingBoxExtenders.ReadFromFile(reader);
unk10Set.UnkOffset = reader.ReadInt32(); // offset is next set in next cell?
// Linked cell?
unk10Set.Unk20 = reader.ReadInt32(); // really unsure on what this is
set.unk10Boxes[x] = unk10Set;
}
// 2nd set of boxes
set.unk12Boxes = new Unk12DataSet[set.NumUnk12Boxes];
for (int x = 0; x < set.NumUnk12Boxes; x++)
{
Unk12DataSet unk12Set = new Unk12DataSet();
unk12Set.B1 = BoundingBoxExtenders.ReadFromFile(reader);
unk12Set.Unk01 = reader.ReadInt32();
unk12Set.Unk02 = reader.ReadInt32();
unk12Set.Unk03 = reader.ReadSingle();
unk12Set.Unk04 = reader.ReadSingle();
unk12Set.Unk05 = reader.ReadSingle();
set.unk12Boxes[x] = unk12Set;
}
// 3rd set of boxes, but these are offsets
set.unk14Boxes = new Unk14DataSet[set.NumUn14Boxes];
for (int x = 0; x < set.NumUn14Boxes; x++)
{
var dataSet = new Unk14DataSet();
dataSet.Offset = reader.ReadInt32();
set.unk14Boxes[x] = dataSet;
}
// 4th set of boxes, based on the offsets above.
if (set.NumUn14Boxes > 0)
{
set.unk14End = reader.ReadInt32();
var currentOffset = set.unk14Boxes[0].Offset;
for (int x = 0; x < set.NumUn14Boxes; x++)
{
var dataSet = set.unk14Boxes[x];
var offset = (x + 1 < set.NumUn14Boxes ? set.unk14Boxes[x + 1].Offset : set.unk14End);
var size = offset - currentOffset;
currentOffset = offset;
var count = size / 12;
dataSet.Points = new Vector3[count];
for (int f = 0; f < dataSet.Points.Length; f++)
{
dataSet.Points[f] = Vector3Utils.ReadFromFile(reader);
}
set.unk14Boxes[x] = dataSet;
}
}
// 5th set of boxes
set.unk16Offsets = new int[set.NumEdges];
for (int x = 0; x < set.NumEdges; x++)
{
set.unk16Offsets[x] = reader.ReadInt32(); // bounding box position - set_pos
}
//ALWAYS A 4-BYTE INTEGER WHICH DENOTES THE END OF THE BATCH
if (set.NumEdges > 0)
{
set.EdgesDataEndOffset = reader.ReadInt32(); // very end of set_pos
}
// 6th set of boxes
set.EdgeBoxes = new BoundingBox[set.NumEdges];
for (int x = 0; x < set.NumEdges; x++)
{
set.EdgeBoxes[x] = BoundingBoxExtenders.ReadFromFile(reader);
}
// 7th set of boxes
set.unk18Set = new Unk18DataSet[set.NumUnk18Boxes];
if (set.NumUnk18Boxes > 0)
{
set.unk18End = reader.ReadInt32();
for (int x = 0; x < set.NumUnk18Boxes; x++)
{
Unk18DataSet dataSet = new Unk18DataSet();
dataSet.Unk0 = reader.ReadSingle();
dataSet.Unk1 = reader.ReadSingle();
dataSet.Unk2 = reader.ReadSingle();
dataSet.Offset = reader.ReadInt32();
set.unk18Set[x] = dataSet;
}
byte[] unknown_data = reader.ReadBytes(12); //usually padding
var currentOffset = set.unk18End;
for (int x = 0; x < set.NumUnk18Boxes; x++)
{
var dataSet = set.unk18Set[x];
var size = dataSet.Offset - currentOffset;
var count = size / 12;
dataSet.Points = new Vector3[count];
for (int f = 0; f < dataSet.Points.Length; f++)
{
dataSet.Points[f] = Vector3Utils.ReadFromFile(reader);
}
currentOffset = dataSet.Offset;
set.unk18Set[x] = dataSet;
}
}
cell.Sets[z] = set;
}
}
/*uint UnkFooter0 = reader.ReadUInt32();
* if(UnkFooter0 == 0)
* {
* throw new NotImplementedException();
* }
*
* uint OffsetToFooter = reader.ReadUInt32(); // should be same as reader.position - kynogon mesh start
* uint FooterPadding = reader.ReadUInt32(); // Usually zero for me.
* string FooterName = StringHelpers.ReadString(reader); // A null terminated string.
* uint FooterUnk0 = reader.ReadUInt32(); // Size of string. Goes _after_ the string has been stored.
* uint FooterMagic = reader.ReadUInt32(); // should be 0x1213F001
* Debug.Assert(FooterMagic == 0x1213F001, "Didn't reach end of file.");
*/
//File.WriteAllLines("model.obj", data.ToArray());
}
public void WriteToFile(NavigationWriter writer)
{
long MESH_START = writer.BaseStream.Position;
StringHelpers.WriteString(writer, "KynogonRuntimeMesh", false);
writer.Write((ushort)0); //magic is name with two extra 00
writer.Write(2); //version
writer.Write(Unk0);
writer.Write(Unk1);
writer.Write(Unk2);
writer.Write(Unk3);
writer.Write(BoundMin.X);
writer.Write(BoundMax.X);
writer.Write(-BoundMax.Y);
writer.Write(-BoundMin.Y);
writer.Write(CellSizeX);
writer.Write(CellSizeY);
writer.Write(Radius);
writer.Write(Unk4);
writer.Write(Height);
writer.Write(Offset);
for (int i = 0; i < Grid.Length; i++)
{
writer.PushLooseObjectPtr("GRID_OFFSET_" + i, MESH_START);
}
writer.PushLooseObjectPtr("GRID_END", MESH_START);
for (int i = 0; i < Grid.Length; i++)
{
writer.SolveLooseObjectPtr("GRID_OFFSET_" + i);
Cell cell = Cells[i];
writer.Write(cell.Sets.Length);
if (cell.Sets.Length == 0)
{
continue;
}
writer.PushLooseObjectPtr("GRID_START_OFFSET", MESH_START);
for (int x = 0; x < cell.Sets.Length; x++)
{
var set = cell.Sets[x];
writer.Write(set.X);
writer.Write(set.Y);
writer.PushLooseObjectPtr("SET_END_OFFSET_" + x, MESH_START);
}
writer.SolveLooseObjectPtr("GRID_START_OFFSET");
for (int x = 0; x < cell.Sets.Length; x++)
{
long SET_START = writer.BaseStream.Position;
var set = cell.Sets[x];
writer.Write(set.cellUnk0);
writer.Write(set.cellUnk1);
writer.Write(set.cellUnk2);
writer.Write(set.cellUnk3);
writer.Write(set.cellUnk4);
writer.Write(set.cellUnk5);
writer.Write(set.cellUnk6);
writer.Write(set.cellUnk7);
writer.Write(set.cellUnk8);
writer.Write(set.cellUnk9);
writer.Write(set.NumUnk10Boxes);
writer.PushLooseObjectPtr("UNK10BOXES_OFFSET", SET_START);
writer.Write(set.NumUnk12Boxes);
writer.PushLooseObjectPtr("UNK12BOXES_OFFSET", SET_START);
writer.Write(set.NumUn14Boxes);
writer.PushLooseObjectPtr("UNK14BOXES_OFFSET", SET_START);
writer.Write(set.NumEdges);
writer.PushLooseObjectPtr("EDGES_OFFSET", SET_START);
writer.Write(set.NumUnk18Boxes);
writer.PushLooseObjectPtr("UNK18BOXES_OFFSET", SET_START);
if (set.NumUnk10Boxes > 0)
{
writer.SolveLooseObjectPtr("UNK10BOXES_OFFSET");
foreach (var dataSet in set.unk10Boxes)
{
BoundingBoxExtenders.WriteToFile(dataSet.B1, writer);
writer.Write(dataSet.UnkOffset);
writer.Write(dataSet.Unk20);
}
}
if (set.NumUnk12Boxes > 0)
{
writer.SolveLooseObjectPtr("UNK12BOXES_OFFSET");
foreach (var dataSet in set.unk12Boxes)
{
BoundingBoxExtenders.WriteToFile(dataSet.B1, writer);
writer.Write(dataSet.Unk01);
writer.Write(dataSet.Unk02);
writer.Write(dataSet.Unk03);
writer.Write(dataSet.Unk04);
writer.Write(dataSet.Unk05);
}
}
if (set.NumUn14Boxes > 0)
{
// write offset of boxes
writer.SolveLooseObjectPtr("UNK14BOXES_OFFSET");
for (int z = 0; z < set.unk14Boxes.Length; z++)
{
writer.PushLooseObjectPtr("UNK14_BOX_OFFSET_" + z, SET_START);
}
// write them
writer.PushLooseObjectPtr("UNK14_BOX_END", SET_START);
for (int z = 0; z < set.unk14Boxes.Length; z++)
{
writer.SolveLooseObjectPtr("UNK14_BOX_OFFSET_" + z);
foreach (var point in set.unk14Boxes[z].Points)
{
Vector3Utils.WriteToFile(point, writer);
}
}
// end data with ending offset
writer.SolveLooseObjectPtr("UNK14_BOX_END");
}
if (set.NumEdges > 0)
{
// write offset of boxes
writer.SolveLooseObjectPtr("EDGES_OFFSET");
for (int z = 0; z < set.EdgeBoxes.Length; z++)
{
writer.PushLooseObjectPtr("EDGE_OFFSET_" + z, SET_START);
}
// write them
writer.PushLooseObjectPtr("EDGE_END", SET_START);
for (int z = 0; z < set.EdgeBoxes.Length; z++)
{
writer.SolveLooseObjectPtr("EDGE_OFFSET_" + z);
set.EdgeBoxes[z].WriteToFile(writer);
}
// end data with ending offset
writer.SolveLooseObjectPtr("EDGE_END");
}
if (set.NumUnk18Boxes > 0)
{
// write offset
writer.SolveLooseObjectPtr("UNK18BOXES_OFFSET");
writer.PushLooseObjectPtr("UNK18BOXES_END", SET_START);
for (int z = 0; z < set.unk18Set.Length; z++)
{
writer.Write(set.unk18Set[z].Unk0);
writer.Write(set.unk18Set[z].Unk1);
writer.Write(set.unk18Set[z].Unk2);
writer.PushLooseObjectPtr("UNK18_SET_OFFSET_" + z, SET_START);
}
writer.Write(new byte[12]);
writer.SolveLooseObjectPtr("UNK18BOXES_END");
for (int z = 0; z < set.unk18Set.Length; z++)
{
for (int c = 0; c < set.unk18Set[z].Points.Length; c++)
{
Vector3Utils.WriteToFile(set.unk18Set[z].Points[c], writer);
}
writer.SolveLooseObjectPtr("UNK18_SET_OFFSET_" + z);
}
}
// remove any outstanding offsets
writer.RemoveLooseObjectPtr("UNK10BOXES_OFFSET");
writer.RemoveLooseObjectPtr("UNK12BOXES_OFFSET");
writer.RemoveLooseObjectPtr("UNK14BOXES_OFFSET");
writer.RemoveLooseObjectPtr("EDGES_OFFSET");
writer.RemoveLooseObjectPtr("UNK18BOXES_OFFSET");
// solve end of set
writer.SolveLooseObjectPtr("SET_END_OFFSET_" + x);
}
}
writer.SolveLooseObjectPtr("GRID_END");
/*writer.Write(0);
*
* // write size of mesh
* uint SizeOfMesh = (uint)(writer.BaseStream.Position - MESH_START);
* writer.Write(SizeOfMesh);*/
}
public void ReadFromFile(MemoryStream stream, bool isBigEndian)
{
transform = MatrixExtensions.ReadFromFile(stream, isBigEndian);
bounds = BoundingBoxExtenders.ReadFromFile(stream, isBigEndian);
isValid = stream.ReadByte8();
}
public void ReadFromFile(BinaryReader reader, StreamWriter writer)
{
//KynogonRuntimeMesh
long mesh_pos = reader.BaseStream.Position;
string magicName = new string(reader.ReadChars(18));
if (magicName != "KynogonRuntimeMesh")
{
throw new FormatException("Did not find KynogonRuntimeMesh");
}
short mesh_unk0 = reader.ReadInt16();
int magicVersion = reader.ReadInt32();
if (magicVersion != 2)
{
throw new FormatException("Version did not equal 2");
}
writer.WriteLine("");
Unk0 = reader.ReadInt32();
Unk1 = reader.ReadInt32();
Unk2 = reader.ReadSingle();
Unk3 = reader.ReadSingle();
writer.WriteLine(Unk0);
writer.WriteLine(Unk1);
writer.WriteLine(Unk2);
writer.WriteLine(Unk3);
float boundMinX = reader.ReadSingle();
float boundMaxX = reader.ReadSingle();
float boundMaxY = -reader.ReadSingle();
float boundMinY = -reader.ReadSingle();
BoundMin = new Vector2(boundMinX, boundMinY);
BoundMax = new Vector2(boundMaxX, boundMaxY);
writer.WriteLine(BoundMin);
writer.WriteLine(BoundMax);
//BoundingBox = BoundingBoxExtenders.ReadFromFile(reader);
CellSizeX = reader.ReadInt32();
CellSizeY = reader.ReadInt32();
writer.WriteLine(CellSizeX);
writer.WriteLine(CellSizeY);
Radius = reader.ReadSingle();
Unk4 = reader.ReadInt32();
Height = reader.ReadInt32();
Offset = reader.ReadInt32(); //this is a potential offset;
writer.WriteLine(Radius);
writer.WriteLine(Unk4);
writer.WriteLine(Height);
writer.WriteLine(Offset);
Grid = new int[(CellSizeX * CellSizeY)];
Cells = new Cell[Grid.Length];
writer.WriteLine("");
for (int i = 0; i < Grid.Length; i++)
{
Grid[i] = reader.ReadInt32();
}
int end = reader.ReadInt32();
for (int i = 0; i < Cells.Length; i++)
{
//if (i + 1 >= Cells.Length)
// break;
Cell cell = new Cell();
int numSet0 = reader.ReadInt32();
cell.Sets = new UnkSet0[numSet0];
Cells[i] = cell;
writer.WriteLine("-----------------------");
writer.WriteLine(string.Format("{0} {1}", i, numSet0));
writer.WriteLine("");
if (numSet0 == 0)
{
continue;
}
//NOTE: EVERY OFFSET IN UNKSET0 BEGINS FROM MESH_POS HIGHER IN THE CODE FILE.
cell.Offset = reader.ReadInt32();
for (int x = 0; x < numSet0; x++)
{
UnkSet0 set = new UnkSet0();
set.X = reader.ReadSingle();
set.Y = reader.ReadSingle();
set.Offset = reader.ReadInt32();
cell.Sets[x] = set;
}
//NOTE: EVERY BLOCK OF DATA SEEMS TO START WITH 96, THIS IS HOWEVER UNCONFIRMED.
for (int z = 0; z < numSet0; z++)
{
UnkSet0 set = cell.Sets[z];
//NOTE: MOST OF THE OFFSETS BEGIN HERE, JUST AFTER THE SETS HAVE BEEN DEFINED ABOVE.
set.cellUnk0 = reader.ReadInt32();
if (set.cellUnk0 != Unk1)
{
throw new FormatException();
}
writer.WriteLine("");
set.cellUnk1 = reader.ReadInt32();
set.cellUnk2 = reader.ReadInt32();
set.cellUnk3 = reader.ReadInt32();
set.cellUnk4 = reader.ReadSingle();
set.cellUnk5 = reader.ReadSingle();
set.cellUnk6 = reader.ReadSingle();
set.cellUnk7 = reader.ReadSingle();
set.cellUnk8 = reader.ReadInt32();
set.cellUnk9 = reader.ReadInt32(); //-1?
set.cellUnk10 = reader.ReadInt32(); //1;
set.cellUnk11 = reader.ReadInt32();
set.cellUnk12 = reader.ReadInt32(); //0
set.cellUnk13 = reader.ReadInt32(); //-1;
set.cellUnk14 = reader.ReadInt32(); //0
set.cellUnk15 = reader.ReadInt32(); //-1;
set.NumEdges = reader.ReadInt32(); //8;
set.cellUnk17 = reader.ReadInt32(); //112;
set.cellUnk18 = reader.ReadInt32(); //0;
set.cellUnk19 = reader.ReadInt32(); //-1;
writer.WriteLine(string.Format("Unk1: {0}", set.cellUnk1));
writer.WriteLine(string.Format("Unk2: {0}", set.cellUnk2));
writer.WriteLine(string.Format("Unk3: {0}", set.cellUnk3));
writer.WriteLine(string.Format("Unk4: {0}", set.cellUnk4));
writer.WriteLine(string.Format("Unk5: {0}", set.cellUnk5));
writer.WriteLine(string.Format("Unk6: {0}", set.cellUnk6));
writer.WriteLine(string.Format("Unk7: {0}", set.cellUnk7));
writer.WriteLine(string.Format("Unk8: {0}", set.cellUnk8));
writer.WriteLine(string.Format("Unk9: {0}", set.cellUnk9));
writer.WriteLine(string.Format("Unk10: {0}", set.cellUnk10));
writer.WriteLine(string.Format("Unk11: {0}", set.cellUnk11));
writer.WriteLine(string.Format("Unk12: {0}", set.cellUnk12));
writer.WriteLine(string.Format("Unk13: {0}", set.cellUnk13));
writer.WriteLine(string.Format("Unk14: {0}", set.cellUnk14));
writer.WriteLine(string.Format("Unk15: {0}", set.cellUnk15));
writer.WriteLine(string.Format("Unk16: {0}", set.NumEdges));
writer.WriteLine(string.Format("Unk17: {0}", set.cellUnk17));
writer.WriteLine(string.Format("Unk18: {0}", set.cellUnk18));
writer.WriteLine(string.Format("Unk19: {0}", set.cellUnk19));
writer.WriteLine("");
//THIS BIT IS UNKNOWN, UPTO CELLUNK20
set.unk10Boxes = new Unk10DataSet[set.cellUnk10];
writer.WriteLine("Unk10 Boxes");
for (int x = 0; x < set.cellUnk10; x++)
{
Unk10DataSet unk10Set = new Unk10DataSet();
unk10Set.B1 = BoundingBoxExtenders.ReadFromFile(reader);
unk10Set.UnkOffset = reader.ReadInt32();
unk10Set.Unk20 = reader.ReadInt32();
set.unk10Boxes[x] = unk10Set;
writer.WriteLine(string.Format("Minimum: {0} ", unk10Set.B1.Minimum.ToString()));
writer.WriteLine(string.Format("Maximum: {0} ", unk10Set.B1.Maximum.ToString()));
writer.WriteLine(string.Format("UnkOffset: {0} ", unk10Set.UnkOffset));
writer.WriteLine(string.Format("Unk20: {0} ", unk10Set.Unk20));
writer.WriteLine("");
}
//END OF CONFUSING BIT.
//THIS BIT IS UNKNOWN, BUT IS CELLUNK12
set.unk12Boxes = new Unk12DataSet[set.cellUnk12];
writer.WriteLine("Unk12 Boxes");
for (int x = 0; x < set.cellUnk12; x++)
{
Unk12DataSet unk12Set = new Unk12DataSet();
unk12Set.B1 = BoundingBoxExtenders.ReadFromFile(reader);
unk12Set.Unk01 = reader.ReadInt32();
unk12Set.Unk02 = reader.ReadInt32();
unk12Set.Unk03 = reader.ReadSingle();
unk12Set.Unk04 = reader.ReadSingle();
unk12Set.Unk05 = reader.ReadSingle();
set.unk12Boxes[x] = unk12Set;
writer.WriteLine(string.Format("Minimum: {0} ", unk12Set.B1.Minimum.ToString()));
writer.WriteLine(string.Format("Maximum: {0} ", unk12Set.B1.Maximum.ToString()));
writer.WriteLine(string.Format("Unk01: {0} ", unk12Set.Unk01));
writer.WriteLine(string.Format("Unk02: {0} ", unk12Set.Unk02));
writer.WriteLine(string.Format("Unk03: {0} ", unk12Set.Unk03));
writer.WriteLine(string.Format("Unk04: {0} ", unk12Set.Unk04));
writer.WriteLine(string.Format("Unk05: {0} ", unk12Set.Unk05));
writer.WriteLine("");
}
//END OF CONFUSING BIT.
//THIS LOOPS THROUGH OFFSETS TO BBOX'S
writer.WriteLine("Unk14 Offsets");
set.unk14Boxes = new Unk14DataSet[set.cellUnk14];
for (int x = 0; x < set.cellUnk14; x++)
{
var dataSet = new Unk14DataSet();
dataSet.Offset = reader.ReadInt32();
set.unk14Boxes[x] = dataSet;
writer.WriteLine(string.Format("{0} ", dataSet.Offset));
}
//ALWAYS A 4-BYTE INTEGER WHICH DENOTES THE END OF THE BATCH
if (set.cellUnk14 > 0)
{
set.unk14End = reader.ReadInt32();
var currentOffset = set.unk14Boxes[0].Offset;
for (int x = 0; x < set.cellUnk14; x++)
{
var dataSet = set.unk14Boxes[x];
var offset = (x + 1 < set.cellUnk14 ? set.unk14Boxes[x + 1].Offset : set.unk14End);
var size = offset - currentOffset;
currentOffset = offset;
var count = size / 12;
dataSet.Points = new Vector3[count];
writer.WriteLine(string.Format("Unk14: {0} {1}", x, count));
for (int f = 0; f < dataSet.Points.Length; f++)
{
dataSet.Points[f] = Vector3Extenders.ReadFromFile(reader);
writer.WriteLine("{0}: {1}", f, dataSet.Points[f]);
}
set.unk14Boxes[x] = dataSet;
}
}
writer.WriteLine("");
//CONTINUE ONTO THE NEXT BATCH
set.unk16Offsets = new int[set.NumEdges];
writer.WriteLine("Unk16 Offsets");
for (int x = 0; x < set.NumEdges; x++)
{
set.unk16Offsets[x] = reader.ReadInt32();
writer.WriteLine(string.Format("{0} ", set.unk16Offsets[x]));
}
writer.WriteLine("");
//ALWAYS A 4-BYTE INTEGER WHICH DENOTES THE END OF THE BATCH
if (set.NumEdges > 0)
{
set.EdgesDataEndOffset = reader.ReadInt32();
}
set.EdgeBoxes = new BoundingBox[set.NumEdges];
writer.WriteLine("Unk16 Boxes");
for (int x = 0; x < set.NumEdges; x++)
{
set.EdgeBoxes[x] = BoundingBoxExtenders.ReadFromFile(reader);
writer.WriteLine(string.Format("{0} ", set.EdgeBoxes[x]));
}
set.unk18Set = new Unk18DataSet[set.cellUnk18];
writer.WriteLine("");
if (set.cellUnk18 > 0)
{
set.unk18End = reader.ReadInt32();
writer.WriteLine("Unk18 Boxes:");
for (int x = 0; x < set.cellUnk18; x++)
{
//THIS COULD BE AN OFFSET LIST WITH SOMEKIND OF FLOAT/ROTATION DATA
Unk18DataSet dataSet = new Unk18DataSet();
dataSet.Unk0 = reader.ReadSingle();
dataSet.Unk1 = reader.ReadSingle();
dataSet.Unk2 = reader.ReadSingle();
dataSet.Offset = reader.ReadInt32();
writer.WriteLine(string.Format("{0} {1} {2} {3}", dataSet.Unk0, dataSet.Unk1, dataSet.Unk2, dataSet.Offset));
set.unk18Set[x] = dataSet;
}
byte[] unknown_data = reader.ReadBytes(12); //usually padding
var currentOffset = set.unk18End;
for (int x = 0; x < set.cellUnk18; x++)
{
var dataSet = set.unk18Set[x];
var size = dataSet.Offset - currentOffset;
var count = size / 12;
dataSet.Points = new Vector3[count];
for (int f = 0; f < dataSet.Points.Length; f++)
{
dataSet.Points[f] = Vector3Extenders.ReadFromFile(reader);
writer.WriteLine("{0}: {1}", f, dataSet.Points[f]);
}
currentOffset = dataSet.Offset;
set.unk18Set[x] = dataSet;
}
}
writer.WriteLine("");
cell.Sets[z] = set;
}
Console.WriteLine("Completed: " + i);
//byte[] data = reader.ReadBytes(size);
//File.WriteAllBytes("grid_" + i + ".bin", data);
}
writer.Close();
//File.WriteAllLines("model.obj", data.ToArray());
}
public void ReadFromFile(BinaryReader reader)
{
version = reader.ReadInt32();
unk1 = reader.ReadInt32();
unk2 = reader.ReadInt16();
bounds = BoundingBoxExtenders.ReadFromFile(reader);
numGrids = reader.ReadInt32();
Grids = new Grid[numGrids];
for (int i = 0; i < numGrids; i++)
{
Grid grid = new Grid();
grid.Key = reader.ReadInt16();
grid.Origin = Vector3Extenders.ReadFromFile(reader);
grid.CellSize = Vector2Extenders.ReadFromFile(reader);
grid.Width = reader.ReadInt32();
grid.Height = reader.ReadInt32();
grid.Data = new ushort[grid.Width * grid.Height];
for (int y = 0; y != grid.Data.Length; y++)
{
grid.Data[y] = reader.ReadUInt16();
}
Grids[i] = grid;
}
numUnk3 = reader.ReadInt32();
unk3 = new short[numUnk3 * 2];
for (int i = 0; i < numUnk3 * 2; i++)
{
unk3[i] = reader.ReadInt16();
}
numObjectGroups = reader.ReadInt32();
ObjectGroups = new ObjectGroup[numObjectGroups];
for (int i = 0; i != numObjectGroups; i++)
{
ObjectGroup objectGroup = new ObjectGroup();
objectGroup.Unk01 = reader.ReadInt16();
objectGroup.NumObjects = reader.ReadInt32();
objectGroup.Objects = new Object[objectGroup.NumObjects];
for (int x = 0; x != objectGroup.NumObjects; x++)
{
Object obj = new Object();
obj.NumInstance2 = reader.ReadInt16();
obj.Unk02 = reader.ReadInt16();
obj.Name = new HashName();
ulong hashvalue = reader.ReadUInt64();
obj.Name.Hash = hashvalue;
obj.Name.String = StringHelpers.ReadString(reader);
Debug.Assert(obj.Name.Hash == hashvalue, "Object Hash and Name should be identical");
obj.UnkBytes1 = reader.ReadBytes(31 - obj.Name.ToString().Length);
obj.GridMax = reader.ReadSingle();
obj.GridMin = reader.ReadSingle();
obj.NumInstances = reader.ReadInt32();
obj.Instances = new Instance[obj.NumInstances];
for (int y = 0; y != obj.NumInstances; y++)
{
byte[] packed = reader.ReadBytes(14);
Instance instance = new Instance();
instance.W0 = BitConverter.ToUInt16(packed, 0);
instance.W1 = BitConverter.ToUInt16(packed, 2);
instance.W2 = BitConverter.ToUInt16(packed, 4);
instance.D5 = BitConverter.ToInt32(packed, 6);
instance.ID = BitConverter.ToUInt16(packed, 10);
instance.D4 = BitConverter.ToUInt16(packed, 12);
DecompressScale(instance);
DecompressRotation(instance);
instance.Position = DecompressPosition(packed, instance, bounds.Minimum, bounds.Maximum);
obj.Instances[y] = instance;
}
objectGroup.Objects[x] = obj;
}
ObjectGroups[i] = objectGroup;
}
}
public void ReadFromFile(BinaryReader reader)
{
version = reader.ReadInt32();
unk1 = reader.ReadInt32();
unk2 = reader.ReadInt16();
bounds = BoundingBoxExtenders.ReadFromFile(reader);
numGrids = reader.ReadInt32();
Grids = new Grid[numGrids];
for (int i = 0; i < numGrids; i++)
{
Grid grid = new Grid();
grid.Key = reader.ReadInt16();
grid.Origin = Vector3Extenders.ReadFromFile(reader);
grid.CellSize = Vector2Extenders.ReadFromFile(reader);
grid.Width = reader.ReadInt32();
grid.Height = reader.ReadInt32();
grid.Data = new ushort[grid.Width * grid.Height];
for (int y = 0; y != grid.Data.Length; y++)
{
grid.Data[y] = reader.ReadUInt16();
}
Grids[i] = grid;
}
numUnk3 = reader.ReadInt32();
unk3 = new short[numUnk3 * 2];
for (int i = 0; i < numUnk3 * 2; i++)
{
unk3[i] = reader.ReadInt16();
}
numObjectGroups = reader.ReadInt32();
ObjectGroups = new ObjectGroup[numObjectGroups];
for (int i = 0; i != numObjectGroups; i++)
{
ObjectGroup objectGroup = new ObjectGroup();
objectGroup.Unk01 = reader.ReadInt16();
objectGroup.NumObjects = reader.ReadInt32();
objectGroup.Objects = new Object[objectGroup.NumObjects];
for (int x = 0; x != objectGroup.NumObjects; x++)
{
Object obj = new Object();
obj.NumInstance2 = reader.ReadInt16();
obj.Unk02 = reader.ReadInt16();
obj.Hash = reader.ReadUInt64();
obj.Name = StringHelpers.ReadString(reader);
obj.UnkBytes1 = reader.ReadBytes(31 - obj.Name.Length);
obj.GridMax = reader.ReadSingle();
obj.GridMin = reader.ReadSingle();
obj.NumInstances = reader.ReadInt32();
obj.Instances = new Instance[obj.NumInstances];
for (int y = 0; y != obj.NumInstances; y++)
{
byte[] packed = reader.ReadBytes(14);
Instance instance = new Instance();
instance.W0 = BitConverter.ToUInt16(packed, 0);
instance.W1 = BitConverter.ToUInt16(packed, 2);
instance.W2 = BitConverter.ToUInt16(packed, 4);
instance.D5 = BitConverter.ToInt32(packed, 6);
instance.ID = BitConverter.ToUInt16(packed, 10);
instance.D4 = BitConverter.ToUInt16(packed, 12);
if (!IDs.Contains(instance.ID))
{
IDs.Add(instance.ID);
}
else
{
Console.WriteLine("Duplication!! {0} {1}", obj.Name, instance.ID);
}
DecompressScale(instance);
DecompressRotation(instance);
instance.Position = DecompressPosition(packed, instance, bounds.Minimum, bounds.Maximum);
obj.Instances[y] = instance;
}
objectGroup.Objects[x] = obj;
}
ObjectGroups[i] = objectGroup;
}
IDs.Sort();
}
public void ReadFromFile(MemoryStream reader, bool isBigEndian)
{
transform = new TransformMatrix(reader, isBigEndian);
bounds = BoundingBoxExtenders.ReadFromFile(reader, isBigEndian);
isValid = reader.ReadByte8();
}
