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()}");
}
}
}
