/// <summary>
/// Write a PrmEntry with specified Binary Writer.
/// </summary>
/// <param name="bw">Binary Writer to use.</param>
public void Write(DhBinaryWriter bw)
{
// Write Hash.
bw.WriteU16(Hash);
// Write NameLength.
bw.WriteU16(NameLength);
// Write Name.
bw.WriteStr(Name);
// Write ValueLength.
bw.WriteU32(ValueLength);
// Check Type.
switch (Type)
{
case PrmType.BYTE:
// Write Value as a byte.
bw.Write((byte)Value);
break;
case PrmType.SHORT:
// Write Value as a short.
bw.WriteS16((short)Value);
break;
case PrmType.INT:
// Write Value as a int.
bw.WriteS32((int)Value);
break;
case PrmType.FLOAT:
// Write Value as a float.
bw.WriteF32((float)Value);
break;
case PrmType.RGBA:
// Write Value as a Clr4.
bw.WriteClr4((Clr4)Value);
break;
case PrmType.VECTOR3:
// Write Value as a Vector3.
bw.WriteVec3((Vec3)Value);
break;
default:
throw new NotImplementedException("PRM parameter entry type is unknown!");
}
}
/// <summary>
/// Creates a byte array from this TMB.
/// </summary>
/// <returns>The TMB as a byte array.</returns>
public byte[] Write()
{
// Define a stream to hold our TMB data.
MemoryStream stream = new MemoryStream();
// Define a binary writer to write with.
DhBinaryWriter bw = new DhBinaryWriter(stream, DhEndian.Big);
// Write the amount of sequences.
bw.WriteU16((ushort)Sequences.Count);
// Find the largest duration value in each keyframe in each sequence.
float longestDuration = Sequences.Max(s => s.KeyFrames.Max(k => k.Time));
// Write the largest duration. (This is the duration of the timing)
bw.WriteU16((ushort)longestDuration);
// Write placeholder for sequence data offset.
bw.WriteU32(0);
// Loop through sequences within this bank.
foreach (TMBSequence sequence in Sequences)
{
// Loop through keyframe's within this sequence.
foreach (TIMKeyFrame keyframe in sequence.KeyFrames)
{
// Write this keyframe.
keyframe.Write(bw);
}
}
// Save the sequence data offset.
uint sequenceDataOffset = (uint)bw.Position();
// Goto sequence data offset value.
bw.Goto(4);
// Write sequence data offset.
bw.WriteU32(sequenceDataOffset);
// Go back to end of stream.
bw.Back(0);
// Loop through sequences within this bank.
foreach (TMBSequence sequence in Sequences)
{
// Write this sequence.
sequence.Write(bw);
}
// Pad to nearest whole 32.
bw.WritePadding32();
// Return the TMB as byte array.
return(stream.ToArray());
}
/// <summary>
/// Write a single graph object with BinaryWriter.
/// </summary>
/// <param name="bw">Binary Writer to use.</param>
/// <param name="graphObjectsOffset">Offset to the graph objects.</param>
public void Write(DhBinaryWriter bw)
{
// Write parent graphobject index.
bw.WriteS16(ParentIndex);
// Write child graphobject index.
bw.WriteS16(ChildIndex);
// Write next graphobject index.
bw.WriteS16(NextIndex);
// Write previous graphobject index.
bw.WriteS16(PreviousIndex);
// Write renderflags.
bw.WriteU16((ushort)RenderFlags);
// Write unknown 1.
bw.WriteU16(Unknown1);
// Write scale.
bw.WriteVec3(Scale);
// Write rotation.
bw.WriteVec3(Rotation);
// Write position.
bw.WriteVec3(Position);
// Write bounding box minimum.
bw.WriteVec3(BoundingBoxMinimum);
// Write bounding box maximum.
bw.WriteVec3(BoundingBoxMaximum);
// Write bounding sphere radius.
bw.WriteF32(BoundingSphereRadius);
// Write part count.
bw.WriteS16((short)Parts.Count);
// Write unknown 3.
bw.WriteU16(Unknown3);
// Write part offset. (CALCULATED)
bw.WriteU32(0);
// Write unknown 4.
bw.WriteU32s(Unknown4);
// Write unknown 4. TODO - Why does demolisher only read file if padding is written twice??
bw.WriteU32s(Unknown4);
}
public Stream Write()
{
// Buffer for new TXP File
Stream stream = new MemoryStream();
// Define a binary writer to write with.
DhBinaryWriter bw = new DhBinaryWriter(stream, DhEndian.Big);
// Write the fixed Unknown values
bw.WriteU16(1);
bw.WriteU16(0);
// Write Entry Count
bw.WriteU16((ushort)TXPEntries.Count);
// Write Frame Count
bw.WriteU16(FrameCount);
//Calculate and write frame data offset
bw.WriteU32((uint)(0xC * TXPEntries.Count));
bw.SaveOffset(0);
//Write dummy entry headers
for (int i = 0; i < TXPEntries.Count; i++)
{
bw.WriteU64(0);
bw.WriteU32(0);
}
//Make a list to store the offsets for each entry's frame data
List <long> frameDataOffsets = new List <long>();
//Write the entries
for (int entry = 0; entry < TXPEntries.Count; entry++)
{
TXPEntries[entry].Write(bw, frameDataOffsets);
}
bw.LoadOffset(0);
//Write frame data offsets
for (int i = 0; i < TXPEntries.Count; i++)
{
bw.WriteU16(1);
bw.WriteS16(TXPEntries[i].MaterialIndex);
bw.WriteU32(0);
bw.WriteU32((uint)frameDataOffsets[i]);
}
// Returns the TXP as a stream
return(stream);
}
public void Write(DhBinaryWriter bw)
{
// Write name.
bw.WriteFixedStr(Name, 28);
// Write keyframe count.
bw.WriteU32(KeyFrameCount);
// Write start index.
bw.WriteU16(StartIndex);
// Write keyframe size.
bw.WriteU16(KeyFrameSize);
}
/// <summary>
/// Creates a byte array from this BAS.
/// </summary>
/// <returns>The BAS as a byte array.</returns>
public byte[] Write()
{
// Define a stream to hold our JMP data.
MemoryStream stream = new MemoryStream();
// Define a binary writer to write with.
DhBinaryWriter bw = new DhBinaryWriter(stream, DhEndian.Big);
// Write entry count.
bw.WriteU16(EntryCount);
// Write unknown 1.
bw.Write(Unknown1);
// Write padding.
bw.Write(Padding);
// Loop through the BAS entries.
for (int i = 0; i < Entries.Count; i++)
{
// Write entry.
Entries[i].Write(bw);
}
// Returns the BAS as a byte array.
return(stream.ToArray());
}
/// <summary>
/// Write a single batch.
/// </summary>
/// <param name="bw">The binarywriter to write with.</param>
public void Write(DhBinaryWriter bw)
{
// Write face count.
bw.WriteU16(FaceCount);
// Write list size. (CALCULATED)
bw.WriteS16(0);
// Write vertex attributes.
bw.WriteU32((uint)VertexAttributes);
// Write normals flag.
bw.Write(UseNormals ? 1 : 0);
// Write position winding flag.
bw.Write(Positions);
// Write uv count.
bw.Write(UvCount);
// Write NBT flag.
bw.Write(UseNBT ? 1 : 0);
// Write primitive offset. (CALCULATED)
bw.WriteU32(0);
// Write unknown 1.
bw.WriteS32s(Unknown1); // 8 bytes
}
/// <summary>
/// Write a single triangle group with specified Binary Writer.
/// </summary>
/// <param name="bw">Binary Writer to use.</param>
public void Write(DhBinaryWriter bw)
{
// Write indices.
bw.WriteU16s(Indices);
// Write ushort to define end of this triangle group.
bw.WriteU16(0xFFFF);
}
/// <summary>
/// Write a single field to stream.
/// </summary>
/// <param name="bw">Binary Writer to use.</param>
public void Write(DhBinaryWriter bw)
{
bw.WriteU32(Hash);
bw.WriteU32(Bitmask);
bw.WriteU16(Offset);
bw.WriteS8(Shift);
bw.WriteU8((byte)Type);
}
/// <summary>
/// Write entry data.
/// </summary>
/// <param name="bw">The binarywriter to write with.</param>
public void WriteIndices(DhBinaryWriter bw)
{
// Loop through indices.
for (int i = 0; i < Indices.Count; i++)
{
// Write index.
bw.WriteU16(Indices[i]);
}
}
/// <summary>
/// Write a single texture with specified Binary Writer.
/// </summary>
/// <param name="bw">Binary Writer to use.</param>
public void Write(DhBinaryWriter bw)
{
// Write texture width.
bw.WriteU16(Width);
// Write texture width.
bw.WriteU16(Height);
// Write texture format.
bw.WriteU8((byte)Format);
// Write texture unknown 1. (Flags?)
bw.WriteU8(AlphaFlag);
// Write texture unknown 2. (Padding)
bw.WriteU16(Unknown1);
// Write texture data offset.
bw.WriteU32(DataOffset);
}
/// <summary>
/// Write a single entry header.
/// </summary>
/// <param name="bw">The binarywriter to write with.</param>
public void WriteHeader(DhBinaryWriter bw)
{
// Write Unknown 1.
bw.WriteS16(Unknown1);
// Write Material Index.
bw.WriteU16(MaterialIndex);
// Write Unknown 2.
bw.WriteS32(Unknown2);
// Write Indices Offset.
bw.WriteU32(IndicesOffset);
}
/// <summary>
/// Write a single field to stream.
/// </summary>
/// <param name="bw">Binary Writer to use.</param>
public void Write(DhBinaryWriter bw)
{
// Write the field's hash.
bw.WriteU32(Hash);
// Write the field's bitmask.
bw.WriteU32(Bitmask);
// Write the field's offset.
bw.WriteU16(Offset);
// Write the field's shift.
bw.WriteS8(Shift);
// Write the field's type.
bw.WriteU8((byte)Type);
}
/// <summary>
/// Creates a byte array from this MP. TODO: Complete writing.
/// </summary>
/// <returns>The MP as a byte array.</returns>
public byte[] Write()
{
// Define a stream to hold our MP data.
MemoryStream stream = new MemoryStream();
// Define a binary writer to write with.
DhBinaryWriter bw = new DhBinaryWriter(stream, DhEndian.Big);
// Define a buffer to store our offsets.
uint[] offsets = new uint[7];
// Write Grid Scale.
bw.WriteVec3(GridScale);
// Write Minimum Bounds.
bw.WriteVec3(MinimumBounds);
// Write Axis Lengths.
bw.WriteVec3(AxisLengths);
// Write offsets. (CALCULATED)
bw.WriteU32s(offsets);
// Set vertices offset.
offsets[0] = (uint)bw.Position();
// Loop through vertices.
for (int i = 0; i < Vertices.Count; i++)
{
// Write vertex.
bw.WriteVec3(Vertices[i]);
}
// Set normals offset.
offsets[1] = (uint)bw.Position();
// Loop through normals.
for (int i = 0; i < Normals.Count; i++)
{
// Write normals.
bw.WriteVec3(Normals[i]);
}
// Set triangle data offset.
offsets[2] = (uint)bw.Position();
// Loop through triangle data.
for (int i = 0; i < TriangleData.Count; i++)
{
// Write triangle data.
TriangleData[i].Write(bw);
}
// Set triangle groups offset.
offsets[3] = (uint)bw.Position();
// Write ushort to define beginning of triangle groups section.
bw.WriteU16(0xFFFF);
// Loop through triangle groups.
for (int i = 0; i < TriangleGroups.Count; i++)
{
// Write triangle group.
TriangleGroups[i].Write(bw);
}
// Write ushort to define ending of triangle groups section.
bw.WriteU16(0xFFFF);
// Set grid indices offset.
offsets[4] = (uint)bw.Position();
// Set duplicated grid indices offset.
offsets[5] = (uint)bw.Position();
// Loop through grid indices.
for (int i = 0; i < GridIndices.Count; i++)
{
// Write grid index.
GridIndices[i].Write(bw);
}
// Set unknown data offset.
offsets[6] = (uint)bw.Position();
// Loop through unknown data. (3 bytes each)
for (int i = 0; i < Unknowns.Count; i++)
{
// Write unknown data.
Unknowns[i].Write(bw);
}
// Pad to nearest whole 32.
bw.WritePadding32('@');
// Goto offsets section.
bw.Goto(36);
// Write offsets.
bw.WriteU32s(offsets);
// Return the MP as a byte array.
return(stream.ToArray());
}
/// <summary>
/// Creates a byte array from this BIN.
/// </summary>
/// <returns>The BIN as a byte array.</returns>
public byte[] Write()
{
// Define a stream to hold our BIN data.
MemoryStream stream = new MemoryStream();
// Define a binary writer to write with.
DhBinaryWriter bw = new DhBinaryWriter(stream, DhEndian.Big);
// Define a buffer to store our offsets.
uint[] offsets = new uint[21];
// Write version.
bw.Write(Version);
// Write model Name.
bw.WriteFixedStr(ModelName, 11);
// Write offsets.
bw.WriteU32s(Offsets);
// Make sure bin has textures.
if (Textures.Count > 0)
{
// Set textures offset.
offsets[0] = (uint)bw.Position();
// Define a array to temporarily
uint[] textureDataOffsets = new uint[Textures.Count];
// Write texture headers. (CALCULATED)
bw.Write(new byte[Textures.Count * 0x0C]);
// Pad to nearest whole 32.
bw.WritePadding32();
// Loop through textures to write texture data.
for (int i = 0; i < textureDataOffsets.Length; i++)
{
// Get actual offset of texture data.
textureDataOffsets[i] = (uint)bw.Position() - offsets[0];
// Write texture data.
bw.Write(Textures[i].Data);
}
// Store this so we can resume after writing the texture headers.
long currentOffset = (uint)bw.Position();
// Pad to nearest whole 32.
bw.WritePadding32();
// Goto textures offset.
bw.Goto(offsets[0]);
// Loop through textures to write texture headers.
for (int i = 0; i < Textures.Count; i++)
{
// Write texture width.
bw.WriteU16(Textures[i].Width);
// Write texture height.
bw.WriteU16(Textures[i].Height);
// Write texture format.
bw.Write((byte)Textures[i].Format);
// Write texture alpha flag.
bw.Write(Textures[i].AlphaFlag);
// Write padding.
bw.WriteU16(0);
// Write texture dataoffset.
bw.WriteU32(textureDataOffsets[i]);
}
// Goto resume point.
bw.Goto(currentOffset);
// Pad to nearest whole 32.
bw.WritePadding32();
}
// Make sure bin has materials.
if (Materials.Count > 0)
{
// Set materials offset.
offsets[1] = (uint)bw.Position();
// Loop through materials.
for (int i = 0; i < Materials.Count; i++)
{
// Write material.
Materials[i].Write(bw);
}
// Pad to nearest whole 32.
bw.WritePadding32();
}
// Make sure bin has positions.
if (Positions.Count > 0)
{
// Set positions offset.
offsets[2] = (uint)bw.Position();
// Loop through positions.
for (int i = 0; i < Positions.Count; i++)
{
// Write position.
bw.WriteS16s(new short[] { (short)(Positions[i].X * 256.0f), (short)(Positions[i].Y * 256.0f), (short)(Positions[i].Z * 256.0f) });
}
// Pad to nearest whole 32.
bw.WritePadding32();
}
// Make sure bin has normals.
if (Normals.Count > 0)
{
// Set normals offset.
offsets[3] = (uint)bw.Position();
// Loop through normals.
for (int i = 0; i < Normals.Count; i++)
{
// Write normal.
bw.WriteVec3(Normals[i]);
}
// Pad to nearest whole 32.
bw.WritePadding32();
}
// SKIP COLOR0
offsets[4] = (uint)0;
// SKIP COLOR1
offsets[5] = (uint)0;
// Make sure bin has texture coordinates 0.
if (TextureCoordinates0.Count > 0)
{
// Set texture coordinates 0 offset.
offsets[6] = (uint)bw.Position();
// Loop through texture coordinates 0.
for (int i = 0; i < TextureCoordinates0.Count; i++)
{
// Write texture coordinate 0.
bw.WriteVec2(TextureCoordinates0[i]);
}
// Pad to nearest whole 32.
bw.WritePadding32();
}
// SKIP TEXTURE COORDINATES 1
offsets[7] = (uint)0;
// SKIP TEXTURE COORDINATES 2 (?)
offsets[8] = (uint)0;
// SKIP TEXTURE COORDINATES 3 (?)
offsets[9] = (uint)0;
// Make sure bin has shaders.
if (Shaders.Count > 0)
{
// Set shaders offset.
offsets[10] = (uint)bw.Position();
// Loop through shaders.
for (int i = 0; i < Shaders.Count; i++)
{
// Write shader.
Shaders[i].Write(bw);
}
// Pad to nearest whole 32.
bw.WritePadding32();
}
// Make sure bin has batches.
if (Batches.Count > 0)
{
// Set batches offset.
offsets[11] = (uint)bw.Position();
// Loop through batches.
for (int i = 0; i < Batches.Count; i++)
{
// Write batch headers.
Batches[i].Write(bw);
}
// Pad to nearest whole 32.
bw.WritePadding32();
// We need to store this stuff somewhere
long[] listStarts = new long[Batches.Count];
long[] listEnds = new long[Batches.Count];
// Loop through batches. (Write primitives)
for (int i = 0; i < Batches.Count; i++)
{
// We'll store this offset for later.
listStarts[i] = bw.Position();
// Loop through primitives.
for (int y = 0; y < Batches[i].Primitives.Count; y++)
{
// Write primitive.
Batches[i].Primitives[y].Write(bw, Batches[i].VertexAttributes);
}
// We'll store this offset for later.
listEnds[i] = bw.Position();
}
// This offset is where we'll continue writing from.
long currentOffset = bw.Position();
// Loop through batches. (Write offsets)
for (int i = 0; i < Batches.Count; i++)
{
// Goto current batch's offset.
bw.Goto(offsets[11] + i * 24);
// Skip 2 bytes.
bw.Sail(2);
// Write list size represented as 32 byte blocks.
bw.WriteS16((short)(Math.Ceiling((float)(listEnds[i] - listStarts[i]) / 32)));
// Skip 8 bytes.
bw.Sail(8);
// Write primitive list offset.
bw.WriteU32((uint)(listStarts[i] - offsets[11]));
}
// Goto continue point we saved earlier.
bw.Goto(currentOffset);
// Pad to nearest whole 32.
bw.WritePadding32();
}
// Make sure bin has graphobjects.
if (GraphObjects.Count > 0)
{
// Set graphObjects offset.
offsets[12] = (uint)bw.Position();
// Loop through graphObjects.
for (int i = 0; i < GraphObjects.Count; i++)
{
// Write graphObject headers.
GraphObjects[i].Write(bw);
}
// Pad to nearest whole 16.
bw.WritePadding16();
// Array to hold graphobject's parts offset.
long[] graphObjectsPartsOffsets = new long[GraphObjects.Count];
// Loop through graphObjects. (Write parts)
for (int i = 0; i < GraphObjects.Count; i++)
{
// Store this graphobject's part offset.
graphObjectsPartsOffsets[i] = bw.Position();
// Loop through graphobject's parts.
for (int y = 0; y < GraphObjects[i].Parts.Count; y++)
{
// Write graphobject's parts.
GraphObjects[i].Parts[y].Write(bw);
}
}
// This offset is where we'll continue writing from.
long currentOffset = bw.Position();
// Loop through graphObjects. (Write offsets)
for (int i = 0; i < GraphObjects.Count; i++)
{
// Goto current graphobject's part offset.
bw.Goto(offsets[12] + (i * 140));
// Skip 80 bytes.
bw.Sail(80);
// Write graphobject's part offset.
bw.WriteU32((uint)(graphObjectsPartsOffsets[i] - offsets[12]));
}
// Goto continue point we saved earlier.
bw.Goto(currentOffset);
}
// Goto offsets section.
bw.Goto(12);
// Write offsets.
bw.WriteU32s(offsets);
// Goto end of file.
bw.Back(0);
// Pad to nearest whole 16.
bw.WritePadding16();
// Return the BIN as a byte array.
return(stream.ToArray());
}
/// <summary>
/// Creates a stream from this TXP.
/// </summary>
/// <returns>The TXP as a stream.</returns>
public Stream Write()
{
// Buffer for new TXP File
Stream stream = new MemoryStream();
// Define a binary writer to write with.
DhBinaryWriter bw = new DhBinaryWriter(stream, DhEndian.Big);
// Write Unknown 1.
bw.WriteU16(Unknown1);
// Write Unknown 2.
bw.WriteU16(Unknown2);
// Write Entry Count.
bw.WriteU16((ushort)Entries.Count);
// Check if Entry Count is greater than 0.
if (Entries.Count > 0)
{
// Write Keyframe Count.
bw.WriteU16((ushort)Entries[0].Indices.Count);
}
else
{
// Write 0.
bw.WriteU16(0);
}
// Write Keyframe Offset.
bw.WriteU32((uint)(12 + (Entries.Count * 12)));
// Loop through entries.
for (int i = 0; i < Entries.Count; i++)
{
// Write entry header.
Entries[i].WriteHeader(bw);
}
// Define a list to hold the offsets for each keyframe offsets.
List <uint> indicesOffsets = new List <uint>();
// Loop through entries.
for (int i = 0; i < Entries.Count; i++)
{
// Save the current offset
indicesOffsets.Add((uint)bw.Position());
// Write entry indices.
Entries[i].WriteIndices(bw);
}
// Loop through entries.
for (int i = 0; i < Entries.Count; i++)
{
// Go to current entry's indices offset value.
bw.Goto(0x0C + (i * 12) + 8);
// Write indices offset.
bw.WriteU32(indicesOffsets[i]);
}
// Return to end of file.
bw.Back(0);
// Write padding to nearest whole 32 bytes.
bw.WritePadding32();
// Return the TXP as a stream
return(stream);
}
/// <summary>
/// Creates a stream from this BTI.
/// </summary>
/// <returns>The BTI as a stream.</returns>
public Stream Write()
{
// Define a stream to hold our BTI data.
Stream stream = new MemoryStream();
// Define a binary writer to write with.
DhBinaryWriter bw = new DhBinaryWriter(stream, DhEndian.Big);
// Write Texture Format.
bw.Write((byte)Format);
// Write Alpha Flag.
bw.Write(AlphaFlag);
// Write Width.
bw.WriteU16(Width);
// Write Height.
bw.WriteU16(Height);
// Write WrapS.
bw.Write((byte)WrapS);
// Write WrapT.
bw.Write((byte)WrapT);
// Write PaletteFormat.
bw.WriteU16((ushort)PaletteFormat);
// Write PaletteCount.
bw.WriteU16(PaletteCount);
// Write PaletteOffset.
bw.WriteU32(PaletteOffset);
// Write Unknown1.
bw.WriteU32(Unknown1);
// Write MagFilterMode.
bw.Write((byte)MagFilterMode);
// Write MinFilterMode.
bw.Write((byte)MinFilterMode);
// Write Min LOD.
bw.WriteU16(MinLOD);
// Write Mag LOD.
bw.Write(MagLOD);
// Write MipMap Count.
bw.Write(MipMapCount);
// Write LodBias.
bw.WriteU16(LodBias);
// Write Data Offset.
bw.WriteU32(DataOffset);
// Write Data.
bw.Write(ToBTI());
// Return the BTI a as stream.
return(stream);
}
