Ejemplo n.º 1
0
                internal override void WriteSpecific(BinaryWriterEx bw)
                {
                    bw.WriteInt32(0);
                    bw.WriteInt32(0);
                    bw.WriteInt32(partIndex2);
                    bw.WriteInt32(0);
                    bw.WriteInt32(ItemLot1);
                    bw.WriteInt32(ItemLot2);
                    bw.WriteInt32(-1);
                    bw.WriteInt32(-1);
                    bw.WriteInt32(-1);
                    bw.WriteInt32(-1);
                    bw.WriteInt32(-1);
                    bw.WriteInt32(-1);
                    bw.WriteInt32(-1);
                    bw.WriteInt32(-1);
                    bw.WriteInt32(-1);

                    bw.WriteBoolean(IsChest);
                    bw.WriteBoolean(IsYoelUnknown);
                    bw.WriteByte(0);
                    bw.WriteByte(0);

                    bw.WriteInt32(0);
                    bw.WriteInt32(0);
                }
Ejemplo n.º 2
0
        internal static void WriteHeader(IBND3 bnd, BinaryWriterEx bw, List <BinderFileHeader> fileHeaders)
        {
            bw.BigEndian = bnd.BigEndian || Binder.ForceBigEndian(bnd.Format);

            bw.WriteASCII("BND3");
            bw.WriteFixStr(bnd.Version, 8);

            Binder.WriteFormat(bw, bnd.BigEndian, bnd.Format);
            bw.WriteBoolean(bnd.BigEndian);
            bw.WriteBoolean(bnd.BitBigEndian);
            bw.WriteByte(0);

            bw.WriteInt32(fileHeaders.Count);
            bw.ReserveInt32("FileHeadersEnd");
            bw.WriteInt32(bnd.Unk18);
            bw.WriteInt32(0);

            for (int i = 0; i < fileHeaders.Count; i++)
            {
                fileHeaders[i].WriteBinder3FileHeader(bw, bnd.Format, bnd.BitBigEndian, i);
            }

            for (int i = 0; i < fileHeaders.Count; i++)
            {
                fileHeaders[i].WriteFileName(bw, bnd.Format, false, i);
            }

            bw.FillInt32($"FileHeadersEnd", (int)bw.Position);
        }
Ejemplo n.º 3
0
                internal override void WriteSpecific(BinaryWriterEx bw)
                {
                    bw.WriteInt32(0);
                    bw.WriteInt32(0);
                    bw.WriteInt32(partIndex2);
                    bw.WriteInt32(0);
                    bw.WriteInt32(ItemLot1);
                    bw.WriteInt32(ItemLot2);
                    bw.WriteInt32(-1);
                    bw.WriteInt32(-1);
                    bw.WriteInt32(-1);
                    bw.WriteInt32(-1);
                    bw.WriteInt32(-1);
                    bw.WriteInt32(-1);
                    bw.WriteInt32(-1);
                    bw.WriteInt32(-1);
                    bw.WriteInt32(ActionButtonParamID);
                    bw.WriteInt32(PickupAnimID);

                    bw.WriteBoolean(InChest);
                    bw.WriteBoolean(StartDisabled);
                    bw.WriteByte(0);
                    bw.WriteByte(0);

                    bw.WriteInt32(0);
                    bw.WriteInt32(0);
                    bw.WriteInt32(0);
                }
Ejemplo n.º 4
0
                private protected override void WriteTypeData(BinaryWriterEx bw)
                {
                    bw.WriteInt32(0);
                    bw.WriteInt32(0);
                    bw.WriteInt32(TreasurePartIndex);
                    bw.WriteInt32(0);
                    bw.WriteInt32(ItemLot1);
                    bw.WriteInt32(ItemLot2);
                    bw.WriteInt32(UnkT18);
                    bw.WriteInt32(-1);
                    bw.WriteInt32(-1);
                    bw.WriteInt32(-1);
                    bw.WriteInt32(-1);
                    bw.WriteInt32(-1);
                    bw.WriteInt32(-1);
                    bw.WriteInt32(-1);
                    bw.WriteInt32(ActionButtonParamID);
                    bw.WriteInt32(PickupAnimID);

                    bw.WriteBoolean(InChest);
                    bw.WriteBoolean(StartDisabled);
                    bw.WriteByte(0);
                    bw.WriteByte(0);

                    bw.WriteInt32(0);
                    bw.WriteInt32(0);
                    bw.WriteInt32(0);
                }
