public void ExportNamedConstants( GpuNamedConstants pConsts, string filename, Endian endianMode )
{
using ( var f = new FileStream( filename, FileMode.CreateNew, FileAccess.Write ) )
{
ExportNamedConstants( pConsts, f, endianMode );
}
}
/**
* Writes any number of bytes into a byte array, at a given position.
* This is an aux function used when creating the WAV data.
*/
public static void writeBytes(byte[] __bytes, ref int __position, byte[] __newBytes, Endian __endian) {
// Writes __newBytes to __bytes at position __position, increasing the position depending on the length of __newBytes
for (int i = 0; i < __newBytes.Length; i++) {
__bytes[__position] = __newBytes[__endian == Endian.BIG_ENDIAN ? i : __newBytes.Length - i - 1];
__position++;
}
}
public static BinaryReader Create(Stream s, Endian e)
{
if (BitConverter.IsLittleEndian)
{
if (Endian.Little == e)
{
return new BinaryReader(s);
}
else
{
return new EndianBinaryReader(s, e);
}
}
else
{
if (Endian.Big == e)
{
return new BinaryReader(s);
}
else
{
return new EndianBinaryReader(s, e);
}
}
}
public ByteBuffer(byte[] data, Endian endian)
{
_data = data;
_endian = endian;
_encoding = Encoding.ASCII;
_specificCharacterSet = null;
}
static private bool NeedConvert(Endian endian)
{
if (endian == Endian.LittleEndian)
return !isLittleEndian;
else
return isLittleEndian;
}
public static void WriteValueF32(this Stream stream, Single value, Endian endian)
{
byte[] data = ShouldSwap(endian) == true
? BitConverter.GetBytes(BitConverter.ToInt32(BitConverter.GetBytes(value), 0).Swap())
: BitConverter.GetBytes(value);
Debug.Assert(data.Length == 4);
stream.WriteBytes(data);
}
private void ExportNamedConstants( GpuNamedConstants pConsts, Stream stream, Endian endianMode )
{
using ( var w = new BinaryWriter( stream ) )
{
}
throw new NotImplementedException();
}
internal FileReference(string file, long offset, long length, Endian endian, DicomVr vr)
{
_filename = file;
_offset = offset;
_length = length;
_endian = endian;
_vr = vr;
}
public MemoryDomainByteArray(string name, Endian endian, byte[] data, bool writable, int wordSize)
{
Name = name;
EndianType = endian;
Data = data;
Writable = writable;
WordSize = wordSize;
}
internal FileReference(DicomStreamOpener streamOpener, long offset, long length, Endian endian, DicomVr vr)
{
StreamOpener = streamOpener;
Offset = offset;
_length = length;
Endian = endian;
Vr = vr;
}
public MPEntryValue(byte[] bytes, int startIndex, Endian endian)
{
ImageAttr = (uint)BitConverterEx.ToInt32(bytes, startIndex + 0, endian);
ImageSize = (uint)BitConverterEx.ToInt32(bytes, startIndex + 4, endian);
ImageDataOffset = (uint)BitConverterEx.ToInt32(bytes, startIndex + 8, endian);
DependentImage1 = (ushort)BitConverterEx.ToInt16(bytes, startIndex + 12, endian);
DependentImage2 = (ushort)BitConverterEx.ToInt16(bytes, startIndex + 14, endian);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="data">Data to encapsulate</param>
/// <param name="endian"><see cref="Endian"/> to use when reading the data.</param>
public EndianBinaryReader(byte[] data, Endian endian)
: base(new MemoryStream(data))
{
if (data == null)
throw new ArgumentNullException("data");
this.CurrentEndian = endian;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="endianness">Big or little endian</param>
/// <param name="sizeofInt">Size of int in bytes</param>
/// <param name="sizeofSizeT">Size of size_t in bytes</param>
/// <param name="sizeofLuaNumber">Size of lua_Number in bytes</param>
/// <param name="stripDebugInfo">Whether to strip debug info or not</param>
public LuaCompilerConfig(Endian endianness, int sizeofInt, int sizeofSizeT, int sizeofLuaNumber, bool stripDebugInfo)
{
Endianness = endianness;
SizeOfInt = sizeofInt;
SizeOfSizeT = sizeofSizeT;
SizeOfLuaNumber = sizeofLuaNumber;
StripDebugInfo = stripDebugInfo;
}
private ByteBuffer(byte[] data, Endian endian, bool highCapacityMode = false)
{
_data = data;
_endian = endian;
Encoding = Encoding.ASCII;
SpecificCharacterSet = null;
_highCapacityMode = highCapacityMode;
}
public static Guid ReadValueGuid(this Stream stream, Endian endian)
{
var a = stream.ReadValueS32(endian);
var b = stream.ReadValueS16(endian);
var c = stream.ReadValueS16(endian);
var d = stream.ReadBytes(8);
return new Guid(a, b, c, d);
}
public static void WriteValueF64(this Stream stream, Double value, Endian endian)
{
byte[] data = ShouldSwap(endian) == true
? BitConverter.GetBytes(BitConverter.DoubleToInt64Bits(value).Swap())
: BitConverter.GetBytes(value);
Debug.Assert(data.Length == 8);
stream.WriteBytes(data);
}
/// <summary>
/// Initializes a new instance of the DataStream class.
/// This will store all PDU information for either an InputStream or OutputStream.
/// </summary>
public DataStream()
{
// Test the machine to determine to see what it supports.
this.endianType = (BitConverter.IsLittleEndian ? Endian.Little : Endian.Big);
// create a new MemoryStream
this.Stream = new MemoryStream();
}
internal static bool ShouldSwap(Endian endian)
{
switch (endian)
{
case Endian.Little: return BitConverter.IsLittleEndian == false;
case Endian.Big: return BitConverter.IsLittleEndian == true;
default: throw new ArgumentException("unsupported endianness", "endian");
}
}
public static void WriteValueGuid(this Stream stream, Guid value, Endian endian)
{
var data = value.ToByteArray();
Debug.Assert(data.Length == 16);
stream.WriteValueS32(BitConverter.ToInt32(data, 0), endian);
stream.WriteValueS16(BitConverter.ToInt16(data, 4), endian);
stream.WriteValueS16(BitConverter.ToInt16(data, 6), endian);
stream.Write(data, 8, 8);
}
public static bool NeedToSwapBytes(Endian endian)
{
if (BitConverter.IsLittleEndian)
{
return Endian.Little != endian;
}
return Endian.Big != endian;
}
/// <summary>
/// Initializes a new instance of the <see cref="EndianStream"/> class.
/// </summary>
/// <param name="stream">The stream to read from and write to.</param>
/// <param name="endianness">The initial endianness to use when operating on the stream.</param>
/// <exception cref="System.ArgumentException">Thrown if <paramref name="stream"/> is not both readable and writable.</exception>
public EndianStream(Stream stream, Endian endianness)
{
if (!stream.CanRead || !stream.CanWrite)
throw new ArgumentException("The input stream must be both readable and writable.");
_stream = stream;
_reader = new EndianReader(stream, endianness);
_writer = new EndianWriter(stream, endianness);
}
/// <summary>
/// Reads a 4-byte unsigned integer from the current stream using provided endian and advances the
/// position of the stream by four bytes.
/// </summary>
/// <param name="reader"></param>
/// <param name="endian">Endian of binary stream.</param>
/// <returns></returns>
public static uint ReadUInt32(this BinaryReader reader, Endian endian)
{
if(endian == Endian.SmallEndian)
return reader.ReadUInt32();
var buffer = new byte[4];
reader.Read(buffer, 0, 4);
return BitConverter.ToUInt32(buffer.Reverse().ToArray(), 0);
}
/// <summary>
/// Reads a 2-byte signed integer from the current stream using privded endian and advances the current
/// position of the stream by two bytes.
/// </summary>
/// <param name="reader"></param>
/// <param name="endian">Endian of binary stream.</param>
/// <returns></returns>
public static short ReadInt16(this BinaryReader reader, Endian endian)
{
if(endian == Endian.SmallEndian)
return reader.ReadInt16();
var buffer = new byte[2];
reader.Read(buffer, 0, 2);
return BitConverter.ToInt16(buffer.Reverse().ToArray(), 0);
}
/// <summary>
/// Attempts to read the specified T. If this system is
/// doesn't match the specified endian, then this will reverse the array of bytes,
/// so that it corresponds with the big-endian format.
/// </summary>
/// <param name="stream">The stream to read the value from</param>
/// <param name="endian">Specifies what endian property should be used.</param>
/// <returns>The integer value</returns>
public static int ReadInt32(this Stream stream, Endian endian)
{
byte[] val = new byte[4];
stream.Read(val, 0, 4);
if ((endian == Endian.LittleEndian) != BitConverter.IsLittleEndian)
{
Array.Reverse(val);
}
return BitConverter.ToInt32(val, 0);
}
public override bool OnInitialize()
{
_major = CommonHeader->VersionMajor;
_minor = CommonHeader->VersionMinor;
_tag = CommonHeader->_tag;
_length = CommonHeader->_length;
_endian = CommonHeader->Endian;
return false;
}
public MemoryDomainDelegate(string name, long size, Endian endian, Func<long, byte> peek, Action<long, byte> poke, int wordSize)
{
Name = name;
EndianType = endian;
Size = size;
_peek = peek;
_poke = poke;
Writable = poke != null;
WordSize = wordSize;
}
public static ushort ToUInt16(byte[] buffer, int startIndex = 0, Endian endian = Endian.Big) {
if (endian == Endian.Little) {
return (ushort)(buffer[startIndex + 1] << 8 |
buffer[startIndex + 0]);
}
else {
return (ushort)(buffer[startIndex + 0] << 8 |
buffer[startIndex + 1]);
}
}
public static void FromUInt16(ushort value, byte[] buffer, int startIndex = 0, Endian endian = Endian.Big) {
if(endian == Endian.Little) {
buffer[startIndex + 1] = (byte)((value >> 8) & 0xff);
buffer[startIndex + 0] = (byte)(value & 0xff);
}
else {
buffer[startIndex + 0] = (byte)((value >> 8) & 0xff);
buffer[startIndex + 1] = (byte)(value & 0xff);
}
}
/// <summary>
/// Usage: using(var myFile = FileSystem.LoadFile("relativePath")) { // Do stuff with myFile }
///
/// Returns a EndianBinaryReader (of specified endian-ness) which contains the specified file. This
/// function will eventually be Folder vs. ISO agnostic.
/// </summary>
/// <param name="relativeFilePath">Relative to the root dir of the WindWaker ISO extract.</param>
/// <param name="endian">Endian-ness of the file to load.</param>
public static EndianBinaryReader LoadFileRelative(string relativeFilePath, Endian endian)
{
if (string.IsNullOrEmpty(Settings.Default.rootDiskDir))
throw new SettingsPropertyNotFoundException("Root Disk Dir not configured, cannot retrieve local file.");
string combinedFilePath = Path.Combine(Settings.Default.rootDiskDir, relativeFilePath);
if (!File.Exists(combinedFilePath))
throw new FileNotFoundException("Requested local file not found.", combinedFilePath);
return new EndianBinaryReader(File.Open(combinedFilePath, FileMode.Open, FileAccess.Read), endian);
}
/// <summary>
/// Constructs a new EndianStream based off of a Stream object.
/// </summary>
/// <param name="stream">The Stream to use. It must at least be available for reading or writing.</param>
/// <param name="endianness">The endianness to use when performing I/O operations.</param>
public EndianStream(Stream stream, Endian endianness)
{
_stream = stream;
if (stream.CanRead)
_reader = new EndianReader(stream, endianness);
if (stream.CanWrite)
_writer = new EndianWriter(stream, endianness);
if (_reader == null && _writer == null)
throw new ArgumentException("The input stream cannot be read from or written to.");
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="stream">The <see cref="Stream"/> to wrap within this EndianBinaryReader.</param>
/// <param name="encoding">The <see cref="Encoding"/> to use for characters.</param>
/// <param name="leaveOpen">Whether or not to leave the stream open after this EndianBinaryReader is disposed.</param>
/// <param name="endian">The <see cref="Endian"/> to use when reading from files.</param>
public EndianBinaryReader(Stream stream, Encoding encoding, bool leaveOpen, Endian endian) : base(stream, encoding, leaveOpen)
{
CurrentEndian = endian;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="data">Data to encapsulate</param>
/// <param name="encoding">The <see cref="Encoding"/> to use for characters.</param>
/// <param name="endian"><see cref="Endian"/> to use when reading the data.</param>
public EndianBinaryReader(byte[] data, Encoding encoding, Endian endian)
: base(new MemoryStream(data), encoding)
{
CurrentEndian = endian;
}
public void Deserialize(IBlock parent, Stream input, Endian endian)
{
}
/// <summary>
/// Initializes an instance of the <see cref="EndianBinaryReader"/> class.
/// </summary>
/// <param name="input">Stream from which to read.</param>
/// <param name="encoding">Encoding of the <paramref name="input"/>.</param>
/// <param name="endian">Endianness of the <paramref name="input"/>. Default values is <c>Endian.Little</c></param>
public EndianBinaryReader(Stream input, Encoding encoding, Endian endian = Endian.Little)
: base(input, encoding)
{
Endian = endian;
}
public void Deserialize(Stream input, Endian endian, StringTable strings)
{
this.R = input.ReadValueF32(endian);
this.G = input.ReadValueF32(endian);
this.B = input.ReadValueF32(endian);
}
public AnimIdentifier(Stream stream, Endian endianness = Endian.LittleEndian) : base(stream, endianness)
{
}
public void Deserialize(Stream input)
{
input.Seek(0, SeekOrigin.Begin);
this.FormatType = input.ReadValueEnum <GFF.FormatType>(Endian.Big);
var version = input.ReadValueU32(Endian.Big);
if (version != 0x56332E32) // 3.2
{
throw new FormatException("unsupported version");
}
this.FileVersion = (byte)(version - 0x56332E32);
var endian = this.Endian = Endian.Little;
var structOffset = input.ReadValueU32(endian);
var structCount = input.ReadValueU32(endian);
var fieldOffset = input.ReadValueU32(endian);
var fieldCount = input.ReadValueU32(endian);
var labelOffset = input.ReadValueU32(endian);
var labelCount = input.ReadValueU32(endian);
var fieldDataOffset = input.ReadValueU32(endian);
var fieldDataSize = input.ReadValueU32(endian);
var fieldIndicesOffset = input.ReadValueU32(endian);
var fieldIndicesSize = input.ReadValueU32(endian);
var listIndicesOffset = input.ReadValueU32(endian);
var listIndicesSize = input.ReadValueU32(endian);
if (structCount < 1)
{
throw new FormatException();
}
// field data
input.Seek(fieldDataOffset, SeekOrigin.Begin);
var data = input.ReadToMemoryStream(fieldDataSize);
// labels
var labels = new string[labelCount];
input.Seek(labelOffset, SeekOrigin.Begin);
for (int i = 0; i < labels.Length; i++)
{
labels[i] = input.ReadString(16, true, Encoding.ASCII);
}
// field indices
if ((fieldIndicesSize % 4) != 0)
{
throw new FormatException();
}
var fieldIndices = new uint[fieldIndicesSize / 4];
input.Seek(fieldIndicesOffset, SeekOrigin.Begin);
for (int i = 0; i < fieldIndices.Length; i++)
{
fieldIndices[i] = input.ReadValueU32(endian);
}
// list indices
if ((listIndicesSize % 4) != 0)
{
throw new FormatException();
}
var listIndices = new uint[listIndicesSize / 4];
input.Seek(listIndicesOffset, SeekOrigin.Begin);
for (int i = 0; i < listIndices.Length; i++)
{
listIndices[i] = input.ReadValueU32(endian);
}
// fields
var fields = new FieldFormat[fieldCount];
input.Seek(fieldOffset, SeekOrigin.Begin);
for (int i = 0; i < fields.Length; i++)
{
fields[i].Type = input.ReadValueEnum <GFF.FieldType>(endian);
fields[i].LabelIndex = input.ReadValueU32(endian);
fields[i].DataOrDataOffset = input.ReadValueU32(endian);
}
// structures
var structs = new GFF.StructureData[structCount];
for (int i = 0; i < structs.Length; i++)
{
structs[i] = new GFF.StructureData();
}
input.Seek(structOffset, SeekOrigin.Begin);
for (int i = 0; i < structs.Length; i++)
{
var structData = structs[i];
var structFormat = new StructFormat();
structData.Type = input.ReadValueU32(endian);
if (i == 0 && structData.Type != 0xFFFFFFFF)
{
throw new FormatException();
}
structFormat.DataOrDataOffset = input.ReadValueU32(endian);
structFormat.FieldCount = input.ReadValueU32(endian);
var indices = new uint[structFormat.FieldCount];
if (structFormat.FieldCount == 1)
{
indices[0] = structFormat.DataOrDataOffset;
}
else
{
if ((structFormat.DataOrDataOffset % 4) != 0)
{
throw new FormatException();
}
uint baseIndex = structFormat.DataOrDataOffset / 4;
for (uint j = 0; j < structFormat.FieldCount; j++)
{
indices[j] = fieldIndices[baseIndex + j];
}
}
var _input = input;
input = null;
foreach (var index in indices)
{
var fieldData = new GFF.FieldData();
var fieldFormat = fields[index];
var label = labels[fieldFormat.LabelIndex];
fieldData.Type = fieldFormat.Type;
switch (fieldFormat.Type)
{
case GFF.FieldType.UInt8:
{
fieldData.Value = (byte)fieldFormat.DataOrDataOffset;
break;
}
case GFF.FieldType.Int8:
{
fieldData.Value = (sbyte)((byte)fieldFormat.DataOrDataOffset);
break;
}
case GFF.FieldType.UInt16:
{
fieldData.Value = (ushort)fieldFormat.DataOrDataOffset;
break;
}
case GFF.FieldType.Int16:
{
fieldData.Value = (short)((ushort)fieldFormat.DataOrDataOffset);
break;
}
case GFF.FieldType.UInt32:
{
fieldData.Value = (uint)fieldFormat.DataOrDataOffset;
break;
}
case GFF.FieldType.Int32:
{
fieldData.Value = (int)fieldFormat.DataOrDataOffset;
break;
}
case GFF.FieldType.UInt64:
{
if (fieldFormat.DataOrDataOffset + 8 > data.Length)
{
throw new FormatException();
}
data.Seek(fieldFormat.DataOrDataOffset, SeekOrigin.Begin);
fieldData.Value = data.ReadValueU64(endian);
break;
}
case GFF.FieldType.Int64:
{
if (fieldFormat.DataOrDataOffset + 8 > data.Length)
{
throw new FormatException();
}
data.Seek(fieldFormat.DataOrDataOffset, SeekOrigin.Begin);
fieldData.Value = data.ReadValueS64(endian);
break;
}
case GFF.FieldType.Single:
{
fieldData.Value = BitConverter.ToSingle(BitConverter.GetBytes(fieldFormat.DataOrDataOffset), 0);
break;
}
case GFF.FieldType.Double:
{
if (fieldFormat.DataOrDataOffset + 8 > data.Length)
{
throw new FormatException();
}
data.Seek(fieldFormat.DataOrDataOffset, SeekOrigin.Begin);
fieldData.Value = data.ReadValueF64(endian);
break;
}
case GFF.FieldType.String:
{
if (fieldFormat.DataOrDataOffset + 4 > data.Length)
{
throw new FormatException();
}
data.Seek(fieldFormat.DataOrDataOffset, SeekOrigin.Begin);
var length = data.ReadValueU32();
if (fieldFormat.DataOrDataOffset + 4 + length > fieldDataOffset)
{
throw new FormatException();
}
fieldData.Value = data.ReadString(length, true, Encoding.ASCII);
break;
}
case GFF.FieldType.Resource:
{
if (fieldFormat.DataOrDataOffset + 1 > data.Length)
{
throw new FormatException();
}
data.Seek(fieldFormat.DataOrDataOffset, SeekOrigin.Begin);
var length = data.ReadValueU8();
if (fieldFormat.DataOrDataOffset + 1 + length > data.Length)
{
throw new FormatException();
}
fieldData.Value = data.ReadString(length, true, Encoding.ASCII);
break;
}
case GFF.FieldType.LocalizedString:
{
if (fieldFormat.DataOrDataOffset + 4 + 8 > data.Length)
{
throw new FormatException();
}
data.Seek(fieldFormat.DataOrDataOffset, SeekOrigin.Begin);
var size = data.ReadValueU32();
if (fieldFormat.DataOrDataOffset + 4 + size > data.Length)
{
throw new FormatException();
}
var loc = new GFF.LocalizedString();
loc.Id = data.ReadValueU32(endian);
var count = data.ReadValueU32(endian);
for (uint j = 0; j < count; j++)
{
var id = data.ReadValueS32(endian);
var length = data.ReadValueU32();
loc.Strings.Add(id, data.ReadString(length, true, Encoding.ASCII));
}
fieldData.Value = loc;
break;
}
case GFF.FieldType.Void:
{
throw new NotSupportedException();
}
case GFF.FieldType.Structure:
{
throw new NotSupportedException();
}
case GFF.FieldType.List:
{
if ((fieldFormat.DataOrDataOffset % 4) != 0)
{
throw new FormatException();
}
var baseIndex = fieldFormat.DataOrDataOffset / 4;
var list = new List <GFF.StructureData>();
var count = listIndices[baseIndex];
for (uint j = 0; j < count; j++)
{
list.Add(structs[listIndices[baseIndex + 1 + j]]);
}
fieldData.Value = list;
break;
}
}
structData.Fields.Add(label, fieldData);
}
input = _input;
}
this.Root = structs[0];
}
public UnknownData1(Stream stream, Endian endianness = Endian.LittleEndian) : base(stream, endianness)
{
}
void PropertyContainerFile.IRawVariant.Serialize(Stream output, Endian endian)
{
FileFormats.Vector3.Write(output, this._Value, endian);
}
void PropertyContainerFile.IRawVariant.Deserialize(Stream input, Endian endian)
{
this._Value = FileFormats.Vector3.Read(input, endian);
}
public void ReadScene(HeaderCommands.Rooms forcerooms = null)
{
Program.Status.Message = string.Format("Reading scene '{0}'...", Name);
ROM.SegmentMapping.Remove((byte)0x02);
ROM.SegmentMapping.Add((byte)0x02, data);
sceneHeaders = new List <HeaderLoader>();
HeaderLoader newheader = null;
HeaderCommands.Rooms rooms = null;
HeaderCommands.Collision coll = null;
if (data[0] == (byte)HeaderLoader.CommandTypeIDs.SettingsSoundScene || data[0] == (byte)HeaderLoader.CommandTypeIDs.Rooms ||
BitConverter.ToUInt32(data, 0) == (byte)HeaderLoader.CommandTypeIDs.SubHeaders)
{
/* Get rooms & collision command from first header */
newheader = new HeaderLoader(ROM, this, 0x02, 0, 0);
/* If external rooms should be forced, overwrite command in header */
if (forcerooms != null)
{
int roomidx = newheader.Commands.FindIndex(x => x.Command == HeaderLoader.CommandTypeIDs.Rooms);
if (roomidx != -1)
{
newheader.Commands[roomidx] = forcerooms;
}
}
rooms = newheader.Commands.FirstOrDefault(x => x.Command == HeaderLoader.CommandTypeIDs.Rooms) as HeaderCommands.Rooms;
coll = newheader.Commands.FirstOrDefault(x => x.Command == HeaderLoader.CommandTypeIDs.Collision) as HeaderCommands.Collision;
sceneHeaders.Add(newheader);
if (BitConverter.ToUInt32((byte[])ROM.SegmentMapping[(byte)0x02], 0) == 0x18)
{
int hnum = 1;
uint aofs = Endian.SwapUInt32(BitConverter.ToUInt32((byte[])ROM.SegmentMapping[(byte)0x02], 4));
while (true)
{
uint rofs = Endian.SwapUInt32(BitConverter.ToUInt32((byte[])ROM.SegmentMapping[(byte)0x02], (int)(aofs & 0x00FFFFFF)));
if (rofs != 0)
{
if ((rofs & 0x00FFFFFF) > ((byte[])ROM.SegmentMapping[(byte)0x02]).Length || (rofs >> 24) != 0x02)
{
break;
}
newheader = new HeaderLoader(ROM, this, 0x02, (int)(rofs & 0x00FFFFFF), hnum++);
/* Get room command index... */
int roomidx = newheader.Commands.FindIndex(x => x.Command == HeaderLoader.CommandTypeIDs.Rooms);
/* If external rooms should be forced, overwrite command in header */
if (roomidx != -1 && forcerooms != null)
{
newheader.Commands[roomidx] = forcerooms;
}
/* If rooms were found in first header, force using these! */
if (roomidx != -1 && rooms != null)
{
newheader.Commands[roomidx] = rooms;
}
/* If collision was found in header, force */
int collidx = newheader.Commands.FindIndex(x => x.Command == HeaderLoader.CommandTypeIDs.Collision);
if (collidx != -1 && coll != null)
{
newheader.Commands[collidx] = coll;
}
sceneHeaders.Add(newheader);
}
aofs += 4;
}
}
currentSceneHeader = sceneHeaders[0];
}
}
public void Write(Stream output, Endian endian)
{
Write(output, this, endian);
}
public CollectionParameter(Endian endian)
{
_endian = endian;
}
/// <summary>
/// Initializes an instance of the <see cref="EndianBinaryReader"/> class.
/// </summary>
/// <param name="input">Stream from which to read.</param>
/// <param name="endian">Endianness of the <paramref name="input"/>. Default values is <c>Endian.Little</c></param>
public EndianBinaryReader(Stream input, Endian endian = Endian.Little)
: base(input)
{
Endian = endian;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="stream">The <see cref="Stream"/> to wrap within this EndianBinaryReader.</param>
/// <param name="encoding">The <see cref="Encoding"/> to use for characters.</param>
/// <param name="endian">The <see cref="Endian"/> to use when reading files.</param>
public EndianBinaryReader(Stream stream, Encoding encoding, Endian endian) : base(stream, encoding)
{
CurrentEndian = endian;
}
/// <summary>
/// Constructor. Uses UTF-8 by default for character encoding.
/// </summary>
/// <param name="stream">The <see cref="Stream"/> to wrap within this EndianBinaryReader.</param>
/// <param name="endian">The <see cref="Endian"/> to use when reading files..</param>
public EndianBinaryReader(Stream stream, Endian endian) : base(stream)
{
CurrentEndian = endian;
}
public void Deserialize(Stream input)
{
var magic = input.ReadValueU32();
if (magic != 0xBEEFFEED)
{
throw new FormatException("not an asm file");
}
var endian = magic == 0xBEEFFEED ? Endian.Little : Endian.Big;
var version = input.ReadValueU16(endian);
if (version != 11)
{
throw new FormatException("unsupported asm version " + this._Version);
}
var containerCount = input.ReadValueU16();
var allocatorTypeCount = version < 8 ? 0 : input.ReadValueU32(endian);
var allocatorTypes = new Asm.TypeId[allocatorTypeCount];
for (uint i = 0; i < allocatorTypeCount; i++)
{
var name = input.ReadStringU16(0x40, Encoding.ASCII, endian);
var id = input.ReadValueU8();
allocatorTypes[i] = new Asm.TypeId(name, id);
}
var primitiveTypeCount = version < 8 ? 0 : input.ReadValueU32(endian);
var primitiveTypes = new Asm.TypeId[allocatorTypeCount];
for (uint i = 0; i < primitiveTypeCount; i++)
{
var name = input.ReadStringU16(0x40, Encoding.ASCII, endian);
var id = input.ReadValueU8();
primitiveTypes[i] = new Asm.TypeId(name, id);
}
var containerTypeCount = version < 8 ? 0 : input.ReadValueU32(endian);
var containerTypes = new Asm.TypeId[allocatorTypeCount];
for (uint i = 0; i < containerTypeCount; i++)
{
var name = input.ReadStringU16(0x40, Encoding.ASCII, endian);
var id = input.ReadValueU8();
containerTypes[i] = new Asm.TypeId(name, id);
}
var containers = new Asm.ContainerEntry[containerCount];
for (ushort i = 0; i < containerCount; i++)
{
var container = new Asm.ContainerEntry();
container.Deserialize(input, this._Version, endian);
containers[i] = container;
}
this._Endian = endian;
this._Version = version;
this._AllocatorTypes.Clear();
this._AllocatorTypes.AddRange(allocatorTypes);
this._PrimitiveTypes.Clear();
this._PrimitiveTypes.AddRange(primitiveTypes);
this._ContainerTypes.Clear();
this._ContainerTypes.AddRange(containerTypes);
this._Containers.Clear();
this._Containers.AddRange(containers);
}
public BlamScriptGenerator(ScriptTable scripts, OpcodeLookup opcodes, Endian endian)
{
_endian = endian;
_scripts = scripts;
_opcodes = opcodes;
}
// llllllll llllllll llllllll llllllll
// iiiiiiii iiiiiiii iiiiiiii iiiiiiii
// uuuuuuuu uuuuuuuu uuuuuuuu uuuuuuss
// ???????? ???????? ???????? ????????
// oocccccc cccccccc cccccccc cccccccc
// oooooooo oooooooo oooooooo oooooooo
// [l] lower 32 bits of hash = 32 bits
// [i] upper 32 bits of hash = 32 bits
// [s] compression scheme = 2 bits
// [u] uncompressed size = 30 bits
// [?] unknown = 32 bits
// [o] offset = 34 bits
// [c] compressed size = 30 bits
public void Serialize(Stream output, Entry entry, Endian endian)
{
throw new NotImplementedException();
}
public void Deserialize(Stream input)
{
const Endian endian = Endian.Little;
var unknownType1 = new type1 {
unknown1 = new type2[input.ReadValueU32(endian)]
}; //count
for (uint i = 0; i < unknownType1.unknown1.Length; i++)
{
var unknownType2 = new type2
{
unknown1 = input.ReadValueU32(endian), //unknown0
unknown2 = ReadString(input, endian), //unknown1
unknown3 = new type3[input.ReadValueU32(endian)] //unknown2
};
for (uint j = 0; j < unknownType2.unknown3.Length; j++)
{
unknownType2.unknown3[j] = new type3
{
unknown1 = input.ReadValueU32(endian), //unknown3
unknown2 = ReadString(input, endian) //unknown4
};
}
unknownType2.unknown4 = new type4[input.ReadValueU32(endian)]; //unknown5
for (uint j = 0; j < unknownType2.unknown4.Length; j++)
{
unknownType2.unknown4[j] = new type4
{
unknown1 = input.ReadValueU32(endian), //unknown6
unknown2 = input.ReadValueU32(endian), //unknown7
unknown3 = ReadString(input, endian) //unknown8
};
}
unknownType2.unknown5 = new type5[input.ReadValueU32(endian)]; //unknown9
for (uint j = 0; j < unknownType2.unknown5.Length; j++)
{
unknownType2.unknown5[j] = new type5
{
unknown1 = input.ReadValueU32(endian), //unknown10
unknown2 = ReadString(input, endian) //unknown11
};
}
unknownType2.unknown6 = new type6[input.ReadValueU32(endian)]; //unknown12
for (uint j = 0; j < unknownType2.unknown6.Length; j++)
{
unknownType2.unknown6[j] = new type6
{
unknown1 = input.ReadValueU32(endian), //unknown13
unknown2 = ReadString(input, endian) //unknown14
};
}
unknownType2.unknown7 = ReadString(input, endian); //unknown15
unknownType2.unknown8 = new type7[input.ReadValueU32(endian)]; //unknown16
for (uint j = 0; j < unknownType2.unknown8.Length; j++)
{
var unknownType7 = new type7
{
unknown1 = ReadString(input, endian), //unknown17
unknown2 = input.ReadValueU32(endian), //unknown18
unknown3 = input.ReadValueU8(), //unknown19
unknown4 = new type8[input.ReadValueU32(endian)] //unknown20
};
for (uint k = 0; k < unknownType7.unknown4.Length; k++)
{
unknownType7.unknown4[k] = new type8
{
unknown1 = input.ReadValueF32(endian), //unknown21
unknown2 = input.ReadValueF32(endian), //unknown22
unknown3 = input.ReadValueF32(endian), //unknown23
unknown4 = input.ReadValueF32(endian), //unknown24
unknown5 = input.ReadValueU32(endian), //unknown25
unknown6 = input.ReadValueU8(), //unknown26
unknown7 = input.ReadValueF32(endian), //unknown27
unknown8 = input.ReadValueF32(endian), //unknown28
unknown9 = input.ReadValueF32(endian), //unknown29
unknown10 = input.ReadValueF32(endian), //unknown30
unknown11 = input.ReadValueU32(endian), //unknown31
unknown12 = input.ReadValueU32(endian), //unknown32
unknown13 = input.ReadValueU32(endian), //unknown33
unknown14 = input.ReadValueU32(endian), //unknown34
unknown15 = input.ReadValueU8() //unknown35
};
}
unknownType7.unknown5 = new type9[input.ReadValueU32(endian)]; //unknown36
for (uint k = 0; k < unknownType7.unknown5.Length; k++)
{
var unknownType9 = new type9
{
unknown1 = input.ReadValueU32(endian), //unknown37
unknown2 = input.ReadValueU8(), //unknown38
unknown3 = new type10[input.ReadValueU32(endian)] //unknown39
};
for (uint l = 0; l < unknownType9.unknown3.Length; l++)
{
unknownType9.unknown3[l] = new type10
{
unknown1 = input.ReadValueF32(endian), //unknown40
unknown2 = input.ReadValueF32(endian), //unknown41
unknown3 = input.ReadValueF32(endian), //unknown42
unknown4 = input.ReadValueF32(endian), //unknown43
unknown5 = input.ReadValueF32(endian), //unknown44
unknown6 = input.ReadValueF32(endian), //unknown45
unknown7 = input.ReadValueF32(endian), //unknown46
unknown8 = input.ReadValueF32(endian), //unknown47
unknown9 = input.ReadValueF32(endian), //unknown48
unknown10 = input.ReadValueF32(endian), //unknown49
unknown11 = input.ReadValueU32(endian), //unknown50
unknown12 = input.ReadValueU8(), //unknown51
unknown13 = input.ReadValueF32(endian), //unknown52
unknown14 = input.ReadValueF32(endian), //unknown53
unknown15 = input.ReadValueF32(endian), //unknown54
unknown16 = input.ReadValueF32(endian), //unknown55
unknown17 = input.ReadValueF32(endian), //unknown56
unknown18 = input.ReadValueF32(endian), //unknown57
unknown19 = input.ReadValueF32(endian), //unknown58
unknown20 = input.ReadValueF32(endian), //unknown59
unknown21 = input.ReadValueU8() //unknown60
};
}
unknownType7.unknown5 [k] = unknownType9;
}
unknownType7.unknown6 = new type11[input.ReadValueU32(endian)]; //unknown61
for (uint k = 0; k < unknownType7.unknown6.Length; k++)
{
var unknownType11 = new type11
{
unknown1 = input.ReadValueU32(endian), //unknown62
unknown2 = input.ReadValueU8(), //unknown63
unknown3 = new type8[input.ReadValueU32(endian)] //unknown64
};
for (uint l = 0; l < unknownType11.unknown3.Length; l++)
{
unknownType11.unknown3[l] = new type8
{
unknown1 = input.ReadValueF32(endian), //unknown21
unknown2 = input.ReadValueF32(endian), //unknown22
unknown3 = input.ReadValueF32(endian), //unknown23
unknown4 = input.ReadValueF32(endian), //unknown24
unknown5 = input.ReadValueU32(endian), //unknown25
unknown6 = input.ReadValueU8(), //unknown26
unknown7 = input.ReadValueF32(endian), //unknown27
unknown8 = input.ReadValueF32(endian), //unknown28
unknown9 = input.ReadValueF32(endian), //unknown29
unknown10 = input.ReadValueF32(endian), //unknown30
unknown11 = input.ReadValueU32(endian), //unknown31
unknown12 = input.ReadValueU32(endian), //unknown32
unknown13 = input.ReadValueU32(endian), //unknown33
unknown14 = input.ReadValueU32(endian), //unknown34
unknown15 = input.ReadValueU8() //unknown35
};
}
unknownType7.unknown6 [k] = unknownType11;
}
unknownType7.unknown7 = new type13[input.ReadValueU32(endian)]; //unknown65
for (uint k = 0; k < unknownType7.unknown7.Length; k++)
{
unknownType7.unknown7[k] = new type13
{
unknown1 = input.ReadValueU32(endian), //unknown66
unknown2 = input.ReadValueU32(endian) //unknown67
};
}
unknownType2.unknown8 [j] = unknownType7;
}
unknownType1.unknown1 [i] = unknownType2;
}
this.result = unknownType1;
}
public void Serialize(IBlock parent, Stream output, Endian endian)
{
}
internal void WriteGlobalConfig(Encoding encoding, Endian endian)
{
WriteByte((byte)(((int)encoding << 4) | (int)endian));
}
///<summary>
/// Creates a BinaryReader backed by a file (RO)
///</summary>
/// <param name="file"></param>
/// <param name="endian"></param>
public EndianBinaryReader(string file, Endian endian = Endian.Little) : base(File.Open(file, FileMode.Open, FileAccess.Read, FileShare.Read))
{
Endian = endian;
}
