generate and use Limb enums (TODO: check Skin skels and implement for Curve skels)

src/overlays/actors/ovl_En_Cow/z_en_cow.h

@@ -5,26 +5,6 @@
 #include "global.h"
 #include "assets/objects/object_cow/object_cow.h"
 
-typedef enum CowLimb {
-    /* 0x00 */ COW_LIMB_NONE,
-    /* 0x01 */ COW_LIMB_ROOT,
-    /* 0x02 */ COW_LIMB_HEAD,
-    /* 0x03 */ COW_LIMB_JAW,
-    /* 0x04 */ COW_LIMB_NOSE,
-    /* 0x05 */ COW_LIMB_NOSE_RING,
-    /* 0x06 */ COW_LIMB_MAX
-} CowLimb;
-
-typedef enum CowTailLimb {
-    /* 0x00 */ COW_TAIL_LIMB_NONE,
-    /* 0x01 */ COW_TAIL_LIMB_ROOT,
-    /* 0x02 */ COW_TAIL_LIMB_UPPER,
-    /* 0x03 */ COW_TAIL_LIMB_MIDDLE,
-    /* 0x04 */ COW_TAIL_LIMB_LOWER,
-    /* 0x05 */ COW_TAIL_LIMB_END,
-    /* 0x06 */ COW_TAIL_LIMB_MAX
-} CowTailLimb;
-
 #define COW_FLAG_PLAYER_NEARBY (1 << 1)
 #define COW_FLAG_FAILED_TO_GIVE_MILK (1 << 2)
 

tools/assets/descriptor/z64resources.py

@@ -1,5 +1,6 @@
 import dataclasses
 import enum
+from typing import Optional
 from xml.etree.ElementTree import Element
 
 from .base import (
@@ -109,24 +110,43 @@ class LimbType(enum.Enum):
 class SkeletonResourceDesc(ResourceDesc):
     type: SkeletonType
     limb_type: LimbType
+    limb_enum_name: Optional[str]
+    limb_enum_none_member_name: Optional[str]
+    limb_enum_max_member_name: Optional[str]
 
 
 def handler_Skeleton(symbol_name, offset, collection, reselem: Element):
     skel_type = SkeletonType[reselem.attrib["Type"].upper()]
     limb_type = LimbType[reselem.attrib["LimbType"].upper()]
     return SkeletonResourceDesc(
-        symbol_name, offset, collection, reselem, skel_type, limb_type
+        symbol_name,
+        offset,
+        collection,
+        reselem,
+        skel_type,
+        limb_type,
+        reselem.attrib.get("EnumName"),
+        reselem.attrib.get("LimbNone"),
+        reselem.attrib.get("LimbMax"),
     )
 
 
 @dataclasses.dataclass(eq=False)
 class LimbResourceDesc(ResourceDesc):
     limb_type: LimbType
+    limb_enum_member_name: Optional[str]
 
 
 def handler_Limb(symbol_name, offset, collection, reselem: Element):
     limb_type = LimbType[reselem.attrib["LimbType"].upper()]
-    return LimbResourceDesc(symbol_name, offset, collection, reselem, limb_type)
+    return LimbResourceDesc(
+        symbol_name,
+        offset,
+        collection,
+        reselem,
+        limb_type,
+        reselem.attrib.get("EnumName"),
+    )
 
 
 @dataclasses.dataclass(eq=False)

tools/assets/extract/extase/__init__.py

@@ -137,6 +137,7 @@ class File:
         ] = dict()
 
     def add_resource(self, resource: "Resource"):
+        assert resource is not None
         assert resource not in self._resources
         self._resources.append(resource)
         self._is_resources_sorted = False

tools/assets/extract/extase_oot64/dlist_resources.py

@@ -10,7 +10,7 @@ try:
 except ModuleNotFoundError:
     rich_pprint = print
 
-# pip install pygfxd@git+https://github.com/Dragorn421/pygfxd.git@065541d92ad0d84d214fad4f30e4592f7102c013
+# pip install pygfxd@git+https://github.com/Dragorn421/pygfxd.git@9d418bc5d1cebedfeec3455250bef29473055940
 import pygfxd
 
 if TYPE_CHECKING:

