public override void OnRebuild(VoidPtr address, int length, bool force)
{
U8 *header = (U8 *)address;
header->_tag = U8.Tag;
header->_entriesLength = (uint)entryLength;
header->_entriesOffset = 0x20;
VoidPtr dataAddress = address + 0x20 + entryLength.Align(0x20);
U8Entry *entries = (U8Entry *)(address + 0x20);
VoidPtr tableAddr = address + 0x20 + _entrySize;
_stringTable.WriteTable(tableAddr);
header->_firstOffset = (uint)(dataAddress - address);
entries->_dataLength = (uint)(_entrySize / 12);
entries->_type = 1;
entries++;
foreach (U8EntryNode b in Children)
{
RebuildNode(address, b, ref entries, tableAddr, ref dataAddress, force);
}
}
public void RebuildNode(VoidPtr header, U8EntryNode node, ref U8Entry *entry, VoidPtr sTableStart, ref VoidPtr dataAddr, U8StringTable sTable, bool force)
{
entry->_type = (byte)((node is U8FolderNode) ? 1 : 0);
entry->_stringOffset.Value = (int)sTable[node.Name] - (int)sTableStart;
if (entry->_type == 1)
{
if (node.Parent != this && node.Parent != null)
{
entry->_dataOffset = (uint)(node.Parent as U8EntryNode).index;
}
(entry++)->_dataLength = (uint)(node.index + node.Children.Count + 1);
foreach (ResourceNode b in node.Children)
{
if (b is U8EntryNode)
{
RebuildNode(header, b as U8EntryNode, ref entry, sTableStart, ref dataAddr, table, force);
}
}
}
else
{
node.Rebuild(dataAddr, node._calcSize, force);
entry->_dataOffset = (uint)dataAddr - (uint)header;
(entry++)->_dataLength = (uint)node._calcSize.Align(0x10);
dataAddr += node._calcSize.Align(0x20);
}
}
private void RebuildNode(VoidPtr header, U8EntryNode node, ref U8Entry *entry, VoidPtr sTableStart, ref VoidPtr dataAddr, bool force)
{
entry->_type = (byte)((node is U8FolderNode) ? 1 : 0);
entry->_stringOffset.Value = (uint)_stringTable[node.Name] - (uint)sTableStart;
if (entry->_type == 1)
{
int index = node.Index + 1, parentIndex = 0, endIndex = _entrySize / 12;
if (node.Parent != this && node.Parent != null)
{
parentIndex = ((U8EntryNode)node.Parent)._u8Index;
}
if (index < node.Parent.Children.Count)
{
endIndex = (node.Parent.Children[index] as U8EntryNode)._u8Index;
}
entry->_dataLength = (uint)endIndex;
entry->_dataOffset = (uint)parentIndex;
entry++;
foreach (ResourceNode b in node.Children)
{
if (b is U8EntryNode)
{
RebuildNode(header, b as U8EntryNode, ref entry, sTableStart, ref dataAddr, force);
}
}
}
else
{
entry->_dataOffset = (uint)dataAddr - (uint)header;
entry->_dataLength = (uint)node._calcSize;
entry++;
node.Rebuild(dataAddr, node._calcSize, force);
dataAddr += node._calcSize.Align(0x20);
}
}
public override void OnPopulate()
{
U8Entry * first = Header->Entries;
uint count = first->_dataLength - 1;
U8Entry * entry = first + 1;
sbyte * table = (sbyte *)entry + count * 12;
List <U8EntryNode> nodes = new List <U8EntryNode>();
U8EntryNode e = null;
for (int i = 0; i < count; i++)
{
if (entry->isFolder)
{
e = new U8FolderNode()
{
_u8Index = i, _name = new String(table + (int)entry->_stringOffset)
};
e._name = new String(table + (int)entry->_stringOffset);
e._u8Index = i;
e._u8Parent = (int)entry->_dataOffset;
e._u8FirstNotChild = (int)entry->_dataLength;
e._u8Type = (int)entry->_type;
e.Initialize(this, entry, 12);
nodes.Add(e);
}
else
{
DataSource source = new DataSource((VoidPtr)Header + entry->_dataOffset, (int)entry->_dataLength);
if ((entry->_dataLength == 0) || (e = NodeFactory.FromSource(this, source) as U8EntryNode) == null)
{
e = new ARCEntryNode();
}
e._name = new String(table + (int)entry->_stringOffset);
e._u8Index = i;
e._u8Parent = -1;
e._u8FirstNotChild = -1;
e._u8Type = (int)entry->_type;
e.Initialize(this, source);
nodes.Add(e);
}
entry++;
}
foreach (U8EntryNode x in nodes)
{
if (x._u8Type == 1)
{
if (x._u8Parent == 0)
{
x.Parent = this;
}
else if (x._u8Parent < nodes.Count)
{
x.Parent = nodes[x._u8Parent - 1];
}
U8EntryNode t = null;
if (x._u8Index + 1 < nodes.Count)
{
t = nodes[x._u8Index + 1];
}
while (t != null)
{
t.Parent = x;
if (t._u8Index + 1 < nodes.Count && t.ChildEndIndex != nodes[t._u8Index + 1]._u8Index)
{
t = nodes[t._u8Index + 1];
}
else
{
t = null;
}
}
}
}
IsDirty = false; //Clear up changes from parent reassignments
}