Ejemplo n.º 5
0
            internal void WriteValues(BinaryWriterEx bw, int groupIndex, int paramIndex, int valuesOffset)
            {
                bw.FillInt32($"ValuesOffset{groupIndex}:{paramIndex}", (int)bw.Position - valuesOffset);
                for (int i = 0; i < Values.Count; i++)
                {
                    object value = Values[i];
                    switch (Type)
                    {
                    case ParamType.Byte:
                        bw.WriteInt32((byte)value);
                        break;

                    case ParamType.Short:
                        bw.WriteInt16((short)value);
                        break;

                    case ParamType.IntA:
                        bw.WriteInt32((int)value);
                        break;

                    case ParamType.BoolA:
                        bw.WriteBoolean((bool)value);
                        break;

                    case ParamType.IntB:
                        bw.WriteInt32((int)value);
                        break;

                    case ParamType.Float:
                        bw.WriteSingle((float)value);
                        break;

                    case ParamType.BoolB:
                        bw.WriteBoolean((bool)value);
                        break;

                    case ParamType.Float2:
                        bw.WriteVector2((Vector2)value);
                        bw.WriteInt32(0);
                        bw.WriteInt32(0);
                        break;

                    case ParamType.Float3:
                        bw.WriteVector3((Vector3)value);
                        bw.WriteInt32(0);
                        break;

                    case ParamType.Float4:
                        bw.WriteVector4((Vector4)value);
                        break;

                    case ParamType.Byte4:
                        bw.WriteBytes((byte[])value);
                        break;
                    }
                }
                bw.Pad(4);
            }
Ejemplo n.º 6
0
            internal void Write(BinaryWriterEx bw, int nameOffset)
            {
                bw.WriteInt32(Unk00);
                bw.WriteInt32(Unk04);
                bw.WriteInt32(Unk08);
                bw.WriteInt32(Unk0C);
                bw.WriteInt32(nameOffset);
                bw.WriteInt32(0);
                bw.WriteInt32(Unk18);

                bw.WriteBoolean(Unk1C);
                bw.WriteByte(DiffuseColor.R);
                bw.WriteByte(DiffuseColor.G);
                bw.WriteByte(DiffuseColor.B);
                bw.WriteSingle(DiffuseBrightness);

                bw.WriteByte(SpecularColor.R);
                bw.WriteByte(SpecularColor.G);
                bw.WriteByte(SpecularColor.B);
                bw.WriteBoolean(Unk27);
                bw.WriteSingle(SpecularBrightness);

                bw.WriteSingle(ConeAngle);
                bw.WriteSingle(Unk30);
                bw.WriteSingle(Unk34);
                bw.WriteVector3(Position);
                bw.WriteVector3(Rotation);
                bw.WriteInt32(Unk50);
                bw.WriteSingle(Unk54);
                bw.WriteSingle(Radius);
                bw.WriteInt32(Unk5C);
                bw.WriteInt32(0);
                bw.WriteInt32(Unk64);
                bw.WriteSingle(Unk68);
                bw.WriteSingle(Unk6C);
                bw.WriteSingle(Unk70);
                bw.WriteSingle(Unk74);
                bw.WriteSingle(Unk78);
                bw.WriteSingle(Unk7C);
                bw.WriteInt32(-1);
                bw.WriteInt32(0);
                bw.WriteInt32(0);
                bw.WriteInt32(0);
                bw.WriteInt32(0);
                bw.WriteInt32(0);
                bw.WriteSingle(Unk98);
                bw.WriteSingle(Unk9C);
                bw.WriteInt32(UnkA0);
                bw.WriteSingle(Unk74);
                bw.WriteInt32(0);
                bw.WriteInt32(0);
                bw.WriteInt32(0);
                bw.WriteInt32(0);
                bw.WriteSingle(Width);
                bw.WriteInt32(0);
                bw.WriteInt32(0);
                bw.WriteSingle(UnkC4);
            }
