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