private void Build()
{
const int HeaderLengthOffset = 0x08;
const int EntriesOffset = 0x20;
const int EntryLength = 0x08;
const int EntryKeyOffset = 0x00;
const int EntryPositionOffset = 0x04;
var buffer = File.GetData();
var headerLen = OrderedBitConverter.ToInt32(buffer, HeaderLengthOffset, true);
var count = headerLen / EntryLength;
var currentPosition = EntriesOffset;
_Rows = new ConcurrentDictionary <int, T>();
for (var i = 0; i < count; ++i)
{
var key = OrderedBitConverter.ToInt32(buffer, currentPosition + EntryKeyOffset, true);
var off = OrderedBitConverter.ToInt32(buffer, currentPosition + EntryPositionOffset, true);
_RowOffsets.Add(key, off);
//_Rows.Add(key, CreateRow(key, off));
currentPosition += EntryLength;
}
}
public static CharaMakeTypeStruct Read(byte[] buffer)
{
int offset = 0;
CharaMakeTypeStruct cmt = new CharaMakeTypeStruct();
cmt.Looks = new CharaMakeTypeLooksStruct[28];
for (int i = 0; i < 28; i++)
cmt.Looks[i] = CharaMakeTypeLooksStruct.Read(buffer, ref offset);
cmt.Voice = CharaMakeTypeVoiceStruct.Read(buffer, ref offset);
cmt.FaceOption = new CharaMakeTypeFaceOptionStruct[8];
for (int i = 0; i < 8; i++)
cmt.FaceOption[i] = CharaMakeTypeFaceOptionStruct.Read(buffer, ref offset);
offset += 4;
cmt.Equip = new CharaMakeTypeEquipStruct[3];
for (int i = 0; i < 3; i++)
cmt.Equip[i] = CharaMakeTypeEquipStruct.Read(buffer, ref offset);
cmt.Race = OrderedBitConverter.ToInt32(buffer, offset, true);
offset += 4;
cmt.Tribe = OrderedBitConverter.ToInt32(buffer, offset, true);
offset += 4;
cmt.Gender = (sbyte)buffer[offset];
return cmt;
}
byte[] padding; //2?
public static CharaMakeTypeLooksStruct Read(byte[] buffer, ref int offset)
{
CharaMakeTypeLooksStruct cmtl = new CharaMakeTypeLooksStruct();
cmtl.Menu = OrderedBitConverter.ToUInt32(buffer, offset, true);
offset += 4;
cmtl.SubMenuMask = OrderedBitConverter.ToUInt32(buffer, offset, true);
offset += 4;
cmtl.Customize = OrderedBitConverter.ToUInt32(buffer, offset, true);
offset += 4;
cmtl.SubMenuParam = new uint[100];
for (int i = 0; i < 100; i++)
{
cmtl.SubMenuParam[i] = OrderedBitConverter.ToUInt32(buffer, offset, true);
offset += 4;
}
cmtl.InitVal = buffer[offset];
cmtl.SubMenuType = buffer[offset + 1];
cmtl.SubMenuNum = buffer[offset + 2];
cmtl.LookAt = buffer[offset + 3];
offset += 4;
cmtl.SubMenuGraphic = new byte[10];
for (int i = 0; i < 10; i++)
{
cmtl.SubMenuGraphic[i] = buffer[offset];
offset += 1;
}
offset += 2;
return cmtl;
}
/// <summary>
/// Read a column's buffer of a row.
/// </summary>
/// <param name="buffer">A byte-array containing the contents of the EX buffer file.</param>
/// <param name="col"><see cref="Column" /> to read.</param>
/// <param name="row"><see cref="IDataRow" /> to read in.</param>
/// <returns>Returns the value read from the given <c>row</c> and <c>column</c>.</returns>
public override object Read(byte[] buffer, Column col, IDataRow row)
{
var fieldOffset = GetFieldOffset(col, row);
var endOfFixed = row.Offset + row.Sheet.Header.FixedSizeDataLength;
var start = endOfFixed + OrderedBitConverter.ToInt32(buffer, fieldOffset, true);
if (start < 0)
{
return(null);
}
var end = start - 1;
while (++end < buffer.Length && buffer[end] != 0)
{
}
var len = end - start;
if (len == 0)
{
return(Text.XivString.Empty);
}
var binaryString = new byte[len];
Array.Copy(buffer, start, binaryString, 0, len);
return(Text.XivStringDecoder.Default.Decode(binaryString));//.ToString();
}
private void Build()
{
const uint Magic = 0x46485845; // EXHF
const int MinimumLength = 0x2E;
const int FixedSizeDataLengthOffset = 0x06;
const int VariantOffset = 0x10;
const int DataOffset = 0x20;
byte[] buffer = File.GetData();
if (buffer.Length < MinimumLength)
{
throw new InvalidDataException("EXH file is too short");
}
if (OrderedBitConverter.ToUInt32(buffer, 0, false) != Magic)
{
throw new InvalidDataException("File not a EX header");
}
FixedSizeDataLength = OrderedBitConverter.ToUInt16(buffer, FixedSizeDataLengthOffset, true);
Variant = OrderedBitConverter.ToUInt16(buffer, VariantOffset, true);
if (Variant != 1 && Variant != 2)
{
throw new NotSupportedException();
}
int currentPosition = DataOffset;
ReadColumns(buffer, ref currentPosition);
ReadPartialFiles(buffer, ref currentPosition);
ReadSuffixes(buffer, ref currentPosition);
}
public DataRow(IDataSheet sheet, int key, int offset) : base(sheet, key, offset + MetadataLength)
{
byte[] b = sheet.GetBuffer();
if (b.Length < offset + MetadataLength)
{
throw new IndexOutOfRangeException();
}
Length = OrderedBitConverter.ToInt32(b, offset, true);
SubRowCount = OrderedBitConverter.ToInt16(b, offset + 4, true);
}
/// <summary>
/// Initializes a new instance of the <see cref="Column" /> class.
/// </summary>
/// <param name="header">The <see cref="Header" /> of the EX file the column is in.</param>
/// <param name="index">The index of the column inside the EX file.</param>
/// <param name="buffer">A byte-array containing the contents of the header file.</param>
/// <param name="offset">The position of the column information inside <c>buffer</c>.</param>
public Column(Header header, int index, byte[] buffer, int offset)
{
const int TypeOffset = 0x00;
const int PositionOffset = 0x02;
Header = header;
Index = index;
Type = OrderedBitConverter.ToUInt16(buffer, offset + TypeOffset, true);
Offset = OrderedBitConverter.ToUInt16(buffer, offset + PositionOffset, true);
Reader = DataReader.GetReader(Type);
}
int[] Option; //7
public static CharaMakeTypeFaceOptionStruct Read(byte[] buffer, ref int offset)
{
CharaMakeTypeFaceOptionStruct cmtf = new CharaMakeTypeFaceOptionStruct();
cmtf.Option = new int[7];
for (int i = 0; i < 7; i++)
{
cmtf.Option[i] = OrderedBitConverter.ToInt32(buffer, offset, true);
offset += 4;
}
return cmtf;
}
private void ReadColumns(byte[] buffer, ref int position)
{
const int CountOffset = 0x08;
const int Length = 0x04;
ushort count = OrderedBitConverter.ToUInt16(buffer, CountOffset, true);
_Columns = new Column[count];
for (int i = 0; i < count; ++i)
{
_Columns[i] = CreateColumn(i, buffer, position);
position += Length;
}
}
private void ReadSuffixes(byte[] buffer, ref int position)
{
const int CountOffset = 0x0C;
const int Length = 0x02;
var count = OrderedBitConverter.ToUInt16(buffer, CountOffset, true);
var langs = new List <Language>();
for (var i = 0; i < count; ++i)
{
langs.Add(LanguageMap[buffer[position]]);
position += Length;
}
_AvailableLanguages = langs.Where(_ => _ != Language.Unsupported).ToArray();
}
public DataRow(IDataSheet sheet, int key, int offset) : base(sheet, key, offset + MetadataLength)
{
var b = sheet.GetBuffer();
if (b.Length < offset + MetadataLength)
{
throw new IndexOutOfRangeException();
}
Length = OrderedBitConverter.ToInt32(b, offset, true);
var c = OrderedBitConverter.ToInt16(b, offset + 4, true);
if (c != 1)
{
throw new InvalidDataException();
}
}
private void ReadPartialFiles(byte[] buffer, ref int position)
{
const int CountOffset = 0x0A;
const int Length = 0x08;
ushort count = OrderedBitConverter.ToUInt16(buffer, CountOffset, true);
_DataFileRanges = new Range[count];
for (int i = 0; i < count; ++i)
{
int min = OrderedBitConverter.ToInt32(buffer, position + 0x00, true);
int len = OrderedBitConverter.ToInt32(buffer, position + 0x04, true);
_DataFileRanges[i] = new Range(min, len);
position += Length;
}
}
public static CharaMakeTypeEquipStruct Read(byte[] buffer, ref int offset)
{
CharaMakeTypeEquipStruct cmte = new CharaMakeTypeEquipStruct();
cmte.Helmet = OrderedBitConverter.ToUInt64(buffer, offset, true);
offset += 8;
cmte.Top = OrderedBitConverter.ToUInt64(buffer, offset, true);
offset += 8;
cmte.Glove = OrderedBitConverter.ToUInt64(buffer, offset, true);
offset += 8;
cmte.Down = OrderedBitConverter.ToUInt64(buffer, offset, true);
offset += 8;
cmte.Shoes = OrderedBitConverter.ToUInt64(buffer, offset, true);
offset += 8;
cmte.Weapon = OrderedBitConverter.ToUInt64(buffer, offset, true);
offset += 8;
cmte.SubWeapon = OrderedBitConverter.ToUInt64(buffer, offset, true);
offset += 8;
return cmte;
}
private void ReadSuffixes(byte[] buffer, ref int position)
{
const int CountOffset = 0x0C;
const int Length = 0x02;
// ScreenImage and CutScreenImage reference localized image files,
// however their available languages are only None. Perhaps there
// is a flag to use a global list of available languages in this
// buffer?
ushort count = OrderedBitConverter.ToUInt16(buffer, CountOffset, true);
List <Language> langs = new List <Language>();
for (int i = 0; i < count; ++i)
{
langs.Add(LanguageMap[buffer[position]]);
position += Length;
}
_AvailableLanguages = langs.Where(_ => _ != Language.Unsupported).ToArray();
}
protected virtual void Read()
{
_SubRows.Clear();
var h = Sheet.Header;
var b = Sheet.GetBuffer();
var o = Offset;
for (var i = 0; i < SubRowCount; ++i)
{
var key = OrderedBitConverter.ToInt16(b, o, true);
o += 2;
var r = new SubRow(this, key, o);
_SubRows.Add(key, r);
o += h.FixedSizeDataLength;
}
_IsRead = true;
}
/// <summary>
/// Initializes static members of the <see cref="DataReader"/> class.
/// </summary>
/// <remarks>
/// This creates the mappings of type identifiers and <see cref="DataReader"/>s.
/// </remarks>
static DataReader()
{
DataReaders = new Dictionary <int, DataReader> {
{
0x0000, new StringDataReader()
}, {
0x0001, new DelegateDataReader("bool", 1, typeof(bool), (d, o) => d[o] != 0)
}, {
0x0002, new DelegateDataReader("sbyte", 1, typeof(sbyte), (d, o) => (sbyte)d[o])
}, {
0x0003, new DelegateDataReader("byte", 1, typeof(byte), (d, o) => d[o])
}, {
0x0004,
new DelegateDataReader("int16", 2, typeof(short), (d, o) => OrderedBitConverter.ToInt16(d, o, true))
}, {
0x0005,
new DelegateDataReader("uint16", 2, typeof(ushort),
(d, o) => OrderedBitConverter.ToUInt16(d, o, true))
}, {
0x0006,
new DelegateDataReader("int32", 4, typeof(int), (d, o) => OrderedBitConverter.ToInt32(d, o, true))
}, {
0x0007,
new DelegateDataReader("uint32", 4, typeof(uint), (d, o) => OrderedBitConverter.ToUInt32(d, o, true))
}, {
0x0009,
new DelegateDataReader("single", 4, typeof(Single),
(d, o) => OrderedBitConverter.ToSingle(d, o, true))
}, {
0x000B,
new DelegateDataReader("int64", 8, typeof(Quad), (d, o) => Quad.Read(d, o, true))
}
};
for (byte i = 0; i < 8; ++i)
{
DataReaders.Add(0x19 + i, new PackedBooleanDataReader((byte)(1 << i)));
}
}
public static byte[] GetRow(byte[] file, int row)
{
int offset = 0;
//ex header
offset += 32;
//seek to offset in table
for (int i = 0; i < row; i++)
{
offset += 8;
}
offset += 4;
int rowOffset = (int)OrderedBitConverter.ToUInt32(file, offset, true);
uint length = OrderedBitConverter.ToUInt32(file, rowOffset, true);
byte[] rowData = new byte[length];
Array.Copy(file, rowOffset + 6, rowData, 0, length);
return(rowData);
}
protected virtual void Read()
{
_SubRows.Clear();
Header h = Sheet.Header;
byte[] b = Sheet.GetBuffer();
int o = Offset;
for (int i = 0; i < SubRowCount; ++i)
{
short key = OrderedBitConverter.ToInt16(b, o, true);
o += 2;
SubRow r = new SubRow(this, key, o);
_SubRows.Add(key, r);
o += h.FixedSizeDataLength;
}
_IsRead = true;
}
public static Quad Read(byte[] buffer, int offset, bool bigEndian)
{
long data = OrderedBitConverter.ToInt64(buffer, offset, bigEndian);
return(new Quad(data));
}
public static uint GetNumRows(byte[] file)
{
return(OrderedBitConverter.ToUInt32(file, 8, true) / 8);
}
