public static Olo Read(Stream stream)
{
Olo olo = new Olo();
olo.header = BinaryMapping.ReadObject <Header>(stream);
olo.ObjectList = new List <ObjectName>();
stream.Seek(olo.header.SpawnObjectsOffset, SeekOrigin.Begin);
for (int i = 0; i < olo.header.SpawnObjectsCount; i++)
{
olo.ObjectList.Add(BinaryMapping.ReadObject <ObjectName>(stream));
}
olo.FileList = new List <PathName>();
stream.Seek(olo.header.FilePathOffset, SeekOrigin.Begin);
for (int i = 0; i < olo.header.FilePathCount; i++)
{
olo.FileList.Add(BinaryMapping.ReadObject <PathName>(stream));
}
olo.ScriptList = new List <PathName>();
stream.Seek(olo.header.ScriptPathOffset, SeekOrigin.Begin);
for (int i = 0; i < olo.header.ScriptPathCount; i++)
{
olo.FileList.Add(BinaryMapping.ReadObject <PathName>(stream));
}
olo.MissionNameList = new List <ObjectName>();
stream.Seek(olo.header.MissionNameOffset, SeekOrigin.Begin);
for (int i = 0; i < olo.header.MissionNameCount; i++)
{
olo.MissionNameList.Add(BinaryMapping.ReadObject <ObjectName>(stream));
}
olo.TriggerList = new List <TriggerData>();
stream.Seek(olo.header.TriggerDataOffset, SeekOrigin.Begin);
for (int i = 0; i < olo.header.TriggerDataCount; i++)
{
olo.TriggerList.Add(BinaryMapping.ReadObject <TriggerData>(stream));
}
olo.GroupList = new List <GroupData>();
stream.Seek(olo.header.GroupDataOffset, SeekOrigin.Begin);
olo.LayoutList = new List <LayoutData>();
for (int i = 0; i < olo.header.GroupDataCount; i++)
{
stream.Seek(olo.header.GroupDataOffset + (i * 0x30), SeekOrigin.Begin);
GroupData data = BinaryMapping.ReadObject <GroupData>(stream);
stream.Seek(data.ObjectLayoutDataOffset, SeekOrigin.Begin);
for (int j = 0; j < data.ObjectLayoutDataCount; j++)
{
olo.LayoutList.Add(BinaryMapping.ReadObject <LayoutData>(stream));
}
olo.GroupList.Add(data);
}
return(olo);
}
public EgsHdAsset(Stream stream)
{
_stream = stream;
_baseOffset = stream.Position;
_seed = stream.ReadBytes(0x10);
_key = EgsEncryption.GenerateKey(_seed, PASS_COUNT);
_header = BinaryMapping.ReadObject <Header>(new MemoryStream(_seed));
var entries = Enumerable
.Range(0, _header.RemasteredAssetCount)
.Select(_ => BinaryMapping.ReadObject <RemasteredEntry>(stream))
.ToList();
_entries = entries.ToDictionary(x => x.Name, x => x);
_dataOffset = stream.Position;
Assets = entries.Select(x => x.Name).ToArray();
ReadData();
foreach (var remasteredAssetName in Assets)
{
ReadRemasteredAsset(remasteredAssetName);
}
stream.SetPosition(_dataOffset);
}
public static List <T> ReadList <T>(this Stream stream, int count)
where T : class
{
return(Enumerable.Range(0, count)
.Select(x => BinaryMapping.ReadObject <T>(stream, (int)stream.Position))
.ToList());
}
public void WriteShouldNotOverwriteAnyDataWhenStrideIsConsidered()
{
var foo = new Foo
{
List = new List <Bar>
{
new Bar()
{
Data = new byte[0x80],
SomeValue = 123
}
}
};
foo.List[0].Data[0xC] = 231;
var memStream = new MemoryStream();
var writer = new BinaryWriter(memStream);
BinaryMapping.WriteObject(writer, foo);
memStream.Position = 0;
var foo2 = BinaryMapping.ReadObject(new BinaryReader(memStream), new Foo()) as Foo;
Assert.Equal(foo.List[0].Data[0xC], foo2.List[0].Data[0xC]);
}
public static Entity Read(Stream stream)
{
var raw = BinaryMapping.ReadObject <Raw>(stream);
return(new Entity
{
ObjectId = raw.ObjectId,
PositionX = raw.PositionX,
PositionY = raw.PositionY,
PositionZ = raw.PositionZ,
RotationX = raw.RotationX,
RotationY = raw.RotationY,
RotationZ = raw.RotationZ,
SpawnType = raw.SpawnType,
SpawnArgument = raw.SpawnArgument,
Serial = raw.Serial,
Argument1 = raw.Argument1,
Argument2 = raw.Argument2,
ReactionCommand = raw.ReactionCommand,
SpawnDelay = raw.SpawnDelay,
Command = raw.Command,
SpawnRange = raw.SpawnRange,
Level = raw.Level,
Medal = raw.Medal,
});
}
private Sequence(Stream stream)
{
if (!stream.CanRead || !stream.CanSeek)
{
throw new InvalidDataException($"Read or seek must be supported.");
}
if (stream.Length < MinimumLength)
{
throw new InvalidDataException("Invalid header length");
}
var header = BinaryMapping.ReadObject <Header>(stream);
if (header.MagicCode != MagicCodeValidator)
{
throw new InvalidDataException("Invalid header");
}
Unknown04 = header.Unknown04;
Frames = stream.ReadList <Frame>(header.AnimationGroupsDesc.Offset, header.AnimationGroupsDesc.Count);
FramesEx = stream.ReadList <FrameEx>(header.AnimationsDesc.Offset, header.AnimationsDesc.Count);
FrameGroups = stream.ReadList <FrameGroup>(header.FrameGroupsDesc.Offset, header.FrameGroupsDesc.Count);
Animations = stream.ReadList <Animation>(header.FramesExDesc.Offset, header.FramesExDesc.Count);
AnimationGroups = stream.ReadList <AnimationGroup>(header.FramesDesc.Offset, header.FramesDesc.Count);
}
private static int ReadSubModel(Stream stream, out SubModel subModel)
{
var header = BinaryMapping.ReadObject <SubModelHeader>(stream);
subModel = new SubModel
{
Type = header.Type,
Unk04 = header.Unk04,
Unk08 = header.Unk08,
BoneCount = header.BoneCount,
Unk = header.Unk,
DmaChainCount = header.DmaChainCount,
};
var dmaChainHeaders = For(subModel.DmaChainCount, () => BinaryMapping.ReadObject <DmaChainHeader>(stream));
stream.Position = header.UnkDataOffset;
subModel.UnknownData = stream.ReadBytes(0x120);
if (header.BoneOffset != 0)
{
stream.Position = header.BoneOffset;
subModel.Bones = For(subModel.BoneCount, () => ReadBone(stream)).ToList();
}
subModel.DmaChains = dmaChainHeaders.Select(x => ReadDmaChain(stream, x)).ToList();
return(header.NextOffset);
}
private Imgd(Stream stream)
{
stream
.MustReadAndSeek()
.MustHaveHeaderLengthOf(HeaderLength);
var reader = new BinaryReader(stream);
var header = BinaryMapping.ReadObject <Header>(stream);
if (header.MagicCode != MagicCode)
{
throw InvalidHeaderException;
}
Size = new Size(header.Width, header.Height);
format = header.Format;
swizzled = header.Swizzled;
stream.SetPosition(header.BitmapOffset);
var data = reader.ReadBytes(header.BitmapLength);
// Swap pixel order for only unswizzled 4-bpp IMGD.
Data = (format == Format4bpp && (swizzled & 4) == 0)
? GetSwappedPixelData(data)
: data;
stream.SetPosition(header.ClutOffset);
Clut = reader.ReadBytes(header.ClutLength);
}
public static bool IsFac(Stream stream)
{
if (stream.Length < HeaderLength)
{
return(false);
}
stream.MustReadAndSeek().SetPosition(0);
var header = BinaryMapping.ReadObject <Header>(stream);
if (header.MagicCode != MagicCode)
{
return(false);
}
stream
.SetPosition(header.ClutOffset + header.ClutLength)
.AlignPosition(FacAlignment);
if (stream.Position + HeaderLength >= stream.Length)
{
return(false);
}
header = BinaryMapping.ReadObject <Header>(stream);
if (header.MagicCode != MagicCode)
{
return(false);
}
return(true);
}
public void SimpleBitfieldTest()
{
var rawData = new byte[] { 0xAD, 0x02 };
var memStream = new MemoryStream(rawData);
var actual = BinaryMapping.ReadObject(new BinaryReader(memStream), new SimpleBitfieldFixture()) as SimpleBitfieldFixture;
Assert.NotNull(actual);
Assert.Equal(2, memStream.Position);
Assert.True(actual.Bit0);
Assert.False(actual.Bit1);
Assert.True(actual.Bit2);
Assert.True(actual.Bit3);
Assert.False(actual.Bit4);
Assert.True(actual.Bit5);
Assert.False(actual.Bit6);
Assert.True(actual.Bit7);
Assert.False(actual.Bit8);
Assert.True(actual.Bit9);
memStream = new MemoryStream();
BinaryMapping.WriteObject(new BinaryWriter(memStream), actual);
Assert.Equal(2, memStream.Position);
memStream.Position = 0;
Assert.Equal(rawData[0], memStream.ReadByte());
Assert.Equal(rawData[1], memStream.ReadByte());
}
public static Chunk Read(Stream stream)
{
var header = BinaryMapping.ReadObject <ChunkHeader>(stream);
ChunkContent content;
if (header.NextChunkOffset > 0)
{
content = BinaryMapping.ReadObject <ChunkContent>(stream);
if (content.ChunkLength > ContentHeaderLength)
{
content.RawData = stream.ReadBytes(content.ChunkLength - ContentHeaderLength);
}
else
{
content.RawData = new byte[0];
}
}
else
{
content = null;
}
if (header.NextChunkOffset > 0)
{
stream.Position = header.NextChunkOffset;
}
return(new Chunk(header, content));
}
private VpuPacket(Stream stream)
{
var vpu = BinaryMapping.ReadObject <VpuHeader>(stream);
VertexRange = Read(stream, vpu.UnkBoxLocation, vpu.UnkBoxCount, ReadInt32);
Indices = Read(stream, vpu.IndexLocation, vpu.IndexCount, ReadIndex);
Colors = Read(stream, vpu.ColorLocation, vpu.ColorCount, ReadColor);
Vertices = Read(stream, vpu.VertexLocation, vpu.VertexCount, ReadVertex);
if (vpu.VertexMixerCount > 0)
{
var countPerAmount = Read(stream, vpu.VertexMixerOffset, vpu.VertexMixerCount, ReadInt32);
VertexWeightedCount = countPerAmount.Sum();
VertexWeightedIndices = countPerAmount
.Select((count, amount) =>
{
stream.AlignPosition(0x10);
return(Enumerable
.Range(0, count)
.Select(x => Enumerable.Range(0, amount + 1).Select(y => stream.ReadInt32()).ToArray())
.ToArray());
})
.ToArray();
}
//Debug.Assert(vpu.VertexCount == Box.Sum());
}
private static SpawnPoint ReadSingle(Stream stream)
{
var raw = BinaryMapping.ReadObject <Raw>(stream);
var spawn = new SpawnPoint
{
Unk00 = raw.Unk00,
Unk02 = raw.Unk02,
Teleport = new TeleportDesc
{
Place = raw.Place,
Door = raw.Door,
World = raw.World,
Unknown = raw.Unk1f
},
Unk20 = raw.Unk20,
Unk24 = raw.Unk24,
};
spawn.Entities = ReadList(stream, raw.EntityCount, Entity.Read);
spawn.EventActivators = ReadList(stream, raw.EventActivatorCount, EventActivator.Read);
spawn.WalkPath = ReadList(stream, raw.Unk08Count, WalkPathDesc.Read);
spawn.Unknown0aTable = ReadList(stream, raw.Unk0aCount, Unknown0a.Read);
spawn.Unknown0cTable = ReadList(stream, raw.Unk0cCount, Unknown0c.Read);
return(spawn);
}
private VpuPacket(Stream stream)
{
var vpu = BinaryMapping.ReadObject <VpuHeader>(stream);
Indices = Read(stream, vpu.IndexLocation, vpu.IndexCount, ReadIndex);
Colors = Read(stream, vpu.ColorLocation, vpu.ColorCount, ReadColor);
Vertices = Read(stream, vpu.VertexLocation, vpu.VertexCount, ReadVertex);
}
public static List <WorldPoint> Read(Stream stream)
{
var estimatedItemCount = (int)(stream.Length - stream.Position) / 4;
return(Enumerable.Range(0, estimatedItemCount)
.Select(_ => BinaryMapping.ReadObject <WorldPoint>(stream))
.ToList());
}
internal static ArchivePartitionEntry Read(Stream stream)
{
var pastPos = stream.Position;
ArchivePartitionEntry archivepart = BinaryMapping.ReadObject <ArchivePartitionEntry>(stream);
archivepart.LocationOffset = pastPos;
return(archivepart);
}
public static void ReadTextureSection(Stream stream, Pmo pmo)
{
pmo.textureInfo = new TextureInfo[pmo.header.TextureCount];
for (ushort i = 0; i < pmo.header.TextureCount; i++)
{
pmo.textureInfo[i] = BinaryMapping.ReadObject <TextureInfo>(stream);
}
}
internal static PartitionFileEntry Read(Stream stream)
{
var pastPos = stream.Position;
PartitionFileEntry part = BinaryMapping.ReadObject <PartitionFileEntry>(stream);
part.LocationOffset = pastPos;
return(part);
}
private List <T> ReactCoctEntry <T>(Stream stream, int offset, int length)
where T : class, IData
{
stream.Position = offset;
return(Enumerable.Range(0, length)
.Select(_ => BinaryMapping.ReadObject <T>(stream))
.ToList());
}
public static SaveKhRecom Read(Stream stream)
{
var obj = BinaryMapping.ReadObject <SaveKhRecom>(stream);
obj.Data = BinaryMapping.ReadObject <DataRecom>(stream, (int)stream.Position);
return(obj);
}
public static List <Event> Read(Stream stream)
{
var header = BinaryMapping.ReadObject <Header>(stream);
return(Enumerable.Range(0, header.Count)
.Select(_ => BinaryMapping.ReadObject <Event>(stream))
.ToList());
}
public static IEnumerable <MissionData> Read(Stream stream)
{
Header head = BinaryMapping.ReadObject <Header>(stream);
return(Enumerable.Range(0, head.DataCount)
.Select(x => BinaryMapping.ReadObject <MissionData>(stream))
.ToArray());
}
public static List <T> Read(Stream stream)
{
var header = BinaryMapping.ReadObject <BaseShortTable <T> >(stream);
return(Enumerable.Range(0, header.Count)
.Select(_ => BinaryMapping.ReadObject <T>(stream))
.ToList());
}
public static BaseMixdata <T> Read(Stream stream)
{
var baseTable = BinaryMapping.ReadObject <BaseMixdata <T> >(stream);
baseTable.Items = Enumerable.Range(0, baseTable.Count)
.Select(_ => BinaryMapping.ReadObject <T>(stream))
.ToList();
return(baseTable);
}
public static List <ObjectCollision> Read(Stream stream)
{
var count = stream.ReadInt32();
stream.Position += 0x40 - 4;
return(Enumerable
.Range(0, count)
.Select(x => BinaryMapping.ReadObject <ObjectCollision>(stream))
.ToList());
}
public ModelCollision(Stream stream)
{
this.EntryCount = stream.ReadInt32();
this.Enable = stream.ReadInt32();
stream.Position += reservedSize;
this.EntryList = Enumerable
.Range(0, this.EntryCount)
.Select(x => BinaryMapping.ReadObject <ObjectCollision>(stream))
.ToList();
}
private Sequence(Stream inputStream)
{
inputStream.MustReadAndSeek();
if (inputStream.Length < MinimumLength)
{
throw new InvalidDataException("Invalid header length");
}
var stream = new SubStream(inputStream, inputStream.Position, inputStream.Length - inputStream.Position);
var header = BinaryMapping.ReadObject <Header>(stream);
if (header.MagicCode != MagicCodeValidator)
{
throw new InvalidDataException("Invalid header");
}
Unknown04 = header.Unknown04;
Sprites = stream.ReadList <RawSprite>(header.SpriteDesc.Offset, header.SpriteDesc.Count)
.Select(x => new Sprite
{
Left = x.Left,
Top = x.Top,
Right = x.Right,
Bottom = x.Bottom,
UTranslation = x.UTranslation,
VTranslation = x.VTranslation,
ColorLeft = x.ColorLeft,
ColorTop = x.ColorTop,
ColorRight = x.ColorRight,
ColorBottom = x.ColorBottom,
}).ToList();
var spritePart = stream.ReadList <SpritePart>(header.SpritePartDesc.Offset, header.SpritePartDesc.Count);
SpriteGroups = stream.ReadList <RawSpriteGroup>(header.SpriteGroupDesc.Offset, header.SpriteGroupDesc.Count)
.Select(x => spritePart.Skip(x.Start).Take(x.Count).ToList()).ToList();
var animations = stream.ReadList <Animation>(header.AnimationDesc.Offset, header.AnimationDesc.Count);
AnimationGroups = stream.ReadList <RawAnimationGroup>(header.AnimationGroupDesc.Offset, header.AnimationGroupDesc.Count)
.Select(x => new AnimationGroup
{
Animations = animations.Skip(x.AnimationIndex).Take(x.Count).ToList(),
DoNotLoop = x.DoNotLoop,
Unknown06 = x.Unknown06,
LoopStart = x.LoopStart,
LoopEnd = x.LoopEnd,
LightPositionX = x.Unknown10,
TextPositionY = x.Unknown14,
TextScale = x.Unknown18,
UiPadding = x.Unknown1C,
TextPositionX = x.Unknown20,
}).ToList();
}
private void checkBtlparam(string filePath)
{
List <byte> myByteArray = File.ReadAllBytes(filePath).ToList();
for (int i = 0; i < 229; i++)
{
List <byte> entryBytes = myByteArray.GetRange(i * 72, 72);
DDD_btlparam_Entry myEntry = BinaryMapping.ReadObject <DDD_btlparam_Entry>(new MemoryStream(entryBytes.ToArray()));
Debug.WriteLine("[" + i + "] " + myEntry.entity + "[" + myEntry.ele_physical + "]" + "[" + myEntry.ele_fire + "]" + " - " + myEntry.hp);
}
//DDD_btlparam_Entry myEntry = BinaryMapping.ReadObject<DDD_btlparam_Entry>(new MemoryStream(myByteArray));
}
private static IEnumerable <DmaPacket> ReadTags(Stream stream)
{
while (true)
{
var dmaPacket = BinaryMapping.ReadObject <DmaPacket>(stream);
yield return(dmaPacket);
if (dmaPacket.DmaTag.Qwc == 0)
{
yield break;
}
}
}
internal Layout(Stream stream)
{
if (!stream.CanRead || !stream.CanSeek)
{
throw new InvalidDataException($"Read or seek must be supported.");
}
if (stream.Length < MinimumLength)
{
throw new InvalidDataException("Invalid header length");
}
var header = BinaryMapping.ReadObject <Header>(stream);
if (header.MagicCode != MagicCodeValidator)
{
throw new InvalidDataException("Invalid header");
}
if (header.Version != SupportedVersion)
{
throw new InvalidDataException($"Unsupported version {header.Version}");
}
var sequenceProperties = stream.ReadList <SequenceProperty>(header.L1Offset, header.L1Count);
SequenceGroups = stream
.ReadList <RawSequenceGroup>(header.L2Offset, header.L2Count)
.Select(x => new SequenceGroup
{
Sequences = sequenceProperties.Skip(x.L1Index).Take(x.L1Count).ToList(),
Unknown04 = x.Unknown04,
Unknown08 = x.Unknown08,
Unknown0c = x.Unknown0c,
Unknown10 = x.Unknown10
})
.ToList();
SequenceItems = new List <Sequence>();
var sequenceOffsets = stream.ReadInt32List(header.SequenceOffset, header.SequenceCount);
sequenceOffsets.Add((int)stream.Length);
for (var i = 0; i < sequenceOffsets.Count - 1; i++)
{
// TODO Assuming that the sequence files are stored in order...
int offset = sequenceOffsets[i];
var length = sequenceOffsets[i + 1] - offset;
var sequenceStream = new SubStream(stream, offset, length);
SequenceItems.Add(Sequence.Read(sequenceStream));
}
}