tools/assets/extract/extase_oot64/skeleton_resources.py

@@ -1,6 +1,13 @@
+import abc
 import io
 from typing import TYPE_CHECKING
 
+from ..extase import (
+    RESOURCE_PARSE_SUCCESS,
+    ResourceParseInProgress,
+    ResourceParseWaiting,
+)
+
 if TYPE_CHECKING:
     from ..extase.memorymap import MemoryContext
 
@@ -17,15 +24,43 @@ from . import dlist_resources
 
 
 class StandardLimbResource(CDataResource):
+    def write_limb_index(
+        resource, memory_context: "MemoryContext", v, f: io.TextIOBase, line_prefix
+    ):
+        assert isinstance(v, int)
+        f.write(line_prefix)
+        if resource.skeleton_resource is None:
+            f.write(f"{v}")
+        else:
+            f.write(f"/* {v} */ ")
+            if v == 0xFF:
+                f.write("LIMB_DONE")
+            else:
+                f.write(
+                    resource.skeleton_resource.limbs_array_resource.limbs[
+                        v
+                    ].enum_member_name
+                )
+                f.write(" - 1")
+        return True
+
     cdata_ext = CDataExt_Struct(
         (
             ("jointPos", cdata_ext_Vec3s),
-            ("child", CDataExt_Value.u8),
+            ("child", CDataExt_Value("B").set_write(write_limb_index)),
-            ("sibling", CDataExt_Value.u8),
+            ("sibling", CDataExt_Value("B").set_write(write_limb_index)),
             ("dList", dlist_resources.cdata_ext_gfx_segmented),
         )
     )
 
+    def __init__(self, file, range_start, name):
+        super().__init__(file, range_start, name)
+        self.enum_member_name = f"LIMB_{file.name.upper()}_{range_start:06X}"
+        self.skeleton_resource: "SkeletonResourceBaseABC | None" = None
+
+    def set_enum_member_name(self, enum_member_name: str):
+        self.enum_member_name = enum_member_name
+
     def get_c_declaration_base(self):
         return f"StandardLimb {self.symbol_name}"
 
@@ -40,12 +75,25 @@ class LODLimbResource(CDataResource):
     cdata_ext = CDataExt_Struct(
         (
             ("jointPos", cdata_ext_Vec3s),
-            ("child", CDataExt_Value.u8),
+            (
-            ("sibling", CDataExt_Value.u8),
+                "child",
+                CDataExt_Value("B").set_write(StandardLimbResource.write_limb_index),
+            ),
+            (
+                "sibling",
+                CDataExt_Value("B").set_write(StandardLimbResource.write_limb_index),
+            ),
             ("dLists", CDataExt_Array(dlist_resources.cdata_ext_gfx_segmented, 2)),
         )
     )
 
+    def __init__(self, file, range_start, name):
+        super().__init__(file, range_start, name)
+        self.enum_member_name = f"LIMB_{file.name.upper()}_{range_start:06X}"
+
+    def set_enum_member_name(self, enum_member_name: str):
+        self.enum_member_name = enum_member_name
+
     def get_c_declaration_base(self):
         return f"LodLimb {self.symbol_name}"
 
@@ -60,18 +108,6 @@ class LimbsArrayResourceABC(CDataArrayResource):
     limb_type: type[CDataResource]
     c_limb_type: str
 
-    def report_limb_element(resource, memory_context: "MemoryContext", v):
-        assert isinstance(v, int)
-        address = v
-        memory_context.report_resource_at_segmented(
-            resource,
-            address,
-            resource.limb_type,
-            lambda file, offset: resource.limb_type(
-                file, offset, f"{resource.name}_{address:08X}"
-            ),
-        )
-
     def write_limb_element(
         resource, memory_context: "MemoryContext", v, f: io.TextIOBase, line_prefix
     ):
@@ -81,11 +117,29 @@ class LimbsArrayResourceABC(CDataArrayResource):
         f.write(memory_context.get_c_reference_at_segmented(address))
         return True
 
