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 int GetEntrySize(U8EntryNode node, bool force, ref int id)
{
node._u8Index = id++;
_stringTable.Add(node.Name);
_entrySize += 12;
int size = node is U8FolderNode ? 0 : node.CalculateSize(force).Align(0x20);
foreach (ResourceNode r in node.Children)
{
if (r is U8EntryNode)
{
size += GetEntrySize(r as U8EntryNode, force, ref id);
}
}
return(size);
}
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
}