Ejemplo n.º 7
0
            internal void WriteValues(BinaryWriterEx bw, int groupIndex, int paramIndex, int valuesOffset)
            {
                bw.FillInt32($"ValuesOffset{groupIndex}:{paramIndex}", (int)bw.Position - valuesOffset);
                for (int i = 0; i < Values.Count; i++)
                {
                    object value = Values[i];
                    switch (Type)
                    {
                    case ParamType.Unk1:
                        bw.WriteInt32((int)value);
                        break;

                    case ParamType.Unk2:
                        bw.WriteInt16((short)value);
                        break;

                    case ParamType.Unk3:
                        bw.WriteInt32((int)value);
                        break;

                    case ParamType.Unk5:
                        bw.WriteBoolean((bool)value);
                        break;

                    case ParamType.Unk7:
                        bw.WriteInt32((int)value);
                        break;

                    case ParamType.Unk9:
                        bw.WriteSingle((float)value);
                        break;

                    case ParamType.UnkB:
                        bw.WriteBoolean((bool)value);
                        break;

                    case ParamType.UnkC:
                        bw.WriteVector2((Vector2)value);
                        bw.WriteInt32(0);
                        bw.WriteInt32(0);
                        break;

                    case ParamType.UnkD:
                        bw.WriteVector4((Vector4)value);
                        break;

                    case ParamType.UnkE:
                        bw.WriteVector4((Vector4)value);
                        break;

                    case ParamType.UnkF:
                        bw.WriteInt32((int)value);
                        break;
                    }
                }
                bw.Pad(4);
            }
Ejemplo n.º 8
0
                internal override void WriteSpecific(BinaryWriterEx bw, long start)
                {
                    bw.FillInt64("UnkOffset", bw.Position - start);

                    bw.WriteByte(UnkT00);
                    bw.WriteByte(UnkT01);
                    bw.WriteBoolean(UnkT02);
                    bw.WriteBoolean(UnkT03);
                }
Ejemplo n.º 9
0
 internal static void WriteHeader(BinaryWriterEx bw)
 {
     bw.WriteASCII("MSB ");
     bw.WriteInt32(1);
     bw.WriteInt32(0x10);
     bw.WriteBoolean(false);
     bw.WriteBoolean(false);
     bw.WriteByte(1);
     bw.WriteByte(0xFF);
 }
Ejemplo n.º 10
0
                internal override void WriteTypeData(BinaryWriterEx bw)
                {
                    bw.WriteByte(UnkT00);
                    bw.WriteByte(UnkT01);
                    bw.WriteBoolean(UnkT02);
                    bw.WriteBoolean(UnkT03);

                    bw.WriteInt32(0);
                    bw.WriteInt32(0);
                    bw.WriteInt32(0);
                }
Ejemplo n.º 11
0
        internal override void Write(BinaryWriterEx bw)
        {
            Entries entries;

            entries.Models = Models.GetEntries();
            List <Event> events = Events.GetEntries();

            entries.Regions = Regions.GetEntries();
            List <Route> routes = Routes.GetEntries();

            entries.Parts = Parts.GetEntries();

            foreach (Model model in entries.Models)
            {
                model.CountInstances(entries.Parts);
            }
            foreach (Event evt in events)
            {
                evt.GetIndices(entries);
            }
            foreach (Region region in entries.Regions)
            {
                region.GetIndices(entries);
            }
            foreach (Part part in entries.Parts)
            {
                part.GetIndices(this, entries);
            }

            bw.WriteASCII("MSB ");
            bw.WriteInt32(1);
            bw.WriteInt32(0x10);
            bw.WriteBoolean(false);
            bw.WriteBoolean(false);
            bw.WriteByte(1);
            bw.WriteByte(0xFF);

            Models.Write(bw, entries.Models);
            bw.FillInt64("NextParamOffset", bw.Position);
            Events.Write(bw, events);
            bw.FillInt64("NextParamOffset", bw.Position);
            Regions.Write(bw, entries.Regions);
            bw.FillInt64("NextParamOffset", bw.Position);
            Routes.Write(bw, routes);
            bw.FillInt64("NextParamOffset", bw.Position);
            Layers.Write(bw, Layers.GetEntries());
            bw.FillInt64("NextParamOffset", bw.Position);
            Parts.Write(bw, entries.Parts);
            bw.FillInt64("NextParamOffset", bw.Position);
            PartsPoses.Write(bw, Layers.GetEntries());
            bw.FillInt64("NextParamOffset", bw.Position);
            BoneNames.Write(bw, Layers.GetEntries());
            bw.FillInt64("NextParamOffset", 0);
        }