-    elem_cdata_ext = (
+    elem_cdata_ext = CDataExt_Value("I").set_write(write_limb_element)
-        CDataExt_Value("I")
+
-        .set_report(report_limb_element)
+    def __init__(self, file, range_start, name):
-        .set_write(write_limb_element)
+        super().__init__(file, range_start, name)
-    )
+        self.limbs = None
+
+    def try_parse_data(self, memory_context):
+        ret = super().try_parse_data(memory_context)
+        assert ret == RESOURCE_PARSE_SUCCESS
+        self.limbs: list[self.limb_type] = []
+        for address in self.cdata_unpacked:
+            limb = memory_context.report_resource_at_segmented(
+                self,
+                address,
+                self.limb_type,
+                lambda file, offset: self.limb_type(
+                    file,
+                    offset,
+                    f"{self.name}_{address:08X}_{self.c_limb_type}",
+                ),
+            )
+            self.limbs.append(limb)
+        return RESOURCE_PARSE_SUCCESS
 
     def get_c_declaration_base(self):
         return f"void* {self.symbol_name}[]"
@@ -101,9 +155,72 @@ class LODLimbsArrayResource(LimbsArrayResourceABC):
     c_limb_type = "LodLimb"
 
 
-class SkeletonResourceABC(CDataResource):
+class SkeletonResourceBaseABC(CDataResource):
     limbs_array_type: type[LimbsArrayResourceABC]
 
+    def __init__(self, file, range_start, name):
+        super().__init__(file, range_start, name)
+        self.enum_name = f"{self.symbol_name}Limb"
+        self.enum_member_name_none = f"LIMB_{self.symbol_name.upper()}_NONE"
+        self.enum_member_name_max = f"LIMB_{self.symbol_name.upper()}_MAX"
+        self.limbs_array_resource = None
+
+    def set_enum_name(self, enum_name: str):
+        self.enum_name = enum_name
+
+    def set_enum_member_name_none(self, enum_member_name_none: str):
+        self.enum_member_name_none = enum_member_name_none
+
+    def set_enum_member_name_max(self, enum_member_name_max: str):
+        self.enum_member_name_max = enum_member_name_max
+
+    def try_parse_data(self, memory_context):
+        if self.limbs_array_resource is None:
+            ret = super().try_parse_data(memory_context)
+            assert ret == RESOURCE_PARSE_SUCCESS
+            data = self.get_skeleton_header_cdata_unpacked()
+            segment_resolve_result = memory_context.resolve_segmented(data["segment"])
+            self.limbs_array_resource = segment_resolve_result.get_resource(
+                self.limbs_array_type
+            )
+            if self.limbs_array_resource.limbs is None:
+                raise ResourceParseInProgress(
+                    new_progress_done=["reported limbs array"],
+                    waiting_for=["self.limbs_array_resource.limbs"],
+                )
+        else:
+            if self.limbs_array_resource.limbs is None:
+                raise ResourceParseWaiting(
+                    waiting_for=["self.limbs_array_resource.limbs"],
+                )
+        for limb in self.limbs_array_resource.limbs:
+            limb.skeleton_resource = self
+        return RESOURCE_PARSE_SUCCESS
+
+    def write_c_declaration(self, h):
+        h.write(f"typedef enum {self.enum_name} {{\n")
+        limb_enum_members = (
+            self.enum_member_name_none,
+            *(limb.enum_member_name for limb in self.limbs_array_resource.limbs),
+            self.enum_member_name_max,
+        )
+        h.write(
+            ",\n".join(
+                f"    /* {i:2} */ {enum_member}"
+                for i, enum_member in enumerate(limb_enum_members)
+            )
+            + "\n"
+        )
+        h.write(f"}} {self.enum_name};\n")
+        super().write_c_declaration(h)
+        return True
+
+    @abc.abstractmethod
+    def get_skeleton_header_cdata_unpacked(self) -> dict: ...
+
+
+class SkeletonResourceABC(SkeletonResourceBaseABC):
+
     def report_segment(resource, memory_context: "MemoryContext", v):
         assert isinstance(v, int)
         address = v
@@ -177,7 +294,7 @@ class SkeletonNormalLODResource(SkeletonResourceABC):
     limbs_array_type = LODLimbsArrayResource
 
 
