Ejemplo n.º 1
0
        /// <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!");
            }
        }
Ejemplo n.º 2
0
        /// <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());
        }
Ejemplo n.º 3
0
        /// <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);
        }
Ejemplo n.º 4
0
        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);
        }
Ejemplo n.º 5
0
        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);
        }
Ejemplo n.º 6
0
        /// <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());
        }
Ejemplo n.º 7
0
        /// <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
        }
Ejemplo n.º 8
0
        /// <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);
        }
Ejemplo n.º 9
0
 /// <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);
 }
Ejemplo n.º 10
0
 /// <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]);
     }
 }
Ejemplo n.º 11
0
        /// <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);
        }
Ejemplo n.º 12
0
        /// <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);
        }
Ejemplo n.º 13
0
        /// <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);
        }
Ejemplo n.º 14
0
Archivo: MP.cs Proyecto: opeyx/Dolhouse
        /// <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());
        }
Ejemplo n.º 15
0
        /// <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());
        }
Ejemplo n.º 16
0
        /// <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);
        }
Ejemplo n.º 17
0
        /// <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);
        }