Ejemplo n.º 12
0
                private protected override void WriteTypeData(BinaryWriterEx bw)
                {
                    bw.WriteByte(UnkT00);
                    bw.WriteByte(UnkT01);
                    bw.WriteBoolean(UnkT02);
                    bw.WriteBoolean(UnkT03);

                    bw.WriteInt32(0);
                    bw.WriteInt32(0);
                    bw.WriteInt32(0);
                }
Ejemplo n.º 13
0
        internal override void Write(BinaryWriterEx bw)
        {
            Entries entries;

            entries.Models    = Models.GetEntries();
            entries.Events    = Events.GetEntries();
            entries.Regions   = Regions.GetEntries();
            entries.Parts     = Parts.GetEntries();
            entries.BoneNames = new List <BoneName>();

            Lookups lookups;

            lookups.Models     = MakeNameLookup(entries.Models);
            lookups.Parts      = MakeNameLookup(entries.Parts);
            lookups.Collisions = MakeNameLookup(Parts.Collisions);
            lookups.BoneNames  = new Dictionary <string, int>();

            Models.DiscriminateModels();
            foreach (Part part in entries.Parts)
            {
                part.GetIndices(lookups);
            }
            foreach (PartPose pose in PartPoses)
            {
                pose.GetIndices(lookups, entries);
            }

            bw.BigEndian = false;
            bw.WriteASCII("MSB ");
            bw.WriteInt32(1);
            bw.WriteInt32(0x10);
            bw.WriteBoolean(false);
            bw.WriteBoolean(false);
            bw.WriteByte(1);
            bw.WriteByte(0xFF);

            Models.Write(bw, entries.Models);
            bw.FillInt64("NextParamOffset", bw.Position);
            Events.Write(bw, entries.Events);
            bw.FillInt64("NextParamOffset", bw.Position);
            Regions.Write(bw, entries.Regions);
            bw.FillInt64("NextParamOffset", bw.Position);
            new RouteParam().Write(bw, new List <Entry>());
            bw.FillInt64("NextParamOffset", bw.Position);
            new LayerParam().Write(bw, new List <Entry>());
            bw.FillInt64("NextParamOffset", bw.Position);
            Parts.Write(bw, entries.Parts);
            bw.FillInt64("NextParamOffset", bw.Position);
            new MapstudioPartsPose().Write(bw, PartPoses);
            bw.FillInt64("NextParamOffset", bw.Position);
            new MapstudioBoneName().Write(bw, entries.BoneNames);
            bw.FillInt64("NextParamOffset", 0);
        }
Ejemplo n.º 14
0
        internal static void WriteHeader(IBND4 bnd, BinaryWriterEx bw, List <BinderFileHeader> fileHeaders)
        {
            bw.BigEndian = bnd.BigEndian;

            bw.WriteASCII("BND4");

            bw.WriteBoolean(bnd.Unk04);
            bw.WriteBoolean(bnd.Unk05);
            bw.WriteByte(0);
            bw.WriteByte(0);

            bw.WriteByte(0);
            bw.WriteBoolean(bnd.BigEndian);
            bw.WriteBoolean(!bnd.BitBigEndian);
            bw.WriteByte(0);

            bw.WriteInt32(fileHeaders.Count);
            bw.WriteInt64(0x40);
            bw.WriteFixStr(bnd.Version, 8);
            bw.WriteInt64(Binder.GetBND4FileHeaderSize(bnd.Format));
            bw.ReserveInt64("HeadersEnd");

            bw.WriteBoolean(bnd.Unicode);
            Binder.WriteFormat(bw, bnd.BitBigEndian, bnd.Format);
            bw.WriteByte(bnd.Extended);
            bw.WriteByte(0);

            bw.WriteInt32(0);
            bw.ReserveInt64("HashTableOffset");

            for (int i = 0; i < fileHeaders.Count; i++)
            {
                fileHeaders[i].WriteBinder4FileHeader(bw, bnd.Format, bnd.BitBigEndian, i);
            }

            for (int i = 0; i < fileHeaders.Count; i++)
            {
                fileHeaders[i].WriteFileName(bw, bnd.Format, bnd.Unicode, i);
            }

            if (bnd.Extended == 4)
            {
                bw.Pad(0x8);
                bw.FillInt64("HashTableOffset", bw.Position);
                BinderHashTable.Write(bw, fileHeaders);
            }
            else
            {
                bw.FillInt64("HashTableOffset", 0);
            }

            bw.FillInt64("HeadersEnd", bw.Position);
        }
