private static void RecursiveGetClassIDsClasses(ref Dictionary <HavokClassNode, int> classIDs, HavokNode node, ResourceNode e) { if (e is hkClassNode) { hkClassNode type = e as hkClassNode; if (!string.IsNullOrEmpty(type.ParentClass)) { HavokClassNode c = node.GetClassNode(type.ParentClass); classIDs.Add(c, classIDs.Count + 1); } ResourceNode members = type.FindChild("Members", false); foreach (hkClassMemberNode member in members.Children) { if (!string.IsNullOrEmpty(member._class)) { HavokClassNode c = node.GetClassNode(member._class); classIDs.Add(c, classIDs.Count + 1); } if (!string.IsNullOrEmpty(member._enum)) { HavokClassNode c = node.GetClassNode(member._enum); classIDs.Add(c, classIDs.Count + 1); } } if (!classIDs.ContainsKey(type)) { classIDs.Add(type, classIDs.Count + 1); } } }
private void RecursiveGetInheritance(ref List <hkClassNode> i, hkClassNode node) { if (node != null) { foreach (HavokSectionNode section in HavokNode.Children) { if (section._classCache != null && section != HavokNode._dataSection) { foreach (HavokClassNode c in section._classCache) { hkClassNode x = c as hkClassNode; if (x != null && x != this && x.ParentClass == node.Name) { _inheritance.Insert(0, x); RecursiveGetInheritance(ref i, x); } } } } } }
public override void OnPopulate() { HKXHeader * header = (HKXHeader *)_buffer.Address; PhysicsOffsetSection *section = header->OffsetSections; PhysicsOffsetSection *classes = §ion[header->_classNameSectionIndex]; sbyte *classNames = (sbyte *)(_buffer.Address + classes->_dataOffset); VoidPtr dataAddr = classNames; VoidPtr baseAddr = dataAddr; while (dataAddr - baseAddr < classes->DataLength && *(byte *)(dataAddr + 4) == 9) { uint signature = *(buint *)dataAddr; string c = new string((sbyte *)dataAddr + 5); if (!_allSignatures.ContainsKey(c)) { _allSignatures.Add(c, signature); } dataAddr += 5 + c.Length + 1; } //Types have to be parsed first so that they can be used to parse the data last for (int i = 0; i < header->_sectionCount; i++, section++) { if (i == header->_classNameSectionIndex || i == header->_dataSectionIndex) { continue; } int dataOffset = section->_dataOffset; VoidPtr data = _buffer.Address + dataOffset; int classNamePatchLength = section->ClassNamePatchesLength; if (classNamePatchLength > 0) { HavokSectionNode sectionNode = new HavokSectionNode { //sectionNode._name = section->Name; _name = "Classes" }; sectionNode.Initialize(this, data, section->DataLength); //HavokGroupNode classGroup = new HavokGroupNode() { _parent = sectionNode, _name = "Classes" }; //sectionNode.Children.Add(classGroup); //HavokGroupNode enumGroup = new HavokGroupNode() { _parent = sectionNode, _name = "Enums" }; //sectionNode.Children.Add(enumGroup); VoidPtr start = data + section->_classNamePatchesOffset; ClassNamePatch *patch = (ClassNamePatch *)start; int x = 0; while ((int)patch - (int)start < classNamePatchLength && patch->_dataOffset >= 0) { string className = new string(classNames + patch->_classNameOffset); uint signature = *(buint *)(classNames + (patch->_classNameOffset - 5)); if (!_mainTypeSignatures.ContainsKey(className)) { _mainTypeSignatures.Add(className, signature); } HavokClassNode entry = GetClassNode(className, false); if (entry != null) { entry._signature = signature; entry._className = className; entry.Initialize(sectionNode, data + patch->_dataOffset, 0); } patch++; x++; } sectionNode._classCache = sectionNode._children.Select(b => b as HavokClassNode).ToList(); if (AssignClassParents) { sectionNode._children.Clear(); for (int r = 0; r < sectionNode._classCache.Count; r++) { HavokClassNode n = sectionNode._classCache[r]; if (n == null) { continue; } n.Populate(0); n._parent = sectionNode; if (n is hkClassNode) { hkClassNode c = n as hkClassNode; if (!string.IsNullOrEmpty(c.ParentClass)) { for (int w = 0; w < sectionNode._classCache.Count; w++) { HavokClassNode n2 = sectionNode._classCache[w]; if (w != r && n2 is hkClassNode && n2.Name == c.ParentClass) { n._parent = n2; } } } } } foreach (HavokClassNode n in sectionNode._classCache) { if (n == null) { continue; } if (n._parent._children == null) { n._parent._children = new List <ResourceNode>(); } n._parent._children.Add(n); } } foreach (HavokClassNode classNode in sectionNode._classCache) { if (classNode is hkClassNode) { hkClassNode c = classNode as hkClassNode; c.GetInheritance(); } } } } //Parse data using class types, unless the data is explicitly supported if (header->_dataSectionIndex >= 0) { section = &header->OffsetSections[header->_dataSectionIndex]; int dataOffset = section->_dataOffset; VoidPtr data = _buffer.Address + dataOffset; int classNamePatchLength = section->ClassNamePatchesLength; if (classNamePatchLength > 0) { HavokSectionNode sectionNode = new HavokSectionNode { //sectionNode._name = section->Name; _name = "Instances" }; sectionNode.Initialize(this, data, section->DataLength); sectionNode._classCache = new List <HavokClassNode>(); _dataSection = sectionNode; uint rootOffset = header->_rootClassNameOffset; VoidPtr start = data + section->_classNamePatchesOffset; ClassNamePatch *patch = (ClassNamePatch *)start; int x = 0; while ((int)patch - (int)start < classNamePatchLength && patch->_dataOffset >= 0) { string className = new string(classNames + patch->_classNameOffset); uint signature = *(buint *)(classNames + (patch->_classNameOffset - 5)); if (!_mainDataSignatures.ContainsKey(className)) { _mainDataSignatures.Add(className, signature); } HavokClassNode entry = GetClassNode(className); if (entry != null && patch->_classNameOffset == rootOffset) { new HavokMetaObjectNode(entry as hkClassNode) { _signature = signature } .Initialize(sectionNode, data + patch->_dataOffset, 0); } patch++; x++; } } } }
public void GetInheritance() { _inheritance = new List <hkClassNode>(); ResourceNode current = this; //First, get classes inheriting this one TOP: bool found = false; if (current != null) { foreach (HavokSectionNode section in HavokNode.Children) { if (section._classCache != null && section != HavokNode._dataSection) { foreach (HavokClassNode c in section._classCache) { hkClassNode x = c as hkClassNode; if (x != null && x != this && x.ParentClass == current.Name) { current = x; _inheritance.Insert(0, x); found = true; break; } } } if (found) { break; } } } if (found) { goto TOP; } current = this; //Now add this class and the classes it inherits while (current is hkClassNode) { hkClassNode cNode = (hkClassNode)current; _inheritance.Add(cNode); if (HavokNode.AssignClassParents) { current = current.Parent; } //else if (!string.IsNullOrEmpty(cNode.ParentClass)) //{ // current = null; // HavokClassNode parent = HavokNode.GetClassNode(cNode.ParentClass); // if (parent is hkClassNode) // { // current = parent; // } //} } //Start with the eldest class, added last _inheritance.Reverse(); }
public override void OnPopulate() { VoidPtr addr = WorkingUncompressed.Address; foreach (hkClassMemberNode member in _memberArray) { hkClassMember.Type type = member.Type; bool zero = type == hkClassMember.Type.TYPE_ZERO; if (zero) { type = member.SubType; } hkClassNode memberClass = null; hkClassEnumNode memberEnum = null; if (!string.IsNullOrEmpty(member._class)) { HavokClassNode c = HavokNode.GetClassNode(member._class); if (c is hkClassNode) { memberClass = c as hkClassNode; } if (memberClass == null) { Console.WriteLine("Could not find " + member._class + " class"); } } if (!string.IsNullOrEmpty(member._enum)) { //Loop through inheritance starting with the eldest class, added last foreach (hkClassNode c in _classNode._inheritance) { ResourceNode enums = c.FindChild("Enums", false); if (enums != null) { foreach (hkClassEnumNode e in enums.Children) { if (e.Name == member._enum) { memberEnum = e; break; } } } } if (memberEnum == null) { Console.WriteLine("Could not find " + member._enum + " enum in " + _classNode.Name + " class"); } } ClassMemberInstanceNode instance = TryGetMember(type); if (instance != null) { switch (type) { case hkClassMember.Type.TYPE_SIMPLEARRAY: case hkClassMember.Type.TYPE_ARRAY: case hkClassMember.Type.TYPE_INPLACEARRAY: case hkClassMember.Type.TYPE_HOMOGENEOUSARRAY: case hkClassMember.Type.TYPE_POINTER: case hkClassMember.Type.TYPE_FUNCTIONPOINTER: type = member.SubType; break; } instance._isZero = zero; instance._name = member._name; instance._memberType = type; instance._memberFlags = member._flags; instance._classNode = memberClass; instance._enumNode = memberEnum; instance.Initialize(this, addr + member._structOffset, instance.GetSize()); } } }
public HavokMetaObjectNode(hkClassNode classNode) { _classNode = classNode; }