public static void Write(Stream stream, IEnumerable <WorldPoint> worldPoints) { foreach (var item in worldPoints) { BinaryMapping.WriteObject(stream, item); } }
public void Write(Stream stream) { var entries = new List <Entry>(8); AddEntry(entries, HeaderSize, 1); AddEntry(entries, CollisionMeshGroupList.Count * Col1Size, 0x10); AddEntry(entries, CollisionMeshList.Count * Col2Size, 0x10); AddEntry(entries, CollisionList.Count * Col3Size, 4); AddEntry(entries, VertexList.Count * Col4Size, 0x10); AddEntry(entries, PlaneList.Count * Col5Size, 0x10); AddEntry(entries, BoundingBoxList.Count * Col6Size, 0x10); AddEntry(entries, SurfaceFlagsList.Count * Col7Size, 4); stream.Position = 0; BinaryMapping.WriteObject(stream, new Header { MagicCode = MagicCode, Version = 1, Unknown08 = Unknown08, Unknown0c = Unknown0c, Entries = entries.ToArray() }); WriteCoctEntry(stream, CollisionMeshGroupList); WriteCoctEntry(stream, CollisionMeshList); WriteCoctEntry(stream, CollisionList); stream.AlignPosition(0x10); WriteValueEntry(stream, VertexList, WriteVector4); WriteValueEntry(stream, PlaneList, WritePlane); WriteValueEntry(stream, BoundingBoxList, WriteBoundingBoxInt16); WriteCoctEntry(stream, SurfaceFlagsList); }
public static void Write(Stream stream, Ite ite) { BinaryMapping.WriteObject <Header>(stream, ite.header); // Weapon. for (int i = 0; i < ite.header.WeaponDataCount; i++) { BinaryMapping.WriteObject <ITEData>(stream, ite.WeaponList[i]); } // Flavor. for (int i = 0; i < ite.header.FlavorDataCount; i++) { BinaryMapping.WriteObject <ITEData>(stream, ite.FlavorList[i]); } // Key Item. for (int i = 0; i < ite.header.KeyItemDataCount; i++) { BinaryMapping.WriteObject <ITEData>(stream, ite.KeyItemList[i]); } // Key Item Hide. for (int i = 0; i < ite.header.KeyItemHideDataCount; i++) { BinaryMapping.WriteObject <ITEData>(stream, ite.KeyItemHideList[i]); } // Synthesis. for (int i = 0; i < ite.header.SynthesisDataCount; i++) { BinaryMapping.WriteObject <ITEData>(stream, ite.SynthesisList[i]); } }
public void Write(Stream stream) { if (!stream.CanWrite || !stream.CanSeek) { throw new InvalidDataException($"Write and seek must be supported."); } var header = new Header { MagicCode = MagicCodeValidator, Version = SupportedVersion, L1Count = SequenceProperties.Count, L2Count = SequenceGroups.Count, SequenceCount = SequenceItems.Count, }; stream.Position = MinimumLength; header.L1Offset = (int)stream.Position; header.L2Offset = stream.WriteList(SequenceProperties) + header.L1Offset; header.SequenceOffset = stream.WriteList(SequenceGroups) + header.L2Offset; WriteSequences(stream); stream.Position = 0; BinaryMapping.WriteObject(stream, header); }
public static void Write(Stream stream, Epd epd) { BinaryMapping.WriteObject <Header>(stream, epd.header); BinaryMapping.WriteObject <GeneralParameters>(stream, epd.generalParameters); BinaryWriter w = new BinaryWriter(stream); foreach (char[] anim in epd.AnimationList) { w.Write(anim); } stream.Write((uint)0); stream.Write((uint)0); BinaryMapping.WriteObject <OtherParameters>(stream, epd.otherParameters); foreach (TechniqueParameters param in epd.techniqueParameters) { BinaryMapping.WriteObject <TechniqueParameters>(stream, param); } foreach (DropParameters param in epd.dropParameters) { BinaryMapping.WriteObject <DropParameters>(stream, param); } foreach (ExtraParameters param in epd.extraParameters) { BinaryMapping.WriteObject <ExtraParameters>(stream, param); } }
public static List <byte> toBytes <T>(T item) where T : class { MemoryStream memStream = new MemoryStream(); BinaryMapping.WriteObject(memStream, item); return(memStream.ToArray().ToList()); }
public static void AssertReadAndWrite <T>(T value, int expectedLength, Action <ValuePair <T> > assertion = null) { var expected = new Generic <T> { Value = value }; var actual = new Generic <T>(); var memory = new MemoryStream(); var reader = new BinaryReader(memory); var writer = new BinaryWriter(memory); BinaryMapping.WriteObject(writer, expected); Assert.Equal(expectedLength, memory.Length); memory.Position = 0; BinaryMapping.ReadObject(reader, actual); Assert.Equal(expectedLength, memory.Position); if (assertion != null) { assertion(new ValuePair <T> { Expected = value, Actual = actual.Value }); } else { Assert.Equal(expected.Value, actual.Value); } }
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(); BinaryMapping.WriteObject(memStream, foo); memStream.Position = 0; var foo2 = BinaryMapping.ReadObject(memStream, new Foo()) as Foo; Assert.Equal(foo.List[0].Data[0xC], foo2.List[0].Data[0xC]); }
public void SimpleBitfieldTest() { var rawData = new byte[] { 0xAD, 0x02 }; var memStream = new MemoryStream(rawData); var actual = BinaryMapping.ReadObject(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(memStream, actual); Assert.Equal(2, memStream.Position); memStream.Position = 0; Assert.Equal(rawData[0], memStream.ReadByte()); Assert.Equal(rawData[1], memStream.ReadByte()); }
public static void Write(Stream stream, Pmo pmo) { stream.Position = 0; BinaryMapping.WriteObject <Pmo.Header>(stream, pmo.header); for (int i = 0; i < pmo.header.TextureCount; i++) { BinaryMapping.WriteObject <Pmo.TextureInfo>(stream, pmo.textureInfo[i]); } WriteMeshData(stream, pmo); // Write textures. for (int t = 0; t < pmo.texturesData.Count; t++) { stream.Write(pmo.texturesData[t]); } if (pmo.header.SkeletonOffset != 0) { BinaryMapping.WriteObject <SkeletonHeader>(stream, pmo.skeletonHeader); for (int joint = 0; joint < pmo.jointList.Length; joint++) { BinaryMapping.WriteObject <JointData>(stream, pmo.jointList[joint]); } } }
private void WriteCoctEntry <T>(Stream stream, IEnumerable <T> entries) where T : class, IData { foreach (var entry in entries) { BinaryMapping.WriteObject(stream, entry); } }
public void Write(Stream stream) { Count = Items.Count; BinaryMapping.WriteObject(stream, this); foreach (var item in Items) { BinaryMapping.WriteObject(stream, item); } }
public static void WriteHeaderData(Stream stream, Pmo pmo) { BinaryMapping.WriteObject <Pmo.Header>(stream, pmo.header); for (int i = 0; i < pmo.header.TextureCount; i++) { BinaryMapping.WriteObject <Pmo.TextureInfo>(stream, pmo.textureInfo[i]); } }
public static void Write(Stream stream, IEnumerable <PAtkData> AttackData) { var list = AttackData.ToList(); foreach (var item in list) { BinaryMapping.WriteObject(stream, item); } }
public static void Write(Stream stream, Itb itb) { BinaryMapping.WriteObject <Header>(stream, itb.header); for (int i = 0; i < itb.header.ItemsTotal; i++) { BinaryMapping.WriteObject <ITBData>(stream, itb.AllITB[i]); } }
private static void Write(Stream stream, RawMotion rawMotion, bool unkFlag) { const int HeaderSize = 0x60; stream.Write(new byte[ReservedSize], 0, ReservedSize); BinaryMapping.WriteObject(stream, new Header { Version = 1, Unk04 = unkFlag ? 1 : 0, ByteCount = HeaderSize + rawMotion.BoneCount * rawMotion.Matrices.Count * Matrix4x4Size + rawMotion.Matrices2.Length * Matrix4x4Size, Unk0c = 0, }); BinaryMapping.WriteObject(stream, new RawMotionInternal { BoneCount = rawMotion.BoneCount, Unk14 = 0, Unk18 = 0, Unk1c = 0, FrameCountPerLoop = (int)(rawMotion.FrameEnd - rawMotion.FrameLoop) * 2, TotalFrameCount = rawMotion.Matrices.Count, Unk28 = rawMotion.Unk28, Unk2c = rawMotion.Matrices2.Length > 0 ? HeaderSize + rawMotion.BoneCount * rawMotion.Matrices.Count * Matrix4x4Size : 0, BoundingBoxMinX = rawMotion.BoundingBoxMinX, BoundingBoxMinY = rawMotion.BoundingBoxMinY, BoundingBoxMinZ = rawMotion.BoundingBoxMinZ, BoundingBoxMinW = rawMotion.BoundingBoxMinW, BoundingBoxMaxX = rawMotion.BoundingBoxMaxX, BoundingBoxMaxY = rawMotion.BoundingBoxMaxY, BoundingBoxMaxZ = rawMotion.BoundingBoxMaxZ, BoundingBoxMaxW = rawMotion.BoundingBoxMaxW, FrameLoop = rawMotion.FrameLoop, FrameEnd = rawMotion.FrameEnd, FramePerSecond = rawMotion.FramePerSecond, FrameCount = rawMotion.FrameCount }); var writer = new BinaryWriter(stream); foreach (var block in rawMotion.Matrices) { for (int i = 0; i < block.Length; i++) { WriteMatrix(writer, block[i]); } } for (int i = 0; i < rawMotion.Matrices2.Length; i++) { WriteMatrix(writer, rawMotion.Matrices2[i]); } writer.Flush(); }
public void Write(Stream stream) { BinaryMapping.WriteObject(stream, Header); if (!IsLastChunk) { BinaryMapping.WriteObject(stream, Content); stream.Write(Content.RawData, 0, Content.RawData.Length); } }
private static Hed.Entry AddFile(string inputFolder, string filename, FileStream hedStream, FileStream pkgStream, bool shouldCompressData = false, bool shouldEncryptData = false) { var completeFilePath = Path.Combine(inputFolder, ORIGINAL_FILES_FOLDER_NAME, filename); var offset = pkgStream.Position; #region Data using var newFileStream = File.OpenRead(completeFilePath); var header = new EgsHdAsset.Header() { // CompressedLenght => -2: no compression and encryption, -1: no compression CompressedLength = !shouldCompressData ? !shouldEncryptData ? -2 : -1 : 0, DecompressedLength = (int)newFileStream.Length, RemasteredAssetCount = 0, CreationDate = -1 }; var decompressedData = newFileStream.ReadAllBytes(); var compressedData = decompressedData.ToArray(); if (shouldCompressData) { compressedData = Helpers.CompressData(decompressedData); header.CompressedLength = compressedData.Length; } // Encrypt and write current file data in the PKG stream // The seed used for encryption is the original data header var seed = new MemoryStream(); BinaryMapping.WriteObject <EgsHdAsset.Header>(seed, header); var encryptionSeed = seed.ReadAllBytes(); var encryptedData = header.CompressedLength > -2 ? EgsEncryption.Encrypt(compressedData, encryptionSeed) : compressedData; // Write original file header BinaryMapping.WriteObject <EgsHdAsset.Header>(pkgStream, header); // Make sure to write the original file after remastered assets headers pkgStream.Write(encryptedData); #endregion // Write a new entry in the HED stream var hedHeader = new Hed.Entry() { MD5 = Helpers.ToBytes(Helpers.CreateMD5(filename)), ActualLength = (int)newFileStream.Length, DataLength = (int)(pkgStream.Position - offset), Offset = offset }; BinaryMapping.WriteObject <Hed.Entry>(hedStream, hedHeader); return(hedHeader); }
public static void Write(Stream stream, IEnumerable <FontCharacterInfo> charactersInfo) { stream.Position = 0; foreach (var info in charactersInfo) { BinaryMapping.WriteObject(stream, info); } stream.SetLength(stream.Position); }
public void Write(Stream stream) { using (var tempStream = new MemoryStream()) { BinaryMapping.WriteObject(tempStream, this); Checksum = SaveKh3.CalculateChecksum(tempStream); } SaveKh3.Mapper.WriteObject(stream.SetPosition(0), this); }
public static void Write(Stream stream, Pmp pmp) { stream.Position = 0; BinaryMapping.WriteObject <Header>(stream, pmp.header); for (int i = 0; i < pmp.objectInfo.Count; i++) { BinaryMapping.WriteObject <ObjectInfo>(stream, pmp.objectInfo[i]); } List <Pmo> nPmoList = pmp.PmoList; nPmoList.Sort((l, r) => l.PMO_StartPosition.CompareTo(r.PMO_StartPosition)); for (int p = 0; p < nPmoList.Count; p++) { uint off = (uint)stream.Position; stream.Seek(0x44 + (p * 0x30), SeekOrigin.Begin); stream.Write(off); stream.Seek(0, SeekOrigin.End); BinaryMapping.WriteObject <Pmo.Header>(stream, nPmoList[p].header); for (int g = 0; g < nPmoList[p].textureInfo.Length; g++) { BinaryMapping.WriteObject <Pmo.TextureInfo>(stream, nPmoList[p].textureInfo[g]); } Pmo.WriteMeshData(stream, nPmoList[p]); } uint pos = (uint)stream.Position; stream.Seek(0x1C, SeekOrigin.Begin); stream.Write(pos); stream.Seek(0, SeekOrigin.End); for (int tl = 0; tl < pmp.TextureList.Count; tl++) { BinaryMapping.WriteObject <PMPTextureInfo>(stream, pmp.TextureList[tl]); } for (int td = 0; td < pmp.TextureList.Count; td++) { uint sPos = (uint)stream.Position; List <Tm2> l = new List <Tm2>(); l.Add(pmp.TextureDataList[td]); Tm2.Write(stream, l); stream.Seek(pos + (td * 0x20), SeekOrigin.Begin); stream.Write(sPos); stream.Seek(0, SeekOrigin.End); } }
public static void Write(Stream stream, ICollection <ObjectCollision> collisions) { stream.Write(collisions.Count); stream.Write(1); stream.Position += 0x40 - 8; foreach (var item in collisions) { BinaryMapping.WriteObject(stream, item); } }
public static void Write(Stream stream, IEnumerable <BobDescriptor> bobDescriptors) { var items = bobDescriptors.ToList(); stream.Write(8); stream.Write(items.Count * 0x68); foreach (var item in bobDescriptors) { BinaryMapping.WriteObject(stream, item); } }
public static int WriteList <T>(this Stream stream, IEnumerable <T> items) where T : class { var oldPosition = (int)stream.Position; foreach (var item in items) { BinaryMapping.WriteObject <T>(stream, item, oldPosition); } return((int)stream.Position - oldPosition); }
public static void Write <TSaveKhBbs>(Stream stream, TSaveKhBbs save) where TSaveKhBbs : class, ISaveKhBbs { uint checksum; using (var tempStream = new MemoryStream()) { BinaryMapping.WriteObject(tempStream, save); checksum = CalculateChecksum(tempStream); } save.Checksum = checksum; BinaryMapping.WriteObject(stream.FromBegin(), save); }
public static void Write(Stream stream, WalkPathDesc entity) { BinaryMapping.WriteObject(stream, new Raw { Unk00 = entity.Unk00, Count = (short)entity.Positions.Count, Unk04 = entity.Unk04, Unk06 = entity.Unk06, }); foreach (var position in entity.Positions) { BinaryMapping.WriteObject(stream, position); } }
public static void Write(Stream stream, Bep bep) { BinaryMapping.WriteObject <Header>(stream, bep.header); for (int c = 0; c < bep.disappearParameters.Count; c++) { BinaryMapping.WriteObject <BaseParameter>(stream, bep.baseParameters[c]); } for (int d = 0; d < bep.disappearParameters.Count; d++) { BinaryMapping.WriteObject <DisappearParameter>(stream, bep.disappearParameters[d]); } }
public static void Write(Stream stream, IEnumerable <Event> events) { var list = events.ToList(); BinaryMapping.WriteObject(stream, new Header { MagicCode = MagicCode, Count = list.Count }); foreach (var item in list) { BinaryMapping.WriteObject(stream, item); } }
public static void Write(Stream stream, List <SpawnPoint> items) { stream.Write(2); stream.Write(items.Count); foreach (var item in items) { BinaryMapping.WriteObject(stream, new Raw { Type = item.Type, Flag = item.Flag, Id = item.Id, EntityCount = (short)item.Entities.Count, EventActivatorCount = (short)item.EventActivators.Count, WalkPathCount = (short)item.WalkPath.Count, ReturnParameterCount = (short)item.ReturnParameters.Count, SignalCount = (short)item.Signals.Count, Reserved10 = 0, Reserved14 = 0, Reserved18 = 0, Place = item.Teleport.Place, Door = item.Teleport.Door, World = item.Teleport.World, Unk1f = item.Teleport.Unknown, Unk20 = item.Unk20, Unk24 = item.Unk24, Unk28 = 0, }); foreach (var spawnPoint in item.Entities) { Entity.Write(stream, spawnPoint); } foreach (var unk in item.EventActivators) { EventActivator.Write(stream, unk); } foreach (var unk in item.WalkPath) { WalkPathDesc.Write(stream, unk); } foreach (var unk in item.ReturnParameters) { ReturnParameter.Write(stream, unk); } foreach (var unk in item.Signals) { Signal.Write(stream, unk); } } }
public static void Write(Stream stream, IEnumerable <MissionData> data) { Header head = new Header(); head.MagicCode = MagicCode; head.FileVersion = FileVersion; head.DataCount = (ushort)data.Count(); BinaryMapping.WriteObject <Header>(stream, head); foreach (MissionData miss in data) { BinaryMapping.WriteObject <MissionData>(stream, miss); } }