Ejemplo n.º 15
0
 private protected override void WriteTypeData(BinaryWriterEx bw)
 {
     bw.WriteInt32(0);
     bw.WriteInt32(TreasurePartIndex);
     for (int i = 0; i < 5; i++)
     {
         bw.WriteInt32(ItemLots[i]);
         bw.WriteInt32(-1);
     }
     bw.WriteBoolean(InChest);
     bw.WriteBoolean(StartDisabled);
     bw.WriteInt16(0);
 }
Ejemplo n.º 16
0
 internal override void Write(BinaryWriterEx bw, int id)
 {
     base.Write(bw, id);
     bw.WriteInt32(0);
     bw.WriteInt32(TreasurePartIndex);
     for (int i = 0; i < 5; i++)
     {
         bw.WriteInt32(ItemLots[i]);
         bw.WriteInt32(-1);
     }
     bw.WriteBoolean(InChest);
     bw.WriteBoolean(StartDisabled);
     bw.WriteInt16(0);
 }
Ejemplo n.º 17
0
 internal override void WriteTypeData(BinaryWriterEx bw)
 {
     bw.WriteBoolean(UnkT00);
     bw.WriteBoolean(UnkT01);
     bw.WriteBoolean(UnkT02);
     bw.WriteByte(0);
     bw.WriteSingle(UnkT04);
     bw.WriteSingle(UnkT08);
     bw.WriteSingle(UnkT0C);
     bw.WriteSingle(UnkT10);
     bw.WriteSingle(UnkT14);
     bw.WriteSingle(UnkT18);
     bw.WriteInt32(0);
 }
Ejemplo n.º 18
0
        protected override void Write(BinaryWriterEx bw)
        {
            bw.BigEndian = false;

            Entries entries;

            entries.Models  = Models.GetEntries();
            entries.Events  = Events.GetEntries();
            entries.Regions = Regions.GetEntries();
            entries.Parts   = Parts.GetEntries();

            foreach (Model model in entries.Models)
            {
                model.CountInstances(entries.Parts);
            }
            foreach (Event evt in entries.Events)
            {
                evt.GetIndices(this, entries);
            }
            foreach (Region region in entries.Regions)
            {
                region.GetIndices(this, entries);
            }
            foreach (Part part in entries.Parts)
            {
                part.GetIndices(this, entries);
            }

            bw.WriteASCII("MSB ");
            bw.WriteInt32(1);
            bw.WriteInt32(0x10);

            bw.WriteBoolean(false);
            bw.WriteBoolean(false);
            bw.WriteByte(1);
            bw.WriteByte(0xFF);

            Models.Write(bw, entries.Models);
            bw.FillInt64("NextParamOffset", bw.Position);

            Events.Write(bw, entries.Events);
            bw.FillInt64("NextParamOffset", bw.Position);

            Regions.Write(bw, entries.Regions);
            bw.FillInt64("NextParamOffset", bw.Position);

            Parts.Write(bw, entries.Parts);
            bw.FillInt64("NextParamOffset", 0);
        }
Ejemplo n.º 19
0
 internal void Write(BinaryWriterEx bw)
 {
     bw.BigEndian = BigEndian;
     bw.WriteASCII("BDF4");
     bw.WriteBoolean(Flag1);
     bw.WriteBoolean(Flag2);
     bw.WriteByte(0);
     bw.WriteByte(0);
     bw.WriteInt32(0x10000);
     bw.WriteInt32(0);
     bw.WriteInt64(Unk1);
     bw.WriteASCII(Timestamp.PadRight(8, '\0'));
     bw.WriteInt64(0);
     bw.WriteInt64(0);
 }
Ejemplo n.º 20
0
 internal void Write(BinaryWriterEx bw)
 {
     bw.BigEndian = BigEndian;
     bw.WriteASCII("BDF4");
     bw.WriteBoolean(Flag1);
     bw.WriteBoolean(Flag2);
     bw.WriteByte(0);
     bw.WriteByte(0);
     bw.WriteInt32(0x10000);
     bw.WriteInt32(0);
     bw.WriteInt64(Unk1);
     bw.WriteFixStr(Timestamp, 8);
     bw.WriteInt64(0);
     bw.WriteInt64(0);
 }
