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