//----------------------------------------------------------------------------------------------------------
////////////////////////////////////////////////////////////////////////////////////////////////////////////
///335 ADT READER END
////////////////////////////////////////////////////////////////////////////////////////////////////////////
//----------------------------------------------------------------------------------------------------------
// MCIN chunk reader
private MCIN ReadMCINChunk(uint size, BinaryReader bin)
{
var mcinChunk = new MCIN()
{
offset = bin.ReadUInt32(),
size = bin.ReadUInt32(),
flags = bin.ReadUInt32(),
AsyncId = bin.ReadUInt32(),
};
return(mcinChunk);
}
/// <summary>
/// Parse all MCIN element from file stream
/// </summary>
public override MCIN[] Parse()
{
Reader.BaseStream.Position = AbsoluteStart;
var mcins = new MCIN[256];
for (var i = 0; i < 256; i++)
{
var mcin = new MCIN {
Offset = Reader.ReadUInt32(),
Size = Reader.ReadUInt32(),
Flags = Reader.ReadUInt32(),
AsyncId = Reader.ReadUInt32()
};
mcins[i] = mcin;
}
return(mcins);
}
public ADT(string filePath)
{
ADTfileInfo = new FileInfo(filePath);
Logger.log(ADTfileInfo.Name, Logger.Type.READ, ADTfileInfo.DirectoryName);
//Start reading the .ADT File
using (BinaryReader reader = new BinaryReader(ADTfileInfo.Open(FileMode.Open)))
{
Length = (int)reader.BaseStream.Length;
reader.BaseStream.Seek(0, SeekOrigin.Begin);
int MCNK_counter = 0;
int MCNK_size = 0;
while (reader.BaseStream.Position < reader.BaseStream.Length)
{
byte[] ChunkMagic = reader.ReadBytes(4);
byte[] ChunkSize = reader.ReadBytes(4);
byte[] ChunkContent = reader.ReadBytes(BitConverter.ToInt32(ChunkSize, 0));
string ChunkMagicString = MagicBytesToString(ChunkMagic);
//read the chunks
switch (ChunkMagicString)
{
case "MVER":
MVER = new MVER(MagicBytesToChars(ChunkMagic), ChunkSize, ChunkContent);
break;
case "MHDR":
MHDR = new MHDR(MagicBytesToChars(ChunkMagic), ChunkSize, ChunkContent);
break;
case "MCIN":
MCIN = new MCIN(MagicBytesToChars(ChunkMagic), ChunkSize, ChunkContent);
break;
case "MTEX":
MTEX = new MTEX(MagicBytesToChars(ChunkMagic), ChunkSize, ChunkContent);
break;
case "MMDX":
MMDX = new MMDX(MagicBytesToChars(ChunkMagic), ChunkSize, ChunkContent);
break;
case "MMID":
MMID = new MMID(MagicBytesToChars(ChunkMagic), ChunkSize, ChunkContent);
break;
case "MWMO":
MWMO = new MWMO(MagicBytesToChars(ChunkMagic), ChunkSize, ChunkContent);
break;
case "MWID":
MWID = new MWID(MagicBytesToChars(ChunkMagic), ChunkSize, ChunkContent);
break;
case "MDDF":
MDDF = new MDDF(MagicBytesToChars(ChunkMagic), ChunkSize, ChunkContent);
break;
case "MODF":
MODF = new MODF(MagicBytesToChars(ChunkMagic), ChunkSize, ChunkContent);
break;
case "MH2O":
MH2O = new MH2O(MagicBytesToChars(ChunkMagic), ChunkSize, ChunkContent);
break;
case "MCNK":
MCNKs.Add(new MCNK(MagicBytesToChars(ChunkMagic), ChunkSize, ChunkContent));
break;
case "MFBO":
MFBO = new MFBO(MagicBytesToChars(ChunkMagic), ChunkSize, ChunkContent);
break;
}
if (ChunkMagicString == "MCNK")
{
MCNK_counter++; MCNK_size += BitConverter.ToInt32(ChunkSize, 0);
}
else if (ChunkMagicString == "\0\0\0\0") /*Logger.log("0 Byte Chunk", Logger.Direction.WARNING);*/ } {
}
if (MCNK_counter > 0)
{
Logger.log("MCNK[]", Logger.Type.LEVEL1, MCNK_size + " byte");
}
}
}
public void Write()
{
using (var writer = new BinaryWriter(File.OpenWrite("test.adt")))
{
// MVER
writer.Write(MVER.GetChunkHeaderBytes());
writer.Write(MVER.GetChunkBytes());
// Write MHDR later when we got all offsets
var positionBeforeMHDR = writer.BaseStream.Position;
writer.BaseStream.Position += _HeaderSize + MHDR.ChunkSize;
// MTEX
MHDR.OffsetMTEX = (uint)writer.BaseStream.Position;
writer.Write(MTEX.GetChunkHeaderBytes());
writer.Write(MTEX.GetChunkBytes());
// MMDX
MHDR.OffsetMMDX = (uint)writer.BaseStream.Position;
writer.Write(MMDX.GetChunkHeaderBytes());
writer.Write(MMDX.GetChunkBytes());
// MMID
MHDR.OffsetMMID = (uint)writer.BaseStream.Position;
writer.Write(MMID.GetChunkHeaderBytes());
writer.Write(MMID.GetChunkBytes());
// MWMO
MHDR.OffsetMWMO = (uint)writer.BaseStream.Position;
writer.Write(MWMO.GetChunkHeaderBytes());
writer.Write(MWMO.GetChunkBytes());
// MWID
MHDR.OffsetMWID = (uint)writer.BaseStream.Position;
writer.Write(MWID.GetChunkHeaderBytes());
writer.Write(MWID.GetChunkBytes());
// MDDF
MHDR.OffsetMDDF = (uint)writer.BaseStream.Position;
writer.Write(MDDF.GetChunkHeaderBytes());
writer.Write(MDDF.GetChunkBytes());
// MODF
MHDR.OffsetMODF = (uint)writer.BaseStream.Position;
writer.Write(MODF.GetChunkHeaderBytes());
writer.Write(MODF.GetChunkBytes());
// MH2O
MHDR.OffsetMH2O = (uint)writer.BaseStream.Position;
writer.Write(MH2O.GetChunkHeaderBytes());
writer.Write(MH2O.GetChunkBytes());
// MCNK
for (int i = 0; i < MCIN.Entries.Length; i++)
{
MCIN.Entries[i].OffsetMCNK = (uint)writer.BaseStream.Position;
MCIN.Entries[i].ChunkSize = MCNK[i].ChunkSize;
writer.Write(MCNK[i].GetChunkHeaderBytes());
writer.Write(MCNK[i].GetChunkBytes());
}
// MCIN
MHDR.OffsetMCIN = (uint)writer.BaseStream.Position;
writer.Write(MCIN.GetChunkHeaderBytes());
writer.Write(MCIN.GetChunkBytes());
// MFBO
if (MHDR.Flags.HasFlag(MHDRFlags.MFBO))
{
MHDR.OffsetMFBO = (uint)writer.BaseStream.Position;
writer.Write(MFBO.GetChunkHeaderBytes());
writer.Write(MFBO.GetChunkBytes());
}
else
{
MHDR.OffsetMFBO = 0;
}
// MTXF
MHDR.OffsetMTXF = (uint)writer.BaseStream.Position;
writer.Write(MTXF.GetChunkHeaderBytes());
writer.Write(MTXF.GetChunkBytes());
// MHDR
writer.BaseStream.Position = positionBeforeMHDR;
writer.Write(MHDR.GetChunkHeaderBytes());
writer.Write(MHDR.GetChunkBytes());
}
}
