/// <summary>
/// Write a single entry to stream.
/// Full credits for the 'packing' snippet goes to arookas:
/// https://github.com/arookas/jmpman/blob/master/jmpman/jmp.cs
/// </summary>
/// <param name="bw">Binary Writer to use.</param>
public void Write(DhBinaryWriter bw, List <JField> fields)
{
long currentPosition = bw.Position();
Dictionary <ushort, uint> buffer = new Dictionary <ushort, uint>(fields.Count);
for (int i = 0; i < fields.Count; i++)
{
bw.Sail(fields[i].Offset);
switch (fields[i].Type)
{
case JFieldType.INTEGER:
int value = Convert.ToInt32(Values.Values.ElementAt(i));
if (fields[i].Bitmask == 0xFFFFFFFF)
{
// not packed, write data directly.
bw.WriteS32((value));
}
else
{
if (!buffer.ContainsKey(fields[i].Offset))
{
buffer[fields[i].Offset] = 0u;
}
// packed, add data to buffer.
buffer[fields[i].Offset] |= ((uint)(value << fields[i].Shift) & fields[i].Bitmask);
}
break;
case JFieldType.STRING:
bw.WriteFixedStr(Convert.ToString(Values.Values.ElementAt(i)), 32);
break;
case JFieldType.FLOAT:
bw.WriteF32(Convert.ToSingle(Values.Values.ElementAt(i)));
break;
default:
throw new InvalidDataException($"{fields[i].Type} is not a valid jmp entry type!");
}
foreach (var data in buffer)
{
bw.Goto(currentPosition + data.Key);
bw.WriteU32(data.Value);
}
bw.Goto(currentPosition);
}
}
/// <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>
/// Write a single entry to stream.
/// Credits for the 'packing' snippet goes to arookas:
/// https://github.com/arookas/jmpman/blob/master/jmpman/jmp.cs
/// </summary>
/// <param name="bw">Binary Writer to use.</param>
public void Write(DhBinaryWriter bw, List <JField> fields)
{
// Save the current position.
long currentPosition = bw.Position();
// Define a buffer to hold packed int values.
Dictionary <ushort, uint> buffer = new Dictionary <ushort, uint>(fields.Count);
// Loop through each value in the entry.
for (int i = 0; i < fields.Count; i++)
{
// Seek from the current position to value's offset in the entry.
bw.Sail(fields[i].Offset);
// Check which type the current value is.
switch (fields[i].Type)
{
case JFieldType.INTEGER:
// Write the value as a integer. TODO: Add pack values.
int value = int.Parse(Values[i].ToString());
// Check if current field has a bitmask.
if (fields[i].Bitmask == 0xFFFFFFFF)
{
// Value is not packed, write data directly.
bw.WriteS32((value));
}
else
{
// Value is packed, data will be added to the buffer.
if (!buffer.ContainsKey(fields[i].Offset))
{
// Since no key exists yet, create one.
buffer[fields[i].Offset] = 0u;
}
// Add the packet int value to the buffer.
buffer[fields[i].Offset] |= ((uint)(value << fields[i].Shift) & fields[i].Bitmask);
}
break;
case JFieldType.STRING:
// Write the value as a string.
bw.WriteStr32(Values[i].ToString());
break;
case JFieldType.FLOAT:
// Write the value as a float32.
bw.WriteF32(float.Parse(Values[i].ToString()));
break;
default:
// Something went horribly wrong.
throw new InvalidDataException();
}
// Write out the packed int's buffer.
foreach (var data in buffer)
{
//
bw.Goto(currentPosition + data.Key);
// Write the packed int value.
bw.WriteU32(data.Value);
}
// Seek back to the position we saved earlier.
bw.Goto(currentPosition);
}
}