Ejemplo n.º 21
0
                internal void WriteValue(BinaryWriterEx bw, object value)
                {
                    switch (Type)
                    {
                    case ParamType.aob: bw.WriteBytes((byte[])value); break;

                    case ParamType.b: bw.WriteBoolean((bool)value); break;

                    case ParamType.u8:
                    case ParamType.x8: bw.WriteByte((byte)value); break;

                    case ParamType.s8: bw.WriteSByte((sbyte)value); break;

                    case ParamType.u16:
                    case ParamType.x16: bw.WriteUInt16((ushort)value); break;

                    case ParamType.s16: bw.WriteInt16((short)value); break;

                    case ParamType.u32:
                    case ParamType.x32: bw.WriteUInt32((uint)value); break;

                    case ParamType.s32: bw.WriteInt32((int)value); break;

                    case ParamType.u64:
                    case ParamType.x64: bw.WriteUInt64((ulong)value); break;

                    case ParamType.s64: bw.WriteInt64((long)value); break;

                    case ParamType.f32: bw.WriteSingle((float)value); break;

                    case ParamType.f64: bw.WriteDouble((double)value); break;

                    default: throw new Exception($"Invalid ParamTemplate ParamType: {Type.ToString()}");
                    }
                }
Ejemplo n.º 22
0
                internal override void WriteSpecific(BinaryWriterEx bw, Dictionary <string, int> stringOffsets)
                {
                    bw.WriteByte((byte)BlendMode);
                    bw.WriteBoolean(Unknown != null);
                    bw.WriteInt16(LineSpacing);
                    bw.WriteInt32(PaletteColor);
                    WriteColor(bw, CustomColor);
                    bw.WriteInt16(FontSize);
                    bw.WriteByte((byte)Alignment);
                    bw.WriteByte((byte)TextType);
                    bw.WriteInt32(0x1C);

                    if (TextType == TxtType.Literal)
                    {
                        bw.WriteInt32(stringOffsets[TextLiteral]);
                    }
                    else if (TextType == TxtType.FMG)
                    {
                        bw.WriteInt32(CharLength);
                        bw.WriteInt32(TextID);
                    }
                    else if (TextType == TxtType.Dynamic)
                    {
                        bw.WriteInt32(CharLength);
                    }

                    WriteSubtype(bw);

                    Unknown?.Write(bw);
                }
Ejemplo n.º 23
0
            internal void Write(BinaryWriterEx bw, FLVERHeader header, int indexSize, int index)
            {
                bw.WriteUInt32((uint)Flags);
                bw.WriteBoolean(TriangleStrip);
                bw.WriteBoolean(CullBackfaces);
                bw.WriteInt16(Unk06);
                bw.WriteInt32(Indices.Count);
                bw.ReserveInt32($"FaceSetVertices{index}");

                if (header.Version > 0x20005)
                {
                    bw.WriteInt32(Indices.Count * (indexSize / 8));
                    bw.WriteInt32(0);
                    bw.WriteInt32(header.Version >= 0x20013 ? indexSize : 0);
                    bw.WriteInt32(0);
                }
            }
Ejemplo n.º 24
0
 internal override void WriteTypeData(BinaryWriterEx bw)
 {
     bw.WriteInt32(0);
     bw.WriteInt32(0);
     bw.WriteInt32(TreasurePartIndex);
     bw.WriteInt32(0);
     bw.WriteInt32(ItemLotID);
     bw.WriteNull(0x24, true);
     bw.WriteInt32(ActionButtonID);
     bw.WriteInt32(PickupAnimID);
     bw.WriteBoolean(InChest);
     bw.WriteBoolean(StartDisabled);
     bw.WriteInt16(0);
     bw.WriteInt32(0);
     bw.WriteInt32(0);
     bw.WriteInt32(0);
 }
Ejemplo n.º 25
0
 private protected override void WriteTypeData(BinaryWriterEx bw)
 {
     bw.WriteInt16(MessageID);
     bw.WriteInt16(UnkT02);
     bw.WriteBoolean(Hidden);
     bw.WriteByte(0);
     bw.WriteInt16(0);
 }
