internal override void Write(BinaryWriterEx bw, int id) { long start = bw.Position; bw.ReserveVarint("NameOffset"); bw.WriteInt32(EventID); bw.WriteByte((byte)Type); bw.WriteByte(0); bw.WriteInt16((short)id); bw.ReserveVarint("TypeDataOffset"); if (!bw.VarintLong) { bw.WriteInt32(0); bw.WriteInt32(0); } bw.FillVarint("NameOffset", bw.Position - start); bw.WriteUTF16(Name, true); bw.Pad(bw.VarintSize); bw.FillVarint("TypeDataOffset", bw.Position - start); WriteTypeData(bw); }
internal override void Write(BinaryWriterEx bw, int id) { base.Write(bw, id); bw.WriteByte(HitFilterID); bw.WriteByte(SoundSpaceType); bw.WriteInt16(EnvLightMapSpotIndex); bw.WriteSingle(ReflectPlaneHeight); bw.WriteUInt32s(NvmGroups); bw.WriteInt32s(VagrantEntityIDs); bw.WriteInt16(MapNameID); bw.WriteInt16(DisableStart); bw.WriteInt32(DisableBonfireEntityID); bw.WriteInt32(-1); bw.WriteInt32(-1); bw.WriteInt32(-1); bw.WriteInt32(PlayRegionID); bw.WriteInt16(LockCamParamID1); bw.WriteInt16(LockCamParamID2); bw.WriteInt32(0); bw.WriteInt32(0); bw.WriteInt32(0); bw.WriteInt32(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); }
public override void Write(HKX hkx, HKXSection section, BinaryWriterEx bw, uint sectionBaseOffset, HKXVariation variation) { bw.WriteByte(BBX); bw.WriteByte(BBY); bw.WriteByte(BBZ); bw.WriteByte(IDX0); bw.WriteByte(IDX1); bw.WriteByte(IDX2); }
/// <summary> /// Writes TPF data to a BinaryWriterEx. /// </summary> protected override void Write(BinaryWriterEx bw) { bw.BigEndian = Platform == TPFPlatform.Xbox360 || Platform == TPFPlatform.PS3; bw.WriteASCII("TPF\0"); bw.ReserveInt32("DataSize"); bw.WriteInt32(Textures.Count); bw.WriteByte((byte)Platform); bw.WriteByte(Flag2); bw.WriteByte(Encoding); bw.WriteByte(0); for (int i = 0; i < Textures.Count; i++) { Textures[i].WriteHeader(bw, i, Platform, Flag2); } for (int i = 0; i < Textures.Count; i++) { Textures[i].WriteName(bw, i, Encoding); } long dataStart = bw.Position; for (int i = 0; i < Textures.Count; i++) { // Padding for texture data varies wildly across games, // so don't worry about this too much if (Textures[i].Bytes.Length > 0) { bw.Pad(4); } Textures[i].WriteData(bw, i); } bw.FillInt32("DataSize", (int)(bw.Position - dataStart)); }
/// <summary> /// Writes BND3 data to a BinaryWriterEx. /// </summary> internal override void Write(BinaryWriterEx bw) { bw.BigEndian = false; bw.WriteASCII("BND3"); bw.WriteFixStr(Timestamp, 8); bw.WriteByte((byte)Format); bw.WriteBoolean(BigEndian); bw.WriteBoolean(Unk1); bw.WriteByte(0); bw.BigEndian = BigEndian || Binder.ForceBigEndian(Format); bw.WriteInt32(Files.Count); bw.ReserveInt32("HeaderEnd"); bw.WriteInt32(Unk2); bw.WriteInt32(0); for (int i = 0; i < Files.Count; i++) { WriteFileHeader(Files[i], bw, i, Format); } if (Binder.HasName(Format)) { for (int i = 0; i < Files.Count; i++) { WriteFileName(Files[i], bw, i); } } bw.FillInt32($"HeaderEnd", (int)bw.Position); for (int i = 0; i < Files.Count; i++) { WriteFileData(Files[i], bw, i); } }
private protected override void WriteTypeData(BinaryWriterEx bw) { bw.WriteByte(UnkT00); bw.WriteByte(0); bw.WriteInt16(-1); bw.WriteSingle(UnkT04); bw.WriteSingle(UnkT08); bw.WriteRGBA(ColorT0C); bw.WriteRGBA(ColorT10); bw.WriteInt32(0); bw.WriteInt32(0); bw.WriteSingle(UnkT1C); bw.WriteSingle(UnkT20); bw.WriteRGBA(ColorT24); bw.WriteRGBA(ColorT28); bw.WriteInt32(0); bw.WriteInt32(0); bw.WriteRGBA(ColorT34); bw.WriteRGBA(ColorT38); bw.WriteRGBA(ColorT3C); bw.WriteSingle(UnkT40); bw.WriteByte(UnkT44); bw.WritePattern(0x3B, 0x00); }
/// <summary> /// Writes BND3 data to a BinaryWriterEx. /// </summary> internal override void Write(BinaryWriterEx bw) { bw.BigEndian = false; bw.WriteASCII("BND3"); bw.WriteFixStr(Timestamp, 8); bw.WriteByte(Format); bw.WriteBoolean(BigEndian); bw.WriteBoolean(Unk1); bw.WriteByte(0); bw.BigEndian = BigEndian || Format == 0xE0 || Format == 0xF0; bw.WriteInt32(Files.Count); bw.ReserveInt32("HeaderEnd"); bw.WriteInt32(Unk2); bw.WriteInt32(0); for (int i = 0; i < Files.Count; i++) { Files[i].WriteHeader(bw, i, Format); } if (Format != 0x40) { for (int i = 0; i < Files.Count; i++) { Files[i].WriteName(bw, i); } } bw.FillInt32($"HeaderEnd", (int)bw.Position); for (int i = 0; i < Files.Count; i++) { Files[i].WriteData(bw, i, Format); } }
internal void Write(BinaryWriterEx bw) { bw.WriteInt16(SkeletonParamID); bw.WriteByte(Unk2); bw.WriteByte(0); bw.WriteByte(0); bw.WriteByte(0); bw.WriteByte(0); bw.WriteByte(0); }
private protected override void WriteTypeData(BinaryWriterEx bw) { bw.WriteByte(UnkT00); bw.WriteByte(0); bw.WriteByte(0); bw.WriteByte(0); bw.WriteRGBA(ColorT04); bw.WriteSingle(UnkT08); bw.WriteSingle(UnkT0C); bw.WriteSingle(UnkT10); bw.WriteByte(UnkT14); bw.WriteByte(UnkT15); bw.WriteByte(UnkT16); bw.WritePattern(0x11, 0x00); }
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(Convert.ToByte(value)); break; case ParamType.s8: bw.WriteSByte(Convert.ToSByte(value)); break; case ParamType.u16: case ParamType.x16: bw.WriteUInt16(Convert.ToUInt16(value)); break; case ParamType.s16: bw.WriteInt16(Convert.ToInt16(value)); break; case ParamType.u32: case ParamType.x32: bw.WriteUInt32(Convert.ToUInt32(value)); break; case ParamType.s32: bw.WriteInt32(Convert.ToInt32(value)); break; case ParamType.u64: case ParamType.x64: bw.WriteUInt64(Convert.ToUInt64(value)); break; case ParamType.s64: bw.WriteInt64(Convert.ToInt64(value)); break; case ParamType.f32: bw.WriteSingle(Convert.ToSingle(value)); break; case ParamType.f64: bw.WriteDouble(Convert.ToDouble(value)); break; default: throw new Exception($"Invalid ParamTemplate ParamType: {Type.ToString()}"); } }
internal override void WriteSpecific(BinaryWriterEx bw, long start) { bw.FillInt64("TypeDataOffset", bw.Position - start); bw.WriteSingle(UnkT00); bw.WriteSingle(Compare); bw.WriteBoolean(UnkT08); bw.WriteByte(UnkT09); bw.WriteInt16(UnkT0A); bw.WriteInt32(0); bw.WriteInt32(0); bw.WriteInt32(0); bw.WriteInt32(0); bw.WriteInt32(0); bw.WriteInt32(0); bw.WriteInt32(0); bw.WriteInt32(0); }
/// <summary> /// Packs an enumeration of arg values into a byte array for use in an instruction. /// </summary> public void PackArgs(IEnumerable <object> args, bool bigEndian = false) { using (var ms = new MemoryStream()) { var bw = new BinaryWriterEx(bigEndian, ms); foreach (object arg in args) { switch (arg) { case byte ub: bw.WriteByte(ub); break; case ushort us: bw.Pad(2); bw.WriteUInt16(us); break; case uint ui: bw.Pad(4); bw.WriteUInt32(ui); break; case sbyte sb: bw.WriteSByte(sb); break; case short ss: bw.Pad(2); bw.WriteInt16(ss); break; case int si: bw.Pad(4); bw.WriteInt32(si); break; case float f: bw.Pad(4); bw.WriteSingle(f); break; case long sl: bw.Pad(8); bw.WriteInt64(sl); break; default: throw new NotSupportedException($"Unsupported argument type: {arg.GetType()}"); } } ArgData = bw.FinishBytes(); } }
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); }
internal override void WriteSpecific(BinaryWriterEx bw, Dictionary <string, int> stringOffsets) { bw.WriteInt16(DlgIndex); bw.WriteByte(Unk02); bw.WriteByte(Unk03); bw.WriteInt32(PaletteColor); WriteColor(bw, CustomColor); bw.WriteByte((byte)(Unknown == null ? 0 : 1)); bw.WriteByte(0); bw.WriteByte(0); bw.WriteByte(0); }
internal void Write(BinaryWriterEx bw, int index, TPFPlatform platform) { if (platform == TPFPlatform.PC) { DDS dds = new DDS(Bytes); // DDSCAPS2_CUBEMAP Cubemap = (dds.dwCaps2 & 0x200) != 0; Mipmaps = (byte)dds.dwMipMapCount; } bw.ReserveInt32($"FileData{index}"); bw.ReserveInt32($"FileSize{index}"); bw.WriteByte(Format); bw.WriteBoolean(Cubemap); bw.WriteByte(Mipmaps); bw.WriteByte(Flags1); if (platform == TPFPlatform.PC) { bw.ReserveInt32($"FileName{index}"); bw.WriteInt32(Flags2); } else if (platform == TPFPlatform.PS3) { bw.WriteInt16(Header.Width); bw.WriteInt16(Header.Height); bw.WriteInt32(Header.Unk1); bw.WriteInt32(Header.Unk2); bw.ReserveInt32($"FileName{index}"); bw.WriteInt32(Flags2); } else if (platform == TPFPlatform.PS4 || platform == TPFPlatform.Xbone) { bw.WriteInt16(Header.Width); bw.WriteInt16(Header.Height); bw.WriteByte(Header.TextureCount); bw.WriteByte(0); bw.WriteByte(0); bw.WriteByte(0); bw.WriteInt32(Header.Unk2); bw.ReserveInt32($"FileName{index}"); bw.WriteInt32(Flags2); bw.WriteInt32(Header.DXGIFormat); } }
protected internal override void Serialize(BinaryWriterEx bw, List <string> classNames) { bw.WriteInt32(0); bw.WriteInt32(ID); bw.WriteInt32(0); bw.WriteInt32(0); bw.WriteInt32(2); bw.WriteInt16(0); bw.WriteInt16(2); bw.WriteInt32(0); ParamList1.Write(bw, classNames); ParamList2.Write(bw, classNames); StateMap.Write(bw, classNames); ResourceSet.Write(bw, classNames); bw.WriteByte(0); }
public void WriteHeader(BinaryWriterEx bw, HKX.HKXVariation variation) { bw.WriteFixStr(SectionTag, 19); bw.WriteByte(0xFF); bw.ReserveUInt32("absoffset" + SectionID); bw.ReserveUInt32("locoffset" + SectionID); bw.ReserveUInt32("globoffset" + SectionID); bw.ReserveUInt32("virtoffset" + SectionID); bw.ReserveUInt32("expoffset" + SectionID); bw.ReserveUInt32("impoffset" + SectionID); bw.ReserveUInt32("endoffset" + SectionID); if (variation == HKX.HKXVariation.HKXBloodBorne || variation == HKX.HKXVariation.HKXDS3) { bw.WriteUInt32(0xFFFFFFFF); bw.WriteUInt32(0xFFFFFFFF); bw.WriteUInt32(0xFFFFFFFF); bw.WriteUInt32(0xFFFFFFFF); } }
internal override void Write(BinaryWriterEx bw) { bw.BigEndian = false; bw.WriteInt32(2); bw.WriteInt32(Unk04); bw.WriteInt32(Lights.Count); bw.ReserveInt32("NameSize"); bw.WriteInt32(0); bw.WriteInt32(0xC8); bw.WriteInt32(0); bw.WriteInt32(0); bw.WriteInt32(0); bw.WriteInt32(0); bw.WriteInt32(0); bw.WriteInt32(0); bw.WriteInt32(0); bw.WriteInt32(0); bw.WriteInt32(0); long nameStart = bw.Position; var nameOffsets = new List <int>(Lights.Count); foreach (Light entry in Lights) { int nameOffset = (int)(bw.Position - nameStart); nameOffsets.Add(nameOffset); bw.WriteUTF16(entry.Name, true); if (nameOffset % 0x10 != 0) { for (int i = 0; i < 0x10 - (nameOffset % 0x10); i++) { bw.WriteByte(0); } } } bw.FillInt32("NameSize", (int)(bw.Position - nameStart)); for (int i = 0; i < Lights.Count; i++) { Lights[i].Write(bw, nameOffsets[i]); } }
public override void Write(HKX hkx, HKXSection section, BinaryWriterEx bw, uint sectionBaseOffset, HKXVariation variation) { SectionOffset = (uint)bw.Position - sectionBaseOffset; foreach (var elem in Elements) { elem.Write(hkx, section, bw, sectionBaseOffset, variation); } while ((bw.Position % 16) != 0) { // Write padding bytes to 16 byte align bw.WriteByte(0xFF); } // Go through and recursively write reference data for all the array members foreach (var elem in Elements) { elem.WriteReferenceData(hkx, section, bw, sectionBaseOffset, variation); } DataSize = (uint)bw.Position - SectionOffset; }
internal void WriteAssertValue(BinaryWriterEx bw) { switch (Type) { case ParamType.aob: var assertAob = (byte[])ValueToAssert; bw.WriteBytes(assertAob); break; case ParamType.b: bw.WriteBoolean((bool)ValueToAssert); break; case ParamType.u8: case ParamType.x8: bw.WriteByte((byte)ValueToAssert); break; case ParamType.s8: bw.WriteSByte((sbyte)ValueToAssert); break; case ParamType.u16: case ParamType.x16: bw.WriteUInt16((ushort)ValueToAssert); break; case ParamType.s16: bw.WriteInt16((short)ValueToAssert); break; case ParamType.u32: case ParamType.x32: bw.WriteUInt32((uint)ValueToAssert); break; case ParamType.s32: bw.WriteInt32((int)ValueToAssert); break; case ParamType.u64: case ParamType.x64: bw.WriteUInt64((ulong)ValueToAssert); break; case ParamType.s64: bw.WriteInt64((long)ValueToAssert); break; case ParamType.f32: bw.WriteSingle((float)ValueToAssert); break; case ParamType.f64: bw.WriteDouble((double)ValueToAssert); break; default: throw new Exception($"Invalid ParamTemplate ParamType: {Type.ToString()}"); } }
internal override void Write(BinaryWriterEx bw, int id) { long start = bw.Position; bw.ReserveVarint("NameOffset"); bw.WriteByte((byte)Type); bw.WriteByte(0); bw.WriteInt16((short)id); bw.WriteInt16(ModelIndex); bw.WriteInt16(0); bw.WriteVector3(Position); bw.WriteVector3(Rotation); bw.WriteVector3(Scale); bw.WriteUInt32s(DrawGroups); bw.WriteInt32(Unk44); bw.WriteInt32(Unk48); bw.WriteInt32(Unk4C); bw.WriteInt32(Unk50); bw.WriteUInt32s(DispGroups); bw.WriteInt32(Unk64); bw.WriteInt32(0); bw.WriteByte(Unk6C); bw.WriteByte(0); bw.WriteByte(Unk6E); bw.WriteByte(0); bw.ReserveVarint("TypeDataOffset"); if (bw.VarintLong) { bw.WriteInt64(0); } long nameStart = bw.Position; int namePad = bw.VarintLong ? 0x20 : 0x2C; bw.FillVarint("NameOffset", nameStart - start); bw.WriteUTF16(MSB.ReambiguateName(Name), true); if (bw.Position - nameStart < namePad) { bw.Position += namePad - (bw.Position - nameStart); } bw.Pad(bw.VarintSize); bw.FillVarint("TypeDataOffset", bw.Position - start); WriteTypeData(bw); }
/// <summary> /// Serializes file data to a stream. /// </summary> protected override void Write(BinaryWriterEx bw) { bw.BigEndian = false; bw.WriteUInt32((uint)Version); bw.BigEndian = Version == CCMVer.DemonsSouls; bw.ReserveInt32("FileSize"); bw.WriteInt16(FullWidth); bw.WriteInt16(TexWidth); bw.WriteInt16(TexHeight); if (Version == CCMVer.DemonsSouls || Version == CCMVer.DarkSouls1) { bw.WriteInt16(Unk0E); bw.ReserveInt16("CodeGroupCount"); bw.WriteInt16((short)Glyphs.Count); } else if (Version == CCMVer.DarkSouls2) { bw.ReserveInt16("TexRegionCount"); bw.WriteInt16((short)Glyphs.Count); bw.WriteInt16(0); } bw.WriteInt32(0x20); bw.ReserveInt32("GlyphOffset"); bw.WriteByte(Unk1C); bw.WriteByte(Unk1D); bw.WriteByte(TexCount); bw.WriteByte(0); var codes = new List <int>(Glyphs.Keys); codes.Sort(); if (Version == CCMVer.DemonsSouls || Version == CCMVer.DarkSouls1) { var codeGroups = new List <CodeGroup>(); for (int i = 0; i < Glyphs.Count;) { int startCode = codes[i]; int glyphIndex = i; for (i++; i < Glyphs.Count && codes[i] == codes[i - 1] + 1; i++) { ; } int endCode = codes[i - 1]; codeGroups.Add(new CodeGroup(startCode, endCode, glyphIndex)); } bw.FillInt16("CodeGroupCount", (short)codeGroups.Count); foreach (CodeGroup group in codeGroups) { group.Write(bw); } bw.FillInt32("GlyphOffset", (int)bw.Position); foreach (int code in codes) { Glyph glyph = Glyphs[code]; bw.WriteVector2(glyph.UV1); bw.WriteVector2(glyph.UV2); bw.WriteInt16(glyph.PreSpace); bw.WriteInt16(glyph.Width); bw.WriteInt16(glyph.Advance); bw.WriteInt16(glyph.TexIndex); } } else if (Version == CCMVer.DarkSouls2) { var texRegionsByCode = new Dictionary <int, TexRegion>(Glyphs.Count); var texRegions = new HashSet <TexRegion>(); foreach (int code in codes) { Glyph glyph = Glyphs[code]; short x1 = (short)Math.Round(glyph.UV1.X * TexWidth); short y1 = (short)Math.Round(glyph.UV1.Y * TexHeight); short x2 = (short)Math.Round(glyph.UV2.X * TexWidth); short y2 = (short)Math.Round(glyph.UV2.Y * TexHeight); var region = new TexRegion(x1, y1, x2, y2); texRegionsByCode[code] = region; texRegions.Add(region); } bw.FillInt16("TexRegionCount", (short)texRegions.Count); var texRegionOffsets = new Dictionary <TexRegion, int>(texRegions.Count); foreach (TexRegion region in texRegions) { texRegionOffsets[region] = (int)bw.Position; region.Write(bw); } bw.FillInt32("GlyphOffset", (int)bw.Position); foreach (int code in codes) { Glyph glyph = Glyphs[code]; bw.WriteInt32(code); bw.WriteInt32(texRegionOffsets[texRegionsByCode[code]]); bw.WriteInt16(glyph.TexIndex); bw.WriteInt16(glyph.PreSpace); bw.WriteInt16(glyph.Width); bw.WriteInt16(glyph.Advance); bw.WriteInt32(0); bw.WriteInt32(0); } } bw.FillInt32("FileSize", (int)bw.Position); }
internal void WriteCells(BinaryWriterEx bw, int i, Layout layout) { bw.FillInt64($"RowOffset{i}", bw.Position); for (int j = 0; j < layout.Count; j++) { Cell cell = Cells[j]; Layout.Entry entry = layout[j]; CellType type = entry.Type; object value = cell.Value; if (entry.Name != cell.Name || type != cell.Type) { throw new FormatException("Layout does not match cells."); } if (type == CellType.s8) { bw.WriteSByte((sbyte)value); } else if (type == CellType.u8 || type == CellType.x8) { bw.WriteByte((byte)value); } else if (type == CellType.s16) { bw.WriteInt16((short)value); } else if (type == CellType.u16 || type == CellType.x16) { bw.WriteUInt16((ushort)value); } else if (type == CellType.s32) { bw.WriteInt32((int)value); } else if (type == CellType.u32 || type == CellType.x32) { bw.WriteUInt32((uint)value); } else if (type == CellType.f32) { bw.WriteSingle((float)value); } else if (type == CellType.dummy8) { bw.WriteBytes((byte[])value); } else if (type == CellType.fixstr) { bw.WriteFixStr((string)value, entry.Size); } else if (type == CellType.fixstrW) { bw.WriteFixStrW((string)value, entry.Size); } else if (type == CellType.b8) { byte b = 0; int k; for (k = 0; k < 8; k++) { if (j + k >= layout.Count || layout[j + k].Type != CellType.b8) { break; } if ((bool)Cells[j + k].Value) { b |= (byte)(1 << k); } } j += k - 1; bw.WriteByte(b); } else if (type == CellType.b32) { byte[] b = new byte[4]; int k; for (k = 0; k < 32; k++) { if (j + k >= layout.Count || layout[j + k].Type != CellType.b32) { break; } if ((bool)Cells[j + k].Value) { b[k / 8] |= (byte)(1 << (k % 8)); } } j += k - 1; bw.WriteBytes(b); } } }
private void WriteEntityData(BinaryWriterEx bw) { bw.WriteInt32(EntityID); bw.WriteByte(LightID); bw.WriteByte(FogID); bw.WriteByte(ScatterID); bw.WriteByte(LensFlareID); bw.WriteByte(ShadowID); bw.WriteByte(DofID); bw.WriteByte(ToneMapID); bw.WriteByte(ToneCorrectID); bw.WriteByte(LanternID); bw.WriteByte(LodParamID); bw.WriteByte(UnkE0E); bw.WriteByte(IsShadowSrc); bw.WriteByte(IsShadowDest); bw.WriteByte(IsShadowOnly); bw.WriteByte(DrawByReflectCam); bw.WriteByte(DrawOnlyReflectCam); bw.WriteByte(UseDepthBiasFloat); bw.WriteByte(DisablePointLightEffect); bw.WriteByte(0); bw.WriteByte(0); }
internal override void Write(BinaryWriterEx bw) { if (layout == null) { throw new InvalidOperationException("Params cannot be written without a layout."); } Rows.Sort((r1, r2) => r1.ID.CompareTo(r2.ID)); bw.BigEndian = false; bw.ReserveInt32("NameOffset"); bw.WriteInt16(0); bw.WriteInt16(Unk1); bw.WriteInt16(Unk2); bw.WriteUInt16((ushort)Rows.Count); if (FixStrID) { bw.WriteFixStr(ID, 0x20); } else { bw.WriteInt32(0); bw.ReserveInt32("IDOffset"); bw.WriteInt32(0); bw.WriteInt32(0); bw.WriteInt32(0); bw.WriteInt32(0); bw.WriteInt32(0); bw.WriteInt32(0); } bw.WriteByte(0); bw.WriteByte(Unk3); bw.WriteByte(Unk4); bw.WriteByte(0); bw.ReserveInt64("DataStart"); bw.WriteInt32(0); bw.WriteInt32(0); for (int i = 0; i < Rows.Count; i++) { Rows[i].WriteHeader(bw, i); } bw.FillInt64("DataStart", bw.Position); for (int i = 0; i < Rows.Count; i++) { Rows[i].WriteCells(bw, i, layout); } bw.FillInt32("NameOffset", (int)bw.Position); if (FixStrID) { if (Unk4 == 6) { bw.WriteShiftJIS(Name, true); } else if (Unk4 == 7) { bw.WriteUTF16(Name, true); } } else { bw.WriteShiftJIS(Name, true); bw.FillInt32("IDOffset", (int)bw.Position); bw.WriteASCII(ID, true); } for (int i = 0; i < Rows.Count; i++) { Rows[i].WriteName(bw, i, Unk4); } }
internal void Write(BinaryWriterEx bw, long nameOffset, int version, bool longOffsets) { bw.WriteInt32(Unk00); bw.WriteInt32(Unk04); bw.WriteInt32(Unk08); bw.WriteInt32(Unk0C); if (longOffsets) { bw.WriteInt64(nameOffset); } else { bw.WriteInt32((int)nameOffset); } bw.WriteUInt32((uint)Type); bw.WriteBoolean(Unk1C); bw.WriteByte(DiffuseColor.R); bw.WriteByte(DiffuseColor.G); bw.WriteByte(DiffuseColor.B); bw.WriteSingle(DiffusePower); bw.WriteByte(SpecularColor.R); bw.WriteByte(SpecularColor.G); bw.WriteByte(SpecularColor.B); bw.WriteBoolean(CastShadows); bw.WriteSingle(SpecularPower); 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.WriteBytes(Unk64); bw.WriteSingle(Unk68); bw.WriteByte(ShadowColor.R); bw.WriteByte(ShadowColor.G); bw.WriteByte(ShadowColor.B); bw.WriteByte(ShadowColor.A); bw.WriteSingle(Unk70); bw.WriteSingle(FlickerIntervalMin); bw.WriteSingle(FlickerIntervalMax); bw.WriteSingle(FlickerBrightnessMult); bw.WriteInt32(Unk80); bw.WriteBytes(Unk84); bw.WriteSingle(Unk88); bw.WriteInt32(0); bw.WriteSingle(Unk90); bw.WriteInt32(0); bw.WriteSingle(Unk98); bw.WriteSingle(Unk9C); bw.WriteBytes(UnkA0); bw.WriteSingle(Sharpness); bw.WriteInt32(0); bw.WriteSingle(UnkAC); if (longOffsets) { bw.WriteInt64(0); } else { bw.WriteInt32(0); } bw.WriteSingle(Width); bw.WriteSingle(UnkBC); bw.WriteBytes(UnkC0); bw.WriteSingle(UnkC4); if (version >= 16) { bw.WriteSingle(UnkC8); bw.WriteSingle(UnkCC); bw.WriteSingle(UnkD0); bw.WriteSingle(UnkD4); bw.WriteSingle(UnkD8); bw.WriteInt32(UnkDC); bw.WriteSingle(UnkE0); bw.WriteInt32(0); } }
internal void Write(BinaryWriterEx bw) { long start = bw.Position; bw.ReserveInt64("NameOffset"); bw.WriteUInt32((uint)Type); bw.WriteInt32(ID); bw.WriteInt32(modelIndex); bw.WriteInt32(0); bw.ReserveInt64("PlaceholderOffset"); bw.WriteVector3(Position); bw.WriteVector3(Rotation); bw.WriteVector3(Scale); bw.WriteUInt32(DrawGroup1); bw.WriteUInt32(DrawGroup2); bw.WriteUInt32(DrawGroup3); bw.WriteUInt32(DrawGroup4); bw.WriteUInt32(DispGroup1); bw.WriteUInt32(DispGroup2); bw.WriteUInt32(DispGroup3); bw.WriteUInt32(DispGroup4); bw.WriteInt32(UnkF01); bw.WriteInt32(UnkF02); bw.WriteInt32(UnkF03); bw.WriteInt32(UnkF04); bw.WriteInt32(UnkF05); bw.WriteInt32(UnkF06); bw.WriteInt32(UnkF07); bw.WriteInt32(UnkF08); bw.WriteInt32(UnkF09); bw.WriteInt32(UnkF10); bw.WriteInt32(UnkF11); bw.WriteInt32(UnkF12); bw.WriteInt32(UnkF13); bw.WriteInt32(UnkF14); bw.WriteInt32(UnkF15); bw.WriteInt32(UnkF16); bw.WriteInt32(UnkF17); bw.WriteInt32(UnkF18); bw.WriteInt32(0); bw.ReserveInt64("BaseDataOffset"); bw.ReserveInt64("TypeDataOffset"); bw.ReserveInt64("UnkOffset1"); bw.ReserveInt64("UnkOffset2"); bw.FillInt64("NameOffset", bw.Position - start); bw.WriteUTF16(Name, true); if (Placeholder == null) { bw.FillInt64("PlaceholderOffset", 0); } else { bw.FillInt64("PlaceholderOffset", bw.Position - start); bw.WriteUTF16(Placeholder, true); } bw.Pad(8); bw.FillInt64("BaseDataOffset", bw.Position - start); bw.WriteInt32(EventEntityID); bw.WriteSByte(LightID); bw.WriteSByte(FogID); bw.WriteSByte(ScatterID); bw.WriteSByte(LensFlareID); bw.WriteInt32(0); bw.WriteSByte(LanternID); bw.WriteSByte(LodParamID); bw.WriteSByte(UnkB0E); bw.WriteBoolean(IsShadowDest); bw.WriteBoolean(IsShadowOnly); bw.WriteBoolean(DrawByReflectCam); bw.WriteBoolean(DrawOnlyReflectCam); bw.WriteBoolean(UseDepthBiasFloat); bw.WriteBoolean(DisablePointLightEffect); bw.WriteByte(UnkB15); bw.WriteByte(UnkB16); bw.WriteByte(UnkB17); bw.WriteInt32(UnkB18); bw.WriteInt32(UnkB1C); bw.WriteInt32(UnkB20); bw.WriteInt32(UnkB24); bw.WriteInt32(UnkB28); bw.WriteInt32(-1); bw.WriteInt32(UnkB30); bw.WriteInt32(UnkB34); bw.WriteInt32(UnkB38); bw.WriteInt32(0); bw.FillInt64("TypeDataOffset", bw.Position - start); if (UnkOffset1Delta == 0) { bw.FillInt64("UnkOffset1", 0); } else { bw.FillInt64("UnkOffset1", bw.Position - start + UnkOffset1Delta); } if (UnkOffset2Delta == 0) { bw.FillInt64("UnkOffset2", 0); } else { bw.FillInt64("UnkOffset2", bw.Position - start + UnkOffset2Delta); } WriteSpecific(bw); }
internal override void Write(BinaryWriterEx bw) { if (layout == null) { throw new InvalidOperationException("Params cannot be written without a layout."); } Rows.Sort((r1, r2) => r1.ID.CompareTo(r2.ID)); bw.BigEndian = BigEndian; void WriteFormat() { bw.WriteByte((byte)(BigEndian ? 0xFF : 0x00)); bw.WriteByte(Format2D); bw.WriteByte(Format2E); bw.WriteByte(Format2F); } // DeS, DS1 if ((Format2D & 0x7F) < 3) { bw.ReserveUInt32("StringsOffset"); bw.ReserveUInt16("DataStart"); bw.WriteInt16(Unk06); bw.WriteInt16(Unk08); bw.WriteUInt16((ushort)Rows.Count); bw.WriteFixStr(ID, 0x20, 0x20); WriteFormat(); } // DS2 else if ((Format2D & 0x7F) == 3) { bw.ReserveUInt32("StringsOffset"); bw.WriteInt16(0); bw.WriteInt16(Unk06); bw.WriteInt16(Unk08); bw.WriteUInt16((ushort)Rows.Count); bw.WriteFixStr(ID, 0x20, 0x20); WriteFormat(); bw.ReserveUInt32("DataStart"); bw.WriteInt32(0); bw.WriteInt32(0); bw.WriteInt32(0); } // SotFS, BB else if ((Format2D & 0x7F) == 4) { bw.ReserveUInt32("StringsOffset"); bw.WriteInt16(0); bw.WriteInt16(Unk06); bw.WriteInt16(Unk08); bw.WriteUInt16((ushort)Rows.Count); bw.WriteFixStr(ID, 0x20, 0x00); WriteFormat(); bw.ReserveInt64("DataStart"); bw.WriteInt64(0); } // DS3, SDT else { bw.ReserveUInt32("StringsOffset"); bw.WriteInt16(0); bw.WriteInt16(Unk06); bw.WriteInt16(Unk08); bw.WriteUInt16((ushort)Rows.Count); bw.WriteInt32(0); bw.ReserveInt64("IDOffset"); bw.WritePattern(0x14, 0x00); WriteFormat(); bw.ReserveInt64("DataStart"); bw.WriteInt64(0); } for (int i = 0; i < Rows.Count; i++) { Rows[i].WriteHeader(bw, Format2D, i); } if ((Format2D & 0x7F) < 3) { bw.FillUInt16("DataStart", (ushort)bw.Position); } else if ((Format2D & 0x7F) == 3) { bw.FillUInt32("DataStart", (uint)bw.Position); } else { bw.FillInt64("DataStart", bw.Position); } for (int i = 0; i < Rows.Count; i++) { Rows[i].WriteCells(bw, Format2D, i, layout); } bw.FillUInt32("StringsOffset", (uint)bw.Position); if ((Format2D & 0x7F) > 4) { bw.FillInt64("IDOffset", bw.Position); bw.WriteASCII(ID, true); } for (int i = 0; i < Rows.Count; i++) { Rows[i].WriteName(bw, Format2D, i); } }
internal void WriteDefaultValue(BinaryWriterEx bw) { if (ValueToAssert != null) { WriteAssertValue(bw); } else if (DefaultValue == null) { switch (Type) { case ParamType.aob: for (int i = 0; i < AobLength; i++) { bw.WriteByte(0); } break; case ParamType.b: case ParamType.u8: case ParamType.x8: bw.WriteByte(0); break; case ParamType.s8: bw.WriteSByte(0); break; case ParamType.u16: case ParamType.x16: bw.WriteUInt16(0); break; case ParamType.s16: bw.WriteInt16(0); break; case ParamType.u32: case ParamType.x32: bw.WriteUInt32(0); break; case ParamType.s32: bw.WriteInt32(0); break; case ParamType.u64: case ParamType.x64: bw.WriteUInt64(0); break; case ParamType.s64: bw.WriteInt64(0); break; case ParamType.f32: bw.WriteSingle(0); break; case ParamType.f64: bw.WriteDouble(0); break; default: throw new Exception($"Invalid ParamTemplate ParamType: {Type.ToString()}"); } } else { switch (Type) { case ParamType.aob: var assertAob = (byte[])DefaultValue; bw.WriteBytes(assertAob); break; case ParamType.b: case ParamType.u8: case ParamType.x8: bw.WriteByte((byte)DefaultValue); break; case ParamType.s8: bw.WriteSByte((sbyte)DefaultValue); break; case ParamType.u16: case ParamType.x16: bw.WriteUInt16((ushort)DefaultValue); break; case ParamType.s16: bw.WriteInt16((short)DefaultValue); break; case ParamType.u32: case ParamType.x32: bw.WriteUInt32((uint)DefaultValue); break; case ParamType.s32: bw.WriteInt32((int)DefaultValue); break; case ParamType.u64: case ParamType.x64: bw.WriteUInt64((ulong)DefaultValue); break; case ParamType.s64: bw.WriteInt64((long)DefaultValue); break; case ParamType.f32: bw.WriteSingle((float)DefaultValue); break; case ParamType.f64: bw.WriteDouble((double)DefaultValue); break; default: throw new Exception($"Invalid ParamTemplate ParamType: {Type.ToString()}"); } } }