mirror/oot
1
0
Fork 0
mirror of https://github.com/zeldaret/oot.git synced 2025-05-10 19:13:42 +00:00
Code Issues Projects Releases Wiki Activity

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

Browse source
This commit is contained in:
Dragorn421 2025-02-09 01:53:00 +01:00
parent 589916d767
commit 3dc74cde04
No known key found for this signature in database
GPG key ID: 381AEBAF3D429335
8 changed files with 231 additions and 85 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
src/overlays/actors/ovl_En_Cow/z_en_cow.h
View file

@ -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)

24
tools/assets/descriptor/z64resources.py
View file

@ -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)

1
tools/assets/extract/extase/__init__.py
View file

@ -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

2
tools/assets/extract/extase_oot64/dlist_resources.py
View file

@ -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:

163
tools/assets/extract/extase_oot64/skeleton_resources.py
View file

@ -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),
("sibling", CDataExt_Value.u8),
("child", CDataExt_Value("B").set_write(write_limb_index)),
("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 = (
CDataExt_Value("I")
.set_report(report_limb_element)
.set_write(write_limb_element)
)
elem_cdata_ext = CDataExt_Value("I").set_write(write_limb_element)
def __init__(self, file, range_start, name):
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

21
tools/assets/extract/extase_oot64/skeleton_skin_resources.py
View file

@ -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}"

10
tools/assets/extract/extract_xml_z64.py
View file

@ -96,10 +96,8 @@ def process_pool(
):
if VERBOSE2:
print("> process_pool")
print(
"pool_desc collections:",
[str(rescoll.out_path) for rescoll in pool_desc.collections],
)
if len(pool_desc.collections) == 1:
print(", ".join(map(str, (_c.out_path for _c 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,

75
tools/assets/extract/z64_resource_handlers.py
View file

@ -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,
)
if resource_desc.type == z64resources.SkeletonType.NORMAL:
return skeleton_resources.SkeletonNormalResource(
file,
offset,
resource_desc.symbol_name,
)
elif resource_desc.type == z64resources.SkeletonType.FLEX:
return skeleton_resources.SkeletonFlexResource(
file,
offset,
resource_desc.symbol_name,
)
else:
raise NotImplementedError(
"unimplemented SkeletonType",
resource_desc.type,
)
# TODO check is this works for SkeletonSkinResource
# TODO implement for CurveSkeletonHeaderResource
if resource_desc.limb_enum_name is not None:
res.set_enum_name(resource_desc.limb_enum_name)
if resource_desc.limb_enum_none_member_name is not None:
res.set_enum_member_name_none(resource_desc.limb_enum_none_member_name)
if resource_desc.limb_enum_max_member_name is not None:
res.set_enum_member_name_max(resource_desc.limb_enum_max_member_name)
return res
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:
return skeleton_skin_resources.SkinLimbResource(
elif resource_desc.limb_type == z64resources.LimbType.SKIN:
res = skeleton_skin_resources.SkinLimbResource(
file, offset, resource_desc.symbol_name
)
if resource_desc.limb_type == z64resources.LimbType.LOD:
return skeleton_resources.LODLimbResource(
elif resource_desc.limb_type == z64resources.LimbType.LOD:
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:
return skelcurve_resources.SkelCurveLimbResource(
elif resource_desc.limb_type == z64resources.LimbType.CURVE:
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,