Ejemplo n.º 26
0
 internal static void WriteBDFHeader(IBXF4 bxf, BinaryWriterEx bw)
 {
     bw.BigEndian = bxf.BigEndian;
     bw.WriteASCII("BDF4");
     bw.WriteBoolean(bxf.Unk04);
     bw.WriteBoolean(bxf.Unk05);
     bw.WriteByte(0);
     bw.WriteByte(0);
     bw.WriteByte(0);
     bw.WriteBoolean(bxf.BigEndian);
     bw.WriteBoolean(!bxf.BitBigEndian);
     bw.WriteByte(0);
     bw.WriteInt32(0);
     bw.WriteInt64(0x30);
     bw.WriteFixStr(bxf.Version, 8);
     bw.WriteInt64(0);
     bw.WriteInt64(0);
 }
Ejemplo n.º 27
0
 internal override void Write(BinaryWriterEx bw, int id)
 {
     base.Write(bw, id);
     bw.WriteInt16(MessageID);
     bw.WriteInt16(UnkT02);
     bw.WriteBoolean(Hidden);
     bw.WriteByte(0);
     bw.WriteInt16(0);
 }
Ejemplo n.º 28
0
        internal override void Write(BinaryWriterEx bw)
        {
            bool bigEndian = Format == EMEVD.Game.DarkSouls1BE;
            bool is64Bit   = Format >= EMEVD.Game.Bloodborne;

            bw.WriteASCII("ELD\0");
            bw.WriteBoolean(bigEndian);
            bw.WriteSByte((sbyte)(is64Bit ? -1 : 0));
            bw.WriteByte(0);
            bw.WriteByte(0);
            bw.BigEndian  = bigEndian;
            bw.VarintLong = is64Bit;

            bw.WriteInt16(0x65);
            bw.WriteInt16(0xCC);
            bw.ReserveInt32("FileSize");

            bw.WriteVarint(Events.Count);
            bw.ReserveVarint("EventsOffset");
            bw.WriteVarint(0);
            bw.ReserveVarint("Offset2");
            bw.WriteVarint(0);
            bw.ReserveVarint("Offset3");
            bw.ReserveVarint("StringsLength");
            bw.ReserveVarint("StringsOffset");
            if (!is64Bit)
            {
                bw.WriteInt32(0);
                bw.WriteInt32(0);
            }

            bw.FillVarint("EventsOffset", bw.Position);
            for (int i = 0; i < Events.Count; i++)
            {
                Events[i].Write(bw, Format, i);
            }

            bw.FillVarint("Offset2", bw.Position);
            bw.FillVarint("Offset3", bw.Position);

            long stringsOffset = bw.Position;

            bw.FillVarint("StringsOffset", bw.Position);
            for (int i = 0; i < Events.Count; i++)
            {
                Events[i].WriteName(bw, i, stringsOffset);
            }
            if ((bw.Position - stringsOffset) % 0x10 > 0)
            {
                bw.WritePattern(0x10 - (int)(bw.Position - stringsOffset) % 0x10, 0x00);
            }
            bw.FillVarint("StringsLength", bw.Position - stringsOffset);

            bw.FillInt32("FileSize", (int)bw.Position);
        }
 internal void Write(BinaryWriterEx bw, bool longFormat, int index)
 {
     bw.WriteInt32(ID);
     if (longFormat)
     {
         bw.WriteBoolean(BattleInterrupt);
         bw.WriteBoolean(LogicInterrupt);
         bw.WriteInt16(0);
         bw.ReserveInt64($"NameOffset{index}");
         bw.ReserveInt64($"LogicInterruptNameOffset{index}");
     }
     else
     {
         bw.ReserveUInt32($"NameOffset{index}");
         bw.ReserveUInt32($"LogicInterruptNameOffset{index}");
         bw.WriteBoolean(BattleInterrupt);
         bw.WriteBoolean(LogicInterrupt);
         bw.WriteInt16(0);
     }
 }
Ejemplo n.º 30
0
 internal void Write(BinaryWriterEx bw, FLVERHeader header)
 {
     bw.WriteVector3(Position);
     if (header.Version == 0x20010)
     {
         bw.WriteBGRA(Color);
     }
     else
     {
         bw.WriteARGB(Color);
     }
     bw.WriteVector3(Forward);
     bw.WriteInt16(ReferenceID);
     bw.WriteInt16(DummyBoneIndex);
     bw.WriteVector3(Upward);
     bw.WriteInt16(AttachBoneIndex);
     bw.WriteBoolean(Flag1);
     bw.WriteBoolean(UseUpwardVector);
     bw.WriteInt32(Unk30);
     bw.WriteInt32(Unk34);
     bw.WriteInt32(0);
     bw.WriteInt32(0);
 }