-class SkeletonFlexResourceABC(CDataResource):
+class SkeletonFlexResourceABC(SkeletonResourceBaseABC):
     skeleton_type: type[SkeletonResourceABC]
 
     # For SkeletonResourceABC.report_segment

tools/assets/extract/extase_oot64/skeleton_skin_resources.py

@@ -210,8 +210,18 @@ class SkinLimbResource(CDataResource):
     cdata_ext = CDataExt_Struct(
         (
             ("jointPos", cdata_ext_Vec3s),
-            ("child", CDataExt_Value.u8),
+            (
-            ("sibling", CDataExt_Value.u8),
+                "child",
+                CDataExt_Value("B").set_write(
+                    skeleton_resources.StandardLimbResource.write_limb_index
+                ),
+            ),
+            (
+                "sibling",
+                CDataExt_Value("B").set_write(
+                    skeleton_resources.StandardLimbResource.write_limb_index
+                ),
+            ),
             (
                 "segmentType",
                 CDataExt_Value("i").set_write_str_v(
@@ -225,6 +235,13 @@ class SkinLimbResource(CDataResource):
         )
     )
 
+    def __init__(self, file, range_start, name):
+        super().__init__(file, range_start, name)
+        self.enum_member_name = f"LIMB_{file.name.upper()}_{range_start:06X}"
+
+    def set_enum_member_name(self, enum_member_name: str):
+        self.enum_member_name = enum_member_name
+
     def get_c_declaration_base(self):
         return f"SkinLimb {self.symbol_name}"
 

tools/assets/extract/extract_xml_z64.py

@@ -96,10 +96,8 @@ def process_pool(
 ):
     if VERBOSE2:
         print("> process_pool")
-        print(
+    if len(pool_desc.collections) == 1:
-            "pool_desc collections:",
+        print(", ".join(map(str, (_c.out_path for _c in pool_desc.collections))))
-            [str(rescoll.out_path) for rescoll in pool_desc.collections],
-        )
 
     file_by_rescoll: dict[ResourcesDescCollection, File] = dict()
 
@@ -229,7 +227,9 @@ def process_pool(
     # 5)
 
     for rescoll, file in file_by_rescoll.items():
-        file.set_source_path(Path("assets") / rescoll.out_path)
+        file.set_source_path(
+            extraction_ctx.extracted_path / "assets" / rescoll.out_path
+        )
 
         file.set_resources_paths(
             extraction_ctx.extracted_path,

tools/assets/extract/z64_resource_handlers.py

@@ -5,7 +5,6 @@ from ..descriptor import n64resources
 from ..descriptor import z64resources
 
 from .extase import (
-    GetResourceAtResult,
     File,
     Resource,
     BinaryBlobResource,
@@ -81,14 +80,30 @@ def register_resource_handlers():
     ):
         offset = resource_desc.offset
         if resource_desc.limb_type == z64resources.LimbType.STANDARD:
-            pass
+            if resource_desc.type == z64resources.SkeletonType.NORMAL:
+                res = skeleton_resources.SkeletonNormalResource(
+                    file,
+                    offset,
+                    resource_desc.symbol_name,
+                )
+            elif resource_desc.type == z64resources.SkeletonType.FLEX:
+                res = skeleton_resources.SkeletonFlexResource(
+                    file,
+                    offset,
+                    resource_desc.symbol_name,
+                )
+            else:
+                raise NotImplementedError(
+                    "unimplemented SkeletonType",
+                    resource_desc.type,
+                )
         elif resource_desc.limb_type == z64resources.LimbType.LOD:
             if resource_desc.type == z64resources.SkeletonType.NORMAL:
-                return skeleton_resources.SkeletonNormalLODResource(
+                res = skeleton_resources.SkeletonNormalLODResource(
                     file, offset, resource_desc.symbol_name
                 )
             elif resource_desc.type == z64resources.SkeletonType.FLEX:
-                return skeleton_resources.SkeletonFlexLODResource(
+                res = skeleton_resources.SkeletonFlexLODResource(
                     file, offset, resource_desc.symbol_name
                 )
             else:
@@ -99,12 +114,12 @@ def register_resource_handlers():
                 )
         elif resource_desc.limb_type == z64resources.LimbType.SKIN:
             assert resource_desc.type == z64resources.SkeletonType.NORMAL
-            return skeleton_skin_resources.SkeletonSkinResource(
+            res = skeleton_skin_resources.SkeletonSkinResource(
                 file, offset, resource_desc.symbol_name
             )
         elif resource_desc.limb_type == z64resources.LimbType.CURVE:
             assert resource_desc.type == z64resources.SkeletonType.CURVE
-            return skelcurve_resources.CurveSkeletonHeaderResource(
+            res = skelcurve_resources.CurveSkeletonHeaderResource(
                 file, offset, resource_desc.symbol_name
             )
         else:
@@ -112,24 +127,15 @@ def register_resource_handlers():
                 "unimplemented Skeleton LimbType",
                 resource_desc.limb_type,
             )
-
+        # TODO check is this works for SkeletonSkinResource
-        if resource_desc.type == z64resources.SkeletonType.NORMAL:
+        # TODO implement for CurveSkeletonHeaderResource
-            return skeleton_resources.SkeletonNormalResource(
+        if resource_desc.limb_enum_name is not None:
-                file,
+            res.set_enum_name(resource_desc.limb_enum_name)
-                offset,
+        if resource_desc.limb_enum_none_member_name is not None:
-                resource_desc.symbol_name,
+            res.set_enum_member_name_none(resource_desc.limb_enum_none_member_name)
-            )
+        if resource_desc.limb_enum_max_member_name is not None:
-        elif resource_desc.type == z64resources.SkeletonType.FLEX:
+            res.set_enum_member_name_max(resource_desc.limb_enum_max_member_name)
-            return skeleton_resources.SkeletonFlexResource(
+        return res
-                file,
-                offset,
-                resource_desc.symbol_name,
-            )
-        else:
-            raise NotImplementedError(
-                "unimplemented SkeletonType",
-                resource_desc.type,
-            )
 
     def limb_resource_handler(
         file: File,
@@ -137,27 +143,27 @@ def register_resource_handlers():
     ):
         offset = resource_desc.offset
         if resource_desc.limb_type == z64resources.LimbType.STANDARD:
-            return skeleton_resources.StandardLimbResource(
+            res = skeleton_resources.StandardLimbResource(
                 file,
                 offset,
                 resource_desc.symbol_name,
             )
-        if resource_desc.limb_type == z64resources.LimbType.SKIN:
+        elif resource_desc.limb_type == z64resources.LimbType.SKIN:
-            return skeleton_skin_resources.SkinLimbResource(
+            res = skeleton_skin_resources.SkinLimbResource(
                 file, offset, resource_desc.symbol_name
             )
-        if resource_desc.limb_type == z64resources.LimbType.LOD:
+        elif resource_desc.limb_type == z64resources.LimbType.LOD:
-            return skeleton_resources.LODLimbResource(
+            res = skeleton_resources.LODLimbResource(
                 file, offset, resource_desc.symbol_name
             )
-        if resource_desc.limb_type == z64resources.LimbType.LEGACY:
+        elif resource_desc.limb_type == z64resources.LimbType.LEGACY:
             # TODO LegacyLimbResource
             # } LegacyLimb; // size = 0x20
             return BinaryBlobResource(
                 file, offset, offset + 0x20, resource_desc.symbol_name
             )
-        if resource_desc.limb_type == z64resources.LimbType.CURVE:
+        elif resource_desc.limb_type == z64resources.LimbType.CURVE:
-            return skelcurve_resources.SkelCurveLimbResource(
+            res = skelcurve_resources.SkelCurveLimbResource(
                 file, offset, resource_desc.symbol_name
             )
         else:
@@ -165,6 +171,11 @@ def register_resource_handlers():
                 "unimplemented LimbType",
                 resource_desc.limb_type,
             )
+        # TODO check this works for SkinLimbResource
+        # TODO implement for SkelCurveLimbResource
+        if resource_desc.limb_enum_member_name is not None:
+            res.set_enum_member_name(resource_desc.limb_enum_member_name)
+        return res
 
     def limb_table_handler(
         file: File,