/// <summary>
/// Write the file.
/// </summary>
/// <param name="w">The writer.</param>
public override void Write(FileWriter w)
{
//Init file.
w.InitFile <XFileHeader>(FType ? "FSEQ" : "CSEQ", ByteOrder, Version, 2);
//Data block.
w.InitBlock("DATA", blockType: 0x5000);
w.Write(RawData);
w.Align(0x20);
w.CloseBlock();
//Label block.
w.InitBlock("LABL", blockType: 0x5001);
w.Write((uint)Labels.Count);
for (int i = 0; i < Labels.Count; i++)
{
w.InitReference <XReference <object> >("Labl" + i);
}
for (int i = 0; i < Labels.Count; i++)
{
w.CloseReference("Labl" + i, 0x5100);
w.Write(new LabelEntry()
{
Offset = Labels.Values.ElementAt(i), Str = Labels.Keys.ElementAt(i)
});
}
w.Align(0x20);
w.CloseBlock();
//Close file.
w.CloseFile();
}
public override void Write(FileWriter writer, LayoutHeader header)
{
long startPos = writer.Position - 8;
writer.Write(AnimationOrder);
writer.Write((ushort)Groups.Count);
writer.Write(uint.MaxValue); //animNameOffset
writer.Write(uint.MaxValue); //groupNamesOffset
if (header.VersionMajor >= 8)
{
writer.Write(0); //unk
}
writer.Write((ushort)StartFrame);
writer.Write((ushort)EndFrame);
writer.Write(ChildBinding);
writer.Write(UnknownData);
writer.WriteUint32Offset(startPos + 12, startPos);
writer.WriteString(Name);
writer.Align(4);
writer.WriteUint32Offset(startPos + 16, startPos);
for (int i = 0; i < Groups.Count; i++)
{
writer.WriteString(Groups[i], 0x14);
}
writer.Align(4);
}
/// <summary>
/// Write the archive.
/// </summary>
/// <param name="w">The writer.</param>
public override void Write(FileWriter w)
{
//Write the archive.
w.Write("DARC".ToCharArray());
w.Align(0x10);
//Info block.
w.Write("INFO".ToCharArray());
w.Write((uint)Files.Count);
for (int i = 0; i < Files.Count; i++)
{
w.Write(Files.Keys.ElementAt(i));
w.InitOffset("Offset" + i);
w.InitOffset("Size" + i);
w.Write(PackedFiles.Contains(Files.Keys.ElementAt(i)));
}
//Data block.
w.Align(0x10);
w.Write("DATA".ToCharArray());
for (int i = 0; i < Files.Count; i++)
{
w.CloseOffset("Offset" + i);
w.StartStructure();
w.Write(Files.Values.ElementAt(i));
w.CloseOffset("Size" + i);
w.EndStructure();
}
}
public void Save(System.IO.Stream stream)
{
using (var writer = new FileWriter(stream))
{
writer.Write(uint.MaxValue); //header size
writer.Write(uint.MaxValue); //file size
writer.Write(files.Count);
for (int i = 0; i < files.Count; i++)
{
writer.Write(files[i].Hash);
writer.Write(uint.MaxValue); //start offset
writer.Write(uint.MaxValue); //end offset
}
writer.Align(128);
writer.WriteUint32Offset(0, 4); //Size of header - 4
for (int i = 0; i < files.Count; i++)
{
files[i].SaveFileFormat();
writer.WriteUint32Offset(20 + (i * 16)); //start offset
writer.Write(files[i].FileData);
writer.WriteUint32Offset(24 + (i * 16)); //end offset
writer.Align(8);
}
using (writer.TemporarySeek(4, SeekOrigin.Begin)) {
writer.Write((int)writer.BaseStream.Length);
}
}
}
public override void Write(FileWriter writer, HsfFile header)
{
var meshes = header.Meshes.Where(x => x.TexCoords.Count > 0).ToList();
long posStart = writer.Position;
foreach (var mesh in meshes)
{
writer.Write(header.GetStringOffset(mesh.Name));
writer.Write(mesh.TexCoords.Count);
writer.Write(uint.MaxValue);
}
long dataPos = writer.Position;
for (int i = 0; i < meshes.Count; i++)
{
meshes[i].ObjectData.TexCoordIndex = i;
writer.Align(0x20);
writer.WriteUint32Offset(posStart + 8 + (i * 12), dataPos);
for (int j = 0; j < meshes[i].TexCoords.Count; j++)
{
writer.Write(meshes[i].TexCoords[j]);
}
}
writer.Align(4);
}
public void Write(FileWriter writer, FFNT Header)
{
long pos = writer.Position;
if (BinaryTextureFile != null)
{
var mem = new System.IO.MemoryStream();
BinaryTextureFile.Save(mem);
SheetDataList[0] = mem.ToArray();
}
writer.WriteSignature("TGLP");
writer.Write(uint.MaxValue);
writer.Write(CellWidth);
writer.Write(CellHeight);
writer.Write((byte)SheetDataList.Count);
writer.Write(MaxCharWidth);
writer.Write(SheetDataList[0].Length);
writer.Write(BaseLinePos);
writer.Write(Format);
writer.Write(ColumnCount);
writer.Write(RowCount);
writer.Write(SheetWidth);
writer.Write(SheetHeight);
long _ofsSheetBlocks = writer.Position;
writer.Write(uint.MaxValue);
if (Header.Platform == FFNT.PlatformType.NX)
{
writer.Align(4096);
}
else
{
writer.Align(8192);
}
long DataPosition = writer.Position;
using (writer.TemporarySeek(_ofsSheetBlocks, SeekOrigin.Begin))
{
writer.Write((uint)DataPosition);
}
for (int i = 0; i < SheetDataList.Count; i++)
{
writer.Write(SheetDataList[i]);
}
long SectionEndPosition = writer.Position;
//End of section. Set the size
using (writer.TemporarySeek(pos + 4, SeekOrigin.Begin))
{
writer.Write((uint)(SectionEndPosition - pos));
}
}
private void SetAlignment(FileWriter writer, string FileName)
{
if (FileName.EndsWith(".gmx"))
{
writer.Align(0x40);
}
else if (FileName.EndsWith(".gtx"))
{
writer.Align(0x2000);
}
else
{
writer.Write(DefaultAlignment);
}
}
public override void Write(FileWriter writer, LayoutHeader header)
{
long startPos = writer.Position - 8;
base.Write(writer, header);
writer.Write(Properties.Count);
writer.Write(MagnifyX);
writer.Write(MagnifyY);
for (int i = 0; i < Properties.Count; i++)
{
Properties[i].Write(writer, header, startPos);
}
writer.WriteString(LayoutFileName);
writer.Align(4);
// for (int i = 0; i < Properties.Count; i++)
// Properties[i].WriteProperties(writer, header, startPos);
// for (int i = 0; i < Properties.Count; i++)
// Properties[i].WriteUserData(writer, header, startPos);
for (int i = 0; i < Properties.Count; i++)
{
Properties[i].WriteProperties(writer, header, startPos);
Properties[i].WriteUserData(writer, header, startPos);
Properties[i].WritePaneInfo(writer, header, startPos);
}
}
public void WriteEffectNormals(FileWriter writer, HsfFile header)
{
if (Meshes.Count == 0)
{
return;
}
List <EffectMesh> readMeshes = new List <EffectMesh>();
var ObjectsSorted = Objects.OrderBy(x => x.VertexIndex).ToList();
for (int i = 0; i < ObjectsSorted.Count; i++)
{
if (ObjectsSorted[i].VertexIndex >= 0 && Meshes.Count > ObjectsSorted[i].VertexIndex)
{
var effectMesh = Meshes[ObjectsSorted[i].VertexIndex];
int index = Objects.IndexOf(ObjectsSorted[i]);
if (!readMeshes.Contains(effectMesh))
{
writer.Align(0x20);
effectMesh.NormalOffset = (uint)writer.Position;
for (int j = 0; j < effectMesh.Normals.Count; j++)
{
writer.Write(effectMesh.Normals[j]);
}
readMeshes.Add(effectMesh);
}
var obj = Objects[index];
obj.NormalsOffset = (int)effectMesh.NormalOffset;
}
}
}
public void WriteBlock(FileWriter writer, int DataAlignment = 0)
{
//From the block size goto where the data will start
writer.Seek((int)(BlockSize + headerPos), SeekOrigin.Begin);
//Add alignment if necessary
if (DataAlignment != 0)
{
writer.Align(DataAlignment);
}
var blockPos = writer.Position;
//Satisfy the offset
using (writer.TemporarySeek(headerPos + 16, SeekOrigin.Begin))
{
//Offset starts from the block header
writer.Write(blockPos - headerPos);
}
writer.Write(Data);
//Set the total size
uint TotalDataSize = (uint)(writer.Position - blockPos);
using (writer.TemporarySeek(headerPos + 8, SeekOrigin.Begin)) {
writer.Write((ulong)TotalDataSize);
}
}
public void Write(FileWriter writer)
{
writer.WriteSignature("GFLXPACK");
writer.Write(version);
writer.Write(0);
writer.Write(files.Count);
writer.Write(FolderCount);
long FileInfoOffset = writer.Position;
writer.Write(0L);
long HashArrayOffset = writer.Position;
writer.Write(0L);
long folderArrOffset = writer.Position;
//Reserve space for folder offsets
for (int f = 0; f < FolderCount; f++)
{
writer.Write(0L);
}
//Now write all sections
writer.WriteUint64Offset(HashArrayOffset);
foreach (var fileTbl in files)
{
writer.Write(fileTbl.FilePathHash);
}
//Save folder sections
List <long> FolderSectionPositions = new List <long>();
foreach (var folder in folders)
{
FolderSectionPositions.Add(writer.Position);
folder.Write(writer);
}
//Write the folder offsets back
using (writer.TemporarySeek(folderArrOffset, SeekOrigin.Begin))
{
foreach (long offset in FolderSectionPositions)
{
writer.Write(offset);
}
}
//Now file data
writer.WriteUint64Offset(FileInfoOffset);
foreach (var fileTbl in files)
{
fileTbl.Write(writer);
}
//Save data blocks
foreach (var fileTbl in files)
{
fileTbl.WriteBlock(writer);
}
writer.Align(16);
}
public void Write(FileWriter writer)
{
writer.WriteSignature(Magic);
if (Magic == "EFCC")
{
writer.ByteOrder = Syroot.BinaryData.ByteOrder.LittleEndian;
}
else
{
writer.ByteOrder = Syroot.BinaryData.ByteOrder.BigEndian;
}
writer.Write(Version);
writer.Write((ushort)Entries.Count);
writer.Write((ushort)StringEntries.Count);
writer.Write((ushort)0);
for (int i = 0; i < Entries.Count; i++)
{
Entries[i].Write(writer);
}
for (int i = 0; i < StringEntries.Count; i++)
{
writer.Write(StringEntries[i]);
writer.Align(2);
}
}
internal void Write(FileWriter writer)
{
writer.ByteOrder = Syroot.BinaryData.ByteOrder.LittleEndian;
writer.Write(Encoding.ASCII.GetBytes("AAMP"));
writer.Write(Version);
writer.Write(Endianness);
long sizeOffset = writer.Position;
writer.Write(0); //Write the file size later
writer.Write(ParameterIOVersion);
writer.Write(AlignUp(ParameterIOType.Length + 1, 4));
writer.Write(ParameterIOType, Syroot.BinaryData.BinaryStringFormat.ZeroTerminated);
writer.Align(4);
ParamListV1.Write(RootNode, writer);
//Write end of file
writer.Seek(sizeOffset, System.IO.SeekOrigin.Begin);
uint FileSize = (uint)writer.BaseStream.Length;
writer.Write(FileSize);
writer.Close();
writer.Dispose();
}
public void Write(FileWriter writer)
{
writer.WriteSignature("VFXB");
writer.Write(0x20202020);
writer.Write(GraphicsAPIVersion);
writer.Write(VFXVersion);
writer.Write(ByteOrderMark);
writer.Write(Alignment);
writer.Write(TargetOffset);
writer.Write(32);
writer.Write(Flag);
writer.Write(BlockOffset);
writer.Write(0);
long _ofsFileSize = writer.Position;
writer.Write(0);
writer.Seek(BlockOffset, SeekOrigin.Begin);
foreach (var section in Sections)
{
writer.Align(8);
section.Write(writer, this);
}
using (writer.TemporarySeek(_ofsFileSize, SeekOrigin.Begin))
{
writer.Write(writer.BaseStream.Length);
}
writer.Flush();
writer.Close();
writer.Dispose();
}
public void Write(FileWriter writer)
{
writer.Write(ElementCount);
writer.Write(DataType, true);
writer.Write(Stride);
writer.Write(Unknown1);
writer.Write(BufferData);
writer.Align(4);
}
public virtual void Write(FileWriter writer, Header header)
{
writer.WriteSignature(Signature);
writer.Write(Data.Length);
writer.Write(Padding);
writer.Write(EntryCount);
writer.Write(Data);
writer.Align(16);
}
public override void Write(FileWriter writer, HsfFile header)
{
for (int i = 0; i < Attributes.Count; i++)
{
var mat = Attributes[i];
mat.NameOffset = (uint)header.GetStringOffset(AttributeNames[i]);
writer.WriteStruct(mat);
}
writer.Align(4);
}
public override void Write(FileWriter writer, HsfFile header)
{
long startPos = writer.Position;
for (int i = 0; i < Palettes.Count; i++)
{
writer.WriteStruct(Palettes[i]);
}
long dataPos = writer.Position;
for (int i = 0; i < Palettes.Count; i++)
{
writer.Align(0x20);
writer.WriteUint32Offset(startPos + 12 + (i * 16), dataPos);
writer.Write(PaletteData[i]);
}
writer.Align(4);
}
public void Write(FileWriter w)
{
w.Write((ushort)0x1F00);
w.Write((ushort)0);
w.Write(Offset);
w.Write(Str.Length);
w.Write(Str.ToCharArray());
w.Write((byte)0);
w.Align(0x4);
}
public override void Write(FileWriter writer, HsfFile header)
{
for (int i = 0; i < header.Materials.Count; i++)
{
var mat = header.Materials[i];
mat.MaterialData.NameOffset = (uint)header.GetStringOffset(mat.Name);
writer.WriteStruct(mat.MaterialData);
}
writer.Align(4);
}
public override void Write(FileWriter writer, HsfFile header)
{
var meshes = header.Meshes.Where(x => x.Positions.Count > 0).ToList();
long posStart = writer.Position;
foreach (var mesh in meshes)
{
writer.Write(header.GetStringOffset(mesh.Name));
writer.Write(mesh.Normals.Count);
writer.Write(uint.MaxValue);
}
if (meshes.Count == 1)
{
TypeFlag = DataType.Sbyte;
}
long dataPos = writer.Position;
for (int i = 0; i < meshes.Count; i++)
{
meshes[i].ObjectData.NormalIndex = i;
writer.Align(0x20);
writer.WriteUint32Offset(posStart + 8 + (i * 12), dataPos);
for (int j = 0; j < meshes[i].Normals.Count; j++)
{
if (TypeFlag == DataType.Sbyte)
{
writer.Write((sbyte)(meshes[i].Normals[j].X * sbyte.MaxValue));
writer.Write((sbyte)(meshes[i].Normals[j].Y * sbyte.MaxValue));
writer.Write((sbyte)(meshes[i].Normals[j].Z * sbyte.MaxValue));
}
else
{
writer.Write(meshes[i].Normals[j]);
}
}
}
writer.Align(4);
}
public void Write(FileWriter writer)
{
writer.SetByteOrder(IsBigEndian);
if (IsV1)
{
writer.Write(Images.Count);
for (int i = 0; i < Images.Count; i++)
{
((ImageHeaderV1)Images[i].Header).Write(writer);
}
AlignBytesIncrement(writer, 32);
for (int i = 0; i < Images.Count; i++)
{
writer.WriteUint32Offset(8 + (i * 0x10));
writer.Write(Images[i].ImageData);
}
}
else
{
writer.Write(0x0020AF30);
writer.Write(Images.Count);
writer.Write(0x0C); //Offset always 12
//Reserve space for palette and header offsets
writer.Write(new byte[Images.Count * 8]);
//Then write the palettes first
for (int i = 0; i < Images.Count; i++)
{
if (Images[i].PaletteHeader != null)
{
writer.WriteUint32Offset(16 + (i * 8));
Images[i].PaletteHeader.Write(writer);
}
}
//Then write the headers
long imageHeaderPos = writer.Position;
for (int i = 0; i < Images.Count; i++)
{
writer.WriteUint32Offset(12 + (i * 8));
((ImageHeaderV2)Images[i].Header).Write(writer);
}
//Then write the data
for (int i = 0; i < Images.Count; i++)
{
writer.Align(64);
writer.WriteUint32Offset(imageHeaderPos + 8 + (i * 0x24));
writer.Write(Images[i].ImageData);
}
}
}
public void Write(FileWriter writer)
{
byte format = FormatList.FirstOrDefault(x => x.Value == Format).Key;
writer.Write(format);
writer.Write(Padding);
writer.Write(Width);
writer.Write(Height);
writer.Align(32);
writer.Write(ImageData);
}
public override void Write(FileWriter writer, HsfFile header)
{
long texpos = writer.Position;
for (int i = 0; i < header.Textures.Count; i++)
{
var tex = header.Textures[i].TextureInfo;
tex.NameOffset = (uint)header.GetStringOffset(header.Textures[i].Name);
writer.WriteStruct(tex);
}
long datapos = writer.Position;
for (int i = 0; i < header.Textures.Count; i++)
{
writer.Align(0x20);
writer.WriteUint32Offset(texpos + 28 + (i * 32), datapos);
writer.Write(header.Textures[i].ImageData);
}
writer.Align(8);
}
public void Save(Stream stream)
{
using (var writer = new FileWriter(stream)) {
writer.SetByteOrder(true);
writer.WriteStruct(ImageHeader);
writer.Align(32);
writer.Write(ImageData);
if (((GamecubeSwizzle)Platform).PaletteData.Length > 0)
{
writer.Write(((GamecubeSwizzle)Platform).PaletteData);
}
}
}
public byte[] AlignData(byte[] data)
{
using (var mem = new MemoryStream(data))
{
using (var writer = new FileWriter(mem))
{
writer.Write(data);
writer.Align((int)Alignment);
return(mem.ToArray());
}
}
}
public void WriteUserData(FileWriter writer, LayoutHeader header, long startPos)
{
if (UserData != null)
{
writer.WriteUint32Offset(_ofsPos + 4, startPos);
long pos = writer.Position;
writer.WriteSignature("usd1");
writer.Write(uint.MaxValue);
UserData.Write(writer, header);
writer.Align(4);
writer.WriteSectionSizeU32(pos + 4, pos, writer.Position);
}
}
public void Save(System.IO.Stream stream)
{
using (var writer = new FileWriter(stream))
{
writer.Write((ushort)Width);
writer.Write((ushort)Height);
writer.Write(Unknown);
ushort format = FormatsTXE.FirstOrDefault(x => x.Value == Format).Key;
writer.Write(format);
writer.Write(ImageData.Length);
writer.Align(32);
writer.Write(ImageData);
}
}
/// <summary>
/// Write the sequence file.
/// </summary>
/// <param name="w">The writer.</param>
public override void Write(FileWriter w)
{
//Init file.
w.InitFile <RFileHeader>("RSEQ", ByteOrder.BigEndian, new RVersion()
{
Major = 1, Minor = 0
}, 2);
//Data block.
w.InitBlock("DATA");
w.Write((uint)0xC);
w.Write(RawData);
w.Align(0x20, true);
w.CloseBlock();
//Label block.
w.InitBlock("LABL");
w.Write((uint)Labels.Count);
for (int i = 0; i < Labels.Count; i++)
{
w.InitOffset("label" + i);
}
for (int i = 0; i < Labels.Count; i++)
{
w.CloseOffset("label" + i);
w.Write(Labels.Values.ElementAt(i));
w.Write((uint)Labels.Keys.ElementAt(i).Length);
w.Write(Labels.Keys.ElementAt(i).ToCharArray());
w.Write((byte)0);
w.Align(4, true);
}
w.Align(0x20, true);
w.CloseBlock();
//Close file.
w.CloseFile();
}
private byte[] CreateBuffer(List <byte[]> imageData)
{
var mem = new MemoryStream();
using (var writer = new FileWriter(mem))
{
for (int i = 0; i < imageData.Count; i++)
{
if (i > 0)
{
writer.Align(Alignment);
}
writer.Write(imageData[i]);
}
return(mem.ToArray());
}
}