public override void SerializeImpl(SerializerObject s)
{
switch (TileCompression)
{
case Compression.RLE1:
s.DoEncoded(new RHR_RLETileEncoder(RHR_RLETileEncoder.RLEMode.RLE1), () => {
TileIndices = s.SerializeArray <ushort>(TileIndices, 64, name: nameof(TileIndices));
});
break;
case Compression.RLE2:
s.DoEncoded(new RHR_RLETileEncoder(RHR_RLETileEncoder.RLEMode.RLE2), () => {
TileIndices = s.SerializeArray <ushort>(TileIndices, 64, name: nameof(TileIndices));
});
break;
case Compression.BlockDiff:
BaseMapEntry = s.Serialize <ushort>(BaseMapEntry, name: nameof(BaseMapEntry));
Padding = s.Serialize <ushort>(Padding, name: nameof(Padding));
s.DoEncoded(new RHREncoder(RHREncoder.EncoderMode.TileData), () => {
TileIndices = s.SerializeArray <ushort>(TileIndices, 64, name: nameof(TileIndices));
});
break;
case Compression.Block:
s.DoEncoded(new RHREncoder(RHREncoder.EncoderMode.TileData), () => {
TileIndices = s.SerializeArray <ushort>(TileIndices, 64, name: nameof(TileIndices));
});
break;
}
}
public override void SerializeImpl(SerializerObject s)
{
if (s.GameSettings.GBA_IsMilan)
{
FrameCount = s.Serialize <ushort>((ushort)FrameCount, name: nameof(FrameCount));
Milan_Ushort_02 = s.Serialize <ushort>(Milan_Ushort_02, name: nameof(Milan_Ushort_02));
Milan_Bytes_04 = s.SerializeArray <byte>(Milan_Bytes_04, 8, name: nameof(Milan_Bytes_04));
}
else
{
FrameCount = s.Serialize <uint>(FrameCount, name: nameof(FrameCount));
}
var baseOffset = s.CurrentPointer;
FrameOffsets = s.SerializeArray <uint>(FrameOffsets, FrameCount, name: nameof(FrameOffsets));
if (Frames == null)
{
Frames = new GBA_BatmanVengeance_AnimationFrame[FrameCount];
}
for (int i = 0; i < FrameOffsets.Length; i++)
{
Frames[i] = s.DoAt(baseOffset + FrameOffsets[i], () => s.SerializeObject <GBA_BatmanVengeance_AnimationFrame>(Frames[i], onPreSerialize: f => f.Puppet = Puppet, name: $"{nameof(Frames)}[{i}]"));
}
}
/// <summary>
/// Handles the data serialization
/// </summary>
/// <param name="s">The serializer object</param>
public override void SerializeImpl(SerializerObject s)
{
Unk1 = s.Serialize <uint>(Unk1, name: nameof(Unk1));
var unk2Length = 27;
// The PS1 version hard-codes a different length for this version
if (s.GameSettings.EngineVersion == EngineVersion.R1_PS1_Edu && s.GameSettings.EduVolume.StartsWith("CS"))
{
unk2Length = 29;
}
Unk2 = s.SerializeArray <byte>(Unk2, unk2Length, name: nameof(Unk2));
Unk3 = s.SerializeArray <byte>(Unk3, 3130, name: nameof(Unk3));
SampleNames = s.SerializeStringArray(SampleNames, 7, 9, name: nameof(SampleNames));
VignetteItemsCount = s.Serialize <byte>(VignetteItemsCount, name: nameof(VignetteItemsCount));
Unk5 = s.Serialize <uint>(Unk5, name: nameof(Unk5));
Unk6 = s.Serialize <uint>(Unk6, name: nameof(Unk6));
VignetteItems = s.SerializeObjectArray <R1_PCEdu_GeneralFileVignetteItem>(VignetteItems, VignetteItemsCount, name: nameof(VignetteItems));
CreditsStringItemsCount = s.Serialize <uint>(CreditsStringItemsCount, name: nameof(CreditsStringItemsCount));
CreditsStringItems = s.SerializeObjectArray <R1_PC_GeneralFileStringItem>(CreditsStringItems, CreditsStringItemsCount, name: nameof(CreditsStringItems));
}
public override void SerializeImpl(SerializerObject s)
{
Unk1 = s.Serialize <ushort>(Unk1, name: nameof(Unk1));
Unk2 = s.Serialize <ushort>(Unk2, name: nameof(Unk2));
Unk3 = s.Serialize <ushort>(Unk3, name: nameof(Unk3));
ObjectsCount = s.Serialize <uint>(ObjectsCount, name: nameof(ObjectsCount));
OffsetsCount = s.Serialize <uint>(OffsetsCount, name: nameof(OffsetsCount));
UShort_0E = s.Serialize <ushort>(UShort_0E, name: nameof(UShort_0E));
Offsets = s.SerializeArray <uint>(Offsets, OffsetsCount, name: nameof(Offset));
UnusedOffsets = s.SerializeArray <uint>(UnusedOffsets, 4 - OffsetsCount, name: nameof(UnusedOffsets));
ObjectsOffset = s.Serialize <uint>(ObjectsOffset, name: nameof(ObjectsOffset));
UnkData0 = s.SerializeArray <byte>(UnkData0, 24, name: nameof(UnkData0));
ObjectsEndOffset = s.Serialize <uint>(ObjectsEndOffset, name: nameof(ObjectsEndOffset));
UnkData1 = s.SerializeArray <byte>(UnkData1, 76 - 24 - 4, name: nameof(UnkData1));
if (UnkDataBlocks == null)
{
UnkDataBlocks = new byte[OffsetsCount][];
}
for (int i = 0; i < OffsetsCount; i++)
{
UnkDataBlocks[i] = s.SerializeArray <byte>(UnkDataBlocks[i], 64, name: $"{nameof(UnkDataBlocks)}[{i}]");
}
Objects = s.SerializeObjectArray <GBARRR_Object>(Objects, ObjectsCount, name: nameof(Objects));
s.Serialize <uint>(0, "Padding");
}
public override void SerializeBlock(SerializerObject s)
{
if (s.GameSettings.EngineVersion == EngineVersion.GBA_BatmanVengeance)
{
Byte_03 = s.Serialize <byte>(Byte_03, name: nameof(Byte_03));
IsCompressed = s.Serialize <bool>(IsCompressed, name: nameof(IsCompressed));
TileMapLength = s.Serialize <ushort>(TileMapLength, name: nameof(TileMapLength));
}
else
{
TileMapLength = s.Serialize <ushort>(TileMapLength, name: nameof(TileMapLength));
IsCompressed = s.Serialize <bool>(IsCompressed, name: nameof(IsCompressed));
Byte_03 = s.Serialize <byte>(Byte_03, name: nameof(Byte_03));
}
if (IsDataCompressed ?? IsCompressed)
{
s.DoEncoded(new GBA_LZSSEncoder(), () => TileMap = s.SerializeArray <byte>(TileMap, TileMapLength * 32, name: nameof(TileMap)));
s.Align();
}
else
{
TileMap = s.SerializeArray <byte>(TileMap, TileMapLength * 32, name: nameof(TileMap));
}
}
public override void SerializeImpl(SerializerObject s)
{
MapLayersPointers = s.SerializePointerArray(MapLayersPointers, 4, name: nameof(MapLayersPointers));
CollisionDataPointer = s.SerializePointer(CollisionDataPointer, name: nameof(CollisionDataPointer));
LayersBlockPointer = s.SerializePointer(LayersBlockPointer, name: nameof(LayersBlockPointer));
HasDataBlockHeader = s.Serialize <bool>(HasDataBlockHeader, name: nameof(HasDataBlockHeader));
s.SerializeArray <byte>(new byte[3], 3, name: "Padding");
ObjDataPointer = s.SerializePointer(ObjDataPointer, name: nameof(ObjDataPointer));
ObjDataUnkTablePointer = s.SerializePointer(ObjDataUnkTablePointer, name: nameof(ObjDataUnkTablePointer));
s.SerializeArray <byte>(new byte[12], 12, name: "Padding"); // Always 0, but still part of the same struct
if (MapLayers == null)
{
MapLayers = new GBAVV_Map2D_MapLayer[MapLayersPointers.Length];
}
for (int i = 0; i < MapLayers.Length; i++)
{
MapLayers[i] = s.DoAt(MapLayersPointers[i], () => s.SerializeObject <GBAVV_Map2D_MapLayer>(MapLayers[i], name: $"{nameof(MapLayers)}[{i}]"));
}
CollisionLayer = s.DoAt(CollisionDataPointer, () => s.SerializeObject <GBAVV_Map2D_MapLayer>(CollisionLayer, name: nameof(CollisionLayer)));
LayersBlock = s.DoAt(LayersBlockPointer, () => s.SerializeObject <GBAVV_Map2D_LayersBlock>(LayersBlock, x =>
{
x.HasHeader = HasDataBlockHeader;
x.MapData = this;
}, name: nameof(LayersBlock)));
ObjData = s.DoAt(ObjDataPointer, () => s.SerializeObject <GBAVV_Map2D_ObjData>(ObjData, name: nameof(ObjData)));
ObjDataUnkTable = s.DoAt(ObjDataUnkTablePointer, () => s.SerializeObject <GBAVV_Map2D_ObjDataUnkTable>(ObjDataUnkTable, name: nameof(ObjDataUnkTable)));
}
/// <summary>
/// Handles the data serialization
/// </summary>
/// <param name="s">The serializer object</param>
public override void SerializeImpl(SerializerObject s)
{
var isEncryptedAndChecksum = s.GameSettings.EngineVersion != EngineVersion.R1_PS1_Edu;
LevelDefineChecksum = s.DoChecksum(new Checksum8Calculator(false), () =>
{
s.DoXOR((byte)(isEncryptedAndChecksum ? 0x57 : 0), () =>
{
LevelDefine_0 = s.SerializeArray <byte>(LevelDefine_0, 6, name: nameof(LevelDefine_0));
MusicTrack = s.Serialize <byte>(MusicTrack, name: nameof(MusicTrack));
BG_0 = s.Serialize <byte>(BG_0, name: nameof(BG_0));
BG_1 = s.Serialize <byte>(BG_1, name: nameof(BG_1));
BG_2 = s.Serialize <byte>(BG_2, name: nameof(BG_2));
LevelDefine_1 = s.SerializeArray <byte>(LevelDefine_1, 3, name: nameof(LevelDefine_1));
RayEvts = s.Serialize <R1_RayEvtsFlags>(RayEvts, name: nameof(RayEvts));
UnkByte = s.Serialize <byte>(UnkByte, name: nameof(UnkByte));
});
}, ChecksumPlacement.Before, calculateChecksum: isEncryptedAndChecksum, name: nameof(LevelDefineChecksum));
BackgroundDefineNormalChecksum = s.DoChecksum(new Checksum8Calculator(false), () =>
{
s.DoXOR((byte)(isEncryptedAndChecksum ? 0xA5 : 0), () => BackgroundDefineNormal = s.SerializeObjectArray <R1_BackgroundLayerPosition>(BackgroundDefineNormal, 6, name: nameof(BackgroundDefineNormal)));
}, ChecksumPlacement.Before, calculateChecksum: isEncryptedAndChecksum, name: nameof(BackgroundDefineNormalChecksum));
BackgroundDefineDiffChecksum = s.DoChecksum(new Checksum8Calculator(false), () =>
{
s.DoXOR((byte)(isEncryptedAndChecksum ? 0xA5 : 0), () => BackgroundDefineDiff = s.SerializeObjectArray <R1_BackgroundLayerPosition>(BackgroundDefineDiff, 6, name: nameof(BackgroundDefineDiff)));
}, ChecksumPlacement.Before, calculateChecksum: isEncryptedAndChecksum, name: nameof(BackgroundDefineDiffChecksum));
}
public void SerializeVignette(SerializerObject s, bool isImgDataCompressed)
{
// Serialize data from pointers
s.DoAt(ImageDataPointer, () => {
if (s.Context.Settings.GameModeSelection == GameModeSelection.RaymanDSi)
{
if (isImgDataCompressed)
{
s.DoEncoded(new GBA_LZSSEncoder(), () => ImageData = s.SerializeArray <byte>(ImageData, 0x40 * Width * Height, name: nameof(ImageData)));
}
else
{
ImageData = s.SerializeArray <byte>(ImageData, 0x40 * Width * Height, name: nameof(ImageData));
}
}
else
{
ImageData = s.SerializeArray <byte>(ImageData, 0x20 * Width * Height, name: nameof(ImageData));
}
});
s.DoAt(BlockIndicesPointer, () => BlockIndices = s.SerializeArray <ushort>(BlockIndices, Width * Height, name: nameof(BlockIndices)));
s.DoAt(PaletteIndicesPointer, () => PaletteIndices = s.SerializeArray <byte>(PaletteIndices, Width * Height, name: nameof(PaletteIndices)));
s.DoAt(PalettesPointer, () => {
Palettes = s.SerializeObjectArray <ARGB1555Color>(Palettes,
(s.Context.Settings.GameModeSelection == GameModeSelection.RaymanDSi) ? 256 : (PaletteCount * 16),
name: nameof(Palettes));
});
}
public override void SerializeImpl(SerializerObject s)
{
// Serialize alpha data (only on EDU)
if (s.GameSettings.EngineVersion == EngineVersion.R1_PC_Edu || s.GameSettings.EngineVersion == EngineVersion.R1_PS1_Edu)
{
if (EDU_Alpha == null)
{
EDU_Alpha = new byte[160][];
}
for (int i = 0; i < EDU_Alpha.Length; i++)
{
EDU_Alpha[i] = s.SerializeArray <byte>(EDU_Alpha[i], 256, name: $"{nameof(EDU_Alpha)}[{i}]");
}
}
LevelsCount = s.Serialize <ushort>(LevelsCount, name: nameof(LevelsCount));
Unk2 = s.Serialize <byte>(Unk2, name: nameof(Unk2));
Unk3 = s.Serialize <byte>(Unk3, name: nameof(Unk3));
WorldMapVig = s.SerializeString(WorldMapVig, 9, name: nameof(WorldMapVig));
LevelSelectVig = s.SerializeString(LevelSelectVig, 9, name: nameof(LevelSelectVig));
Unk4 = s.SerializeArray <byte>(Unk4, 7, name: nameof(Unk4));
Unk5 = s.Serialize <byte>(Unk5, name: nameof(Unk5));
Unk6 = s.Serialize <ushort>(Unk6, name: nameof(Unk6));
Levels = s.SerializeObjectArray <R1_WorldMapInfo>(Levels, 32, name: nameof(Levels));
Unk8 = s.Serialize <uint>(Unk8, name: nameof(Unk8));
Unk9 = s.SerializeArray <byte>(Unk9, 17, name: nameof(Unk9));
UnkStrings = s.SerializeStringArray(UnkStrings, 319, 9, name: nameof(UnkStrings));
UnkLevelStructs = s.SerializeObjectArray <R1_PC_WorldMapLevelUnkStruct>(UnkLevelStructs, LevelsCount, name: nameof(UnkLevelStructs));
}
public override void SerializeBlock(SerializerObject s)
{
s.SerializeBitValues <byte>(bitFunc => {
IsObjAnimation = bitFunc(IsObjAnimation ? 1 : 0, 1, name: nameof(IsObjAnimation)) == 1;
Batman_Byte00 = (byte)bitFunc(Batman_Byte00, 7, name: nameof(Batman_Byte00));
});
Index_Palette = s.Serialize <byte>(Index_Palette, name: nameof(Index_Palette));
AnimationsCount = s.Serialize <byte>(AnimationsCount, name: nameof(AnimationsCount));
Index_TileSet = s.Serialize <byte>(Index_TileSet, name: nameof(Index_TileSet));
if (s.GameSettings.EngineVersion < EngineVersion.GBA_BatmanVengeance)
{
TilemapWidth = s.Serialize <byte>(TilemapWidth, name: nameof(TilemapWidth));
TilemapHeight = s.Serialize <byte>(TilemapHeight, name: nameof(TilemapHeight));
Padding = s.SerializeArray <byte>(Padding, 2, name: nameof(Padding));
}
var animOffsetsBase = s.CurrentPointer;
AnimationOffsets = s.SerializeArray <uint>(AnimationOffsets, AnimationsCount, name: nameof(AnimationOffsets));
if (Animations == null)
{
Animations = new GBA_BatmanVengeance_Animation[AnimationOffsets.Length];
}
BlockEndPointer = Offset + BlockSize;
for (int i = 0; i < AnimationOffsets.Length; i++)
{
Animations[i] = s.DoAt(animOffsetsBase + AnimationOffsets[i], () => s.SerializeObject <GBA_BatmanVengeance_Animation>(Animations[i], onPreSerialize: a => a.Puppet = this, name: $"{nameof(Animations)}[{i}]"));
}
s.Goto(Offset + BlockSize);
}
/// <summary>
/// Handles the data serialization
/// </summary>
/// <param name="s">The serializer object</param>
public override void SerializeImpl(SerializerObject s)
{
ColorIndexes = s.SerializeArray <byte>(ColorIndexes, Settings.CellSize * Settings.CellSize, name: nameof(ColorIndexes));
Alpha = s.SerializeArray <byte>(Alpha, Settings.CellSize * Settings.CellSize, name: nameof(Alpha));
TransparencyMode = s.Serialize <uint>(TransparencyMode, name: nameof(TransparencyMode));
Unknown1 = s.SerializeArray <byte>(Unknown1, 28, name: nameof(Unknown1));
}
public override void SerializeBlock(SerializerObject s)
{
if (s.GameSettings.GBA_IsMilan)
{
Milan_ActorID = s.SerializeString(Milan_ActorID, length: 4, name: nameof(Milan_ActorID));
s.SerializeArray <byte>(new byte[8], 8, name: "Padding");
}
else
{
if (s.GameSettings.EngineVersion > EngineVersion.GBA_BatmanVengeance)
{
UnkData = s.SerializeArray <byte>(UnkData, 8, name: nameof(UnkData));
}
Index_Puppet = s.Serialize <byte>(Index_Puppet, name: nameof(Index_Puppet));
Byte_09 = s.Serialize <byte>(Byte_09, name: nameof(Byte_09));
Byte_0A = s.Serialize <byte>(Byte_0A, name: nameof(Byte_0A));
Byte_0B = s.Serialize <byte>(Byte_0B, name: nameof(Byte_0B));
if (s.GameSettings.EngineVersion == EngineVersion.GBA_BatmanVengeance)
{
Actions = s.SerializeObjectArray <GBA_Action>(Actions, (BlockSize - 4) / 12, name: nameof(Actions));
}
else
{
Actions = s.SerializeObjectArray <GBA_Action>(Actions, (BlockSize - 12) / 8, name: nameof(Actions));
}
}
}
public override void SerializeBlock(SerializerObject s)
{
if (s.GameSettings.EngineVersion <= EngineVersion.GBA_BatmanVengeance)
{
Is8Bit = s.Serialize <bool>(Is8Bit, name: nameof(Is8Bit));
IsCompressed = s.Serialize <bool>(IsCompressed, name: nameof(IsCompressed));
TileSetLength = s.Serialize <ushort>(TileSetLength, name: nameof(TileSetLength));
}
else
{
TileSetLength = s.Serialize <ushort>(TileSetLength, name: nameof(TileSetLength));
IsCompressed = s.Serialize <bool>(IsCompressed, name: nameof(IsCompressed));
Is8Bit = s.Serialize <bool>(Is8Bit, name: nameof(Is8Bit));
}
var tileLength = s.GameSettings.EngineVersion < EngineVersion.GBA_BatmanVengeance && Is8Bit ? 64 : 32;
if (IsDataCompressed ?? IsCompressed)
{
s.DoEncoded(new GBA_LZSSEncoder(), () => TileSet = s.SerializeArray <byte>(TileSet, TileSetLength * tileLength, name: nameof(TileSet)));
s.Align();
}
else
{
TileSet = s.SerializeArray <byte>(TileSet, TileSetLength * tileLength, name: nameof(TileSet));
}
}
/// <summary>
/// Handles the data serialization
/// </summary>
/// <param name="s">The serializer object</param>
public override void SerializeImpl(SerializerObject s)
{
// Serialize data
if (s.GameSettings.EngineVersion == EngineVersion.R1_DSi)
{
DSi_Dword_00 = s.Serialize <uint>(DSi_Dword_00, name: nameof(DSi_Dword_00));
DSi_Dword_04 = s.Serialize <uint>(DSi_Dword_04, name: nameof(DSi_Dword_04));
}
ImageDataPointer = s.SerializePointer(ImageDataPointer, name: nameof(ImageDataPointer));
BlockIndicesPointer = s.SerializePointer(BlockIndicesPointer, name: nameof(BlockIndicesPointer));
PaletteIndicesPointer = s.SerializePointer(PaletteIndicesPointer, name: nameof(PaletteIndicesPointer));
PalettesPointer = s.SerializePointer(PalettesPointer, name: nameof(PalettesPointer));
Width = s.Serialize <ushort>(Width, name: nameof(Width));
Height = s.Serialize <ushort>(Height, name: nameof(Height));
UnkBytes_14 = s.SerializeArray <byte>(UnkBytes_14, 4, name: nameof(UnkBytes_14));
Pointer_18 = s.SerializePointer(Pointer_18, name: nameof(Pointer_18));
Pointer_1B = s.SerializePointer(Pointer_1B, name: nameof(Pointer_1B));
UnkBytes_20 = s.SerializeArray <byte>(UnkBytes_20, 4, name: nameof(UnkBytes_20));
if (s.GameSettings.EngineVersion == EngineVersion.R1_DSi)
{
DSi_Dword_2C = s.Serialize <uint>(DSi_Dword_2C, name: nameof(DSi_Dword_2C));
}
// Serialize data from pointers
SerializeVignette(s, s.GameSettings.EngineVersion == EngineVersion.R1_DSi);
}
public override void SerializeBlock(SerializerObject s)
{
if (s.GameSettings.EngineVersion == EngineVersion.GBC_R1_PocketPC)
{
FileOffsets = s.SerializeArraySize <uint, uint>(FileOffsets, name: nameof(FileOffsets));
FileOffsets = s.SerializeArray <uint>(FileOffsets, FileOffsets.Length, name: nameof(FileOffsets));
if (Files == null)
{
Files = new SoundFile_PPC[FileOffsets.Length];
}
for (int i = 0; i < FileOffsets.Length; i++)
{
if (FileOffsets[i] == 0)
{
continue;
}
s.Goto(BlockStartPointer + FileOffsets[i]);
Files[i] = s.SerializeObject <SoundFile_PPC>(Files[i], name: $"{nameof(Files)}[{i}]");
}
}
else
{
DataOffsetsOffset = s.Serialize <ushort>(DataOffsetsOffset, name: nameof(DataOffsetsOffset));
UShort_02 = s.Serialize <ushort>(UShort_02, name: nameof(UShort_02));
SoundIDOffsetCount = s.Serialize <ushort>(SoundIDOffsetCount, name: nameof(SoundIDOffsetCount));
SoundOffsetCount = s.Serialize <ushort>(SoundOffsetCount, name: nameof(SoundOffsetCount));
s.DoAt(BlockStartPointer + DataOffsetsOffset, () => {
SoundIDOffsets = s.SerializeArray <ushort>(SoundIDOffsets, SoundIDOffsetCount, name: nameof(SoundIDOffsets));
SoundOffsets = s.SerializeArray <ushort>(SoundOffsets, SoundOffsetCount, name: nameof(SoundOffsets));
});
if (SoundIDs == null)
{
SoundIDs = new SoundID[SoundIDOffsetCount];
}
if (Sounds == null)
{
Sounds = new Sound[SoundOffsetCount];
}
for (int i = 0; i < SoundIDs.Length; i++)
{
s.Goto(BlockStartPointer + SoundIDOffsets[i]);
SoundIDs[i] = s.SerializeObject <SoundID>(SoundIDs[i], name: $"{nameof(SoundIDs)}[{i}]");
}
for (int i = 0; i < Sounds.Length; i++)
{
int nextOff = i < Sounds.Length - 1 ? SoundOffsets[i + 1] : (int)BlockSize;
int length = nextOff - SoundOffsets[i];
s.Goto(BlockStartPointer + SoundOffsets[i]);
Sounds[i] = s.SerializeObject <Sound>(Sounds[i], onPreSerialize: d => d.Length = length, name: $"{nameof(Sounds)}[{i}]");
if (Sounds[i].SoundProgramID.HasValue)
{
Sounds[i].SoundProgram = s.DoAt(DependencyTable.GetPointer(Sounds[i].SoundProgramID.Value - 1), () => {
return(s.SerializeObject <GBC_SoundProgram>(Sounds[i].SoundProgram, name: nameof(Sound.SoundProgram)));
});
}
}
}
}
public override void SerializeImpl(SerializerObject s)
{
FunctionPointer_0 = s.SerializePointer(FunctionPointer_0, name: nameof(FunctionPointer_0));
FunctionPointer_1 = s.SerializePointer(FunctionPointer_1, name: nameof(FunctionPointer_1));
FunctionPointer_2 = s.SerializePointer(FunctionPointer_2, name: nameof(FunctionPointer_2));
Bytes_10 = s.SerializeArray <byte>(Bytes_10, 4, name: nameof(Bytes_10));
AdditionalHeight = s.SerializeObject <FixedPointInt>(AdditionalHeight, name: nameof(AdditionalHeight));
Bytes_18 = s.SerializeArray <byte>(Bytes_18, 20, name: nameof(Bytes_18));
}
public override void SerializeImpl(SerializerObject s)
{
DataLength = s.Serialize <uint>(DataLength, name: nameof(DataLength));
if (DataLength > 0)
{
Unk2 = s.SerializeArray <byte>(Unk2, 24, name: nameof(Unk2));
Data = s.SerializeArray <byte>(Data, DataLength, name: nameof(Data));
}
}
public override void SerializeImpl(SerializerObject s)
{
HasEvents = s.Serialize <bool>(HasEvents, name: nameof(HasEvents));
s.SerializeArray <byte>(new byte[3], 3, name: "Padding");
// Serialize event map dimensions
Width = s.Serialize <ushort>(Width, name: nameof(Width));
Height = s.Serialize <ushort>(Height, name: nameof(Height));
EventIndexMap = s.SerializeArray <ushort>(EventIndexMap, Width * Height, name: nameof(EventIndexMap));
}
public override void SerializeBlock(SerializerObject s)
{
IndicesCount8bpp = s.Serialize <ushort>(IndicesCount8bpp, name: nameof(IndicesCount8bpp));
IndicesCount4bpp = s.Serialize <ushort>(IndicesCount4bpp, name: nameof(IndicesCount4bpp));
if (HasExtraData)
{
ExtraData = s.SerializeArray <byte>(ExtraData, 4, name: nameof(ExtraData));
}
Indices8bpp = s.SerializeArray <ushort>(Indices8bpp, IndicesCount8bpp, name: nameof(Indices8bpp));
Indices4bpp = s.SerializeArray <ushort>(Indices4bpp, IndicesCount4bpp, name: nameof(Indices4bpp));
}
public override void SerializeImpl(SerializerObject s)
{
GraphicsPointer = s.SerializeObject <SNES_Pointer>(GraphicsPointer, onPreSerialize: p => p.HasMemoryBankValue = true, name: nameof(GraphicsPointer));
VRAMAddress = s.Serialize <ushort>(VRAMAddress, name: nameof(VRAMAddress));
BytesToCopy = s.Serialize <ushort>(BytesToCopy, name: nameof(BytesToCopy));
Unknown = s.SerializeArray <byte>(Unknown, BytesToCopy >> 8, name: nameof(Unknown));
GraphicsBuffer = s.DoAt(GraphicsPointer.GetPointer(), () => {
return(s.SerializeArray <byte>(GraphicsBuffer, BytesToCopy, name: nameof(GraphicsBuffer)));
});
}
/// <summary>
/// Handles the data serialization
/// </summary>
/// <param name="s">The serializer object</param>
public override void SerializeImpl(SerializerObject s)
{
ImageDescriptorsPointer = s.Serialize <uint>(ImageDescriptorsPointer, name: nameof(ImageDescriptorsPointer));
AnimationDescriptorsPointer = s.Serialize <uint>(AnimationDescriptorsPointer, name: nameof(AnimationDescriptorsPointer));
Dummy1 = s.SerializeArray <byte>(Dummy1, 32, name: nameof(Dummy1));
ImageBufferLength = s.Serialize <uint>(ImageBufferLength, name: nameof(ImageBufferLength));
Dummy2 = s.SerializeArray <byte>(Dummy2, 24, name: nameof(Dummy2));
ImageDescriptorsCount = s.Serialize <ushort>(ImageDescriptorsCount, name: nameof(ImageDescriptorsCount));
Dummy3 = s.SerializeArray <byte>(Dummy3, 62, name: nameof(Dummy3));
AnimationDescriptorsCount = s.Serialize <byte>(AnimationDescriptorsCount, name: nameof(AnimationDescriptorsCount));
Dummy4 = s.SerializeArray <byte>(Dummy4, 3, name: nameof(Dummy4));
}
public override void SerializeImpl(SerializerObject s)
{
Palette = s.SerializeObjectArray <RGBA5551Color>(Palette, 256, name: nameof(Palette));
Width = s.Serialize <ushort>(Width, name: nameof(Width));
Height = s.Serialize <ushort>(Height, name: nameof(Height));
TileSetCount = s.Serialize <uint>(TileSetCount, name: nameof(TileSetCount));
TileMap = s.SerializeObjectArray <MapTile>(TileMap, Width * Height, name: nameof(TileMap));
TileSet = s.SerializeArray <byte>(TileSet, TileSetCount * 0x20, name: nameof(TileSet));
PaletteIndices = s.SerializeArray <byte>(PaletteIndices, (Width * Height) / 2, name: nameof(PaletteIndices));
}
public override void SerializeImpl(SerializerObject s)
{
ObjectType = s.Serialize <Mode7Type>(ObjectType, name: nameof(ObjectType));
if (ObjectType != Mode7Type.Invalid)
{
XPosition = s.Serialize <short>(XPosition, name: nameof(XPosition));
YPosition = s.Serialize <short>(YPosition, name: nameof(YPosition));
Data0 = s.SerializeArray <byte>(Data0, 10, name: nameof(Data0));
AnimFrame = s.Serialize <short>(AnimFrame, name: nameof(AnimFrame));
Data1 = s.SerializeArray <byte>(Data1, 14, name: nameof(Data1));
}
}
public override void SerializeImpl(SerializerObject s)
{
Sync = s.SerializeArray <byte>(Sync, 12, name: nameof(Sync));
Header = s.SerializeArray <byte>(Header, 4, name: nameof(Header));
SubHeader = s.SerializeArray <byte>(SubHeader, 8, name: nameof(SubHeader));
Object = s.SerializeObject <T>(Object, name: nameof(Object));
s.Goto(Offset + ISO9960_BinFile.SectorDataSize + ISO9960_BinFile.SectorHeaderSize);
EDC = s.SerializeArray <byte>(EDC, 4, name: nameof(EDC));
ECC = s.SerializeArray <byte>(ECC, 276, name: nameof(ECC));
}
/// <summary>
/// Handles the data serialization
/// </summary>
/// <param name="s">The serializer object</param>
public override void SerializeImpl(SerializerObject s)
{
// Serialize the background layer information
BackgroundDefineNormal = s.SerializeObjectArray <R1_BackgroundLayerPosition>(BackgroundDefineNormal, 6, name: nameof(BackgroundDefineNormal));
BackgroundDefineDiff = s.SerializeObjectArray <R1_BackgroundLayerPosition>(BackgroundDefineDiff, 6, name: nameof(BackgroundDefineDiff));
Unknown3 = s.SerializeArray <byte>(Unknown3, 16, name: nameof(Unknown3));
BackgroundLayerInfos = s.SerializeObjectArray <R1_ImageDescriptor>(BackgroundLayerInfos, 12, name: nameof(BackgroundLayerInfos));
Unknown4 = s.SerializeArray <byte>(Unknown4, s.GameSettings.EngineVersion == EngineVersion.R1_PS1_JP ? 208 : 80, name: nameof(Unknown4));
}
public override void SerializeImpl(SerializerObject s)
{
FrameTablePointer = s.SerializePointer(FrameTablePointer, name: nameof(FrameTablePointer));
HitBox = s.SerializeObject <AnimRect>(HitBox, name: nameof(HitBox));
RenderBox = s.SerializeObject <AnimRect>(RenderBox, name: nameof(RenderBox));
PaletteIndex = s.Serialize <byte>(PaletteIndex, name: nameof(PaletteIndex));
AnimSpeed = s.Serialize <byte>(AnimSpeed, name: nameof(AnimSpeed));
FramesCount = s.Serialize <byte>(FramesCount, name: nameof(FramesCount));
Byte_13 = s.Serialize <byte>(Byte_13, name: nameof(Byte_13));
s.SerializeArray <byte>(new byte[4], 4, name: "Padding");
FrameTable = s.DoAt(FrameTablePointer, () => s.SerializeArray <ushort>(FrameTable, FramesCount, name: nameof(FrameTable)));
}
public override void SerializeImpl(SerializerObject s)
{
Bytes_00 = s.SerializeArray <byte>(Bytes_00, 16, name: nameof(Bytes_00));
PalettePointer = s.SerializePointer(PalettePointer, name: nameof(PalettePointer));
Pointer_14 = s.SerializePointer(Pointer_14, name: nameof(Pointer_14));
Pointer_18 = s.SerializePointer(Pointer_18, name: nameof(Pointer_18));
Pointer_1C = s.SerializePointer(Pointer_1C, name: nameof(Pointer_1C));
Pointer_20 = s.SerializePointer(Pointer_20, name: nameof(Pointer_20));
Pointer_24 = s.SerializePointer(Pointer_24, name: nameof(Pointer_24));
Bytes_28 = s.SerializeArray <byte>(Bytes_28, 8, name: nameof(Bytes_28));
NamePointer = s.SerializePointer(NamePointer, name: nameof(NamePointer));
Palette = s.DoAt(PalettePointer, () => s.SerializeObjectArray <ARGB1555Color>(Palette, 16, name: nameof(Palette)));
Name = s.DoAt(NamePointer, () => s.SerializeString(Name, name: nameof(Name)));
}
public override void SerializeBlock(SerializerObject s)
{
Width = s.Serialize <uint>(Width, name: nameof(Width));
Height = s.Serialize <uint>(Height, name: nameof(Height));
Speed = s.Serialize <uint>(Speed, name: nameof(Speed));
FrameCount = s.Serialize <uint>(FrameCount, name: nameof(FrameCount));
FrameOffsets = s.SerializeArray <uint>(FrameOffsets, FrameCount, name: nameof(FrameOffsets));
if (s.GameSettings.EngineVersion == EngineVersion.GBC_R1_PocketPC)
{
if (FrameDataPPC == null)
{
FrameDataPPC = new BGR565Color[FrameCount][];
}
for (int i = 0; i < FrameDataPPC.Length; i++)
{
uint decompressedSize = Width * Height * 2;
uint nextOff = i < FrameDataPPC.Length - 1 ? FrameOffsets[i + 1] : BlockSize;
uint compressedSize = nextOff - FrameOffsets[i];
s.DoAt(BlockStartPointer + FrameOffsets[i], () => {
s.DoEncoded(new Lzo1xEncoder(compressedSize, decompressedSize), () => {
FrameDataPPC[i] = s.SerializeObjectArray <BGR565Color>(FrameDataPPC[i], Width * Height, name: $"{nameof(FrameDataPPC)}[{i}]");
});
});
}
}
}
/// <summary>
/// Serializes the data
/// </summary>
/// <param name="s">The serializer object</param>
public override void SerializeImpl(SerializerObject s)
{
// HEADER
base.SerializeImpl(s);
// IMAGE BLOCK
s.DoAt(ImageBlockPointer, () => ImageBlock = s.SerializeObject <R1_PS1_VignetteBlockGroup>(ImageBlock, name: nameof(ImageBlock), onPreSerialize: x => x.BlockGroupSize = (int)(PaletteBlockPointer - ImageBlockPointer) / 2));
// PARALLAX PALETTES
s.DoAt(PaletteBlockPointer, () =>
{
// TODO: Get correct length and parse
UnknownPaletteHeader = s.SerializeArray <byte>(UnknownPaletteHeader, (FileSize - PaletteBlockPointer.FileOffset) % 512, name: nameof(UnknownPaletteHeader));
uint numPalettes = (uint)(FileSize - s.CurrentPointer.FileOffset) / (256 * 2);
if (ParallaxPalettes == null)
{
ParallaxPalettes = new ARGB1555Color[numPalettes][];
}
for (int i = 0; i < ParallaxPalettes.Length; i++)
{
ParallaxPalettes[i] = s.SerializeObjectArray <ARGB1555Color>(ParallaxPalettes[i], 256, name: nameof(ParallaxPalettes) + "[" + i + "]");
}
});
}
/// <summary>
/// Handles the data serialization
/// </summary>
/// <param name="s">The serializer object</param>
public override void SerializeImpl(SerializerObject s)
{
MapData = s.DoAt(s.CurrentPointer + 0x28000, () => s.SerializeObject <MapData>(MapData, name: nameof(MapData)));
Palettes = s.DoAt(s.CurrentPointer + 0x2ADC4, () => s.SerializeObjectArray <ARGB1555Color>(Palettes, 16 * 16, name: nameof(Palettes)));
TileDescriptors = s.DoAt(s.CurrentPointer + 0x1AAF8, () => s.SerializeObjectArray <SNES_Proto_TileDescriptor>(TileDescriptors, 1024 * 4, name: nameof(TileDescriptors)));
TileMap = s.DoAt(s.CurrentPointer + 0x30000, () => s.SerializeArray <byte>(TileMap, 0x10000, name: nameof(TileMap)));
}
