fivefury 0.2.4__tar.gz → 0.2.5__tar.gz

{fivefury-0.2.4 → fivefury-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fivefury
-Version: 0.2.4
+Version: 0.2.5
 Summary: Python library for GTA V asset workflows including YMAP, YTYP, RPF, YTD and GameFileCache utilities.
 Author: Codex
 License-Expression: MIT
@@ -77,7 +77,7 @@ Support levels:
 
 | Format | Current behavior |
 | --- | --- |
-| `YFT` | Resource texture dictionaries can be discovered/extracted from fragments, but full fragment authoring is not implemented. |
+| `YFT` | Fragment reading/writing for common, damaged, extra and cloth drawables, including geometry, materials, LOD meshes, bounding sphere metadata, fragment flags, physics LODs, physics groups, physics children, child entity drawables, per-child breaking/inertia data, damping constants, damping archetypes, articulated body metadata, link attachments, group and child event references, editable composite bounds, mass/inertia helpers, glass/cloth/vehicle semantic queries, corpus scanning, validation, declarative physics helpers, geometry summaries and embedded texture dictionaries. |
 | `YPT` | Resource texture dictionaries can be discovered/extracted from particle dictionaries, but full particle authoring is not implemented. |
 | `AWC` | Audio wave containers can be read/written structurally, opened through `GameFileCache`, exported back to WAV for PCM/ADPCM streams, and built from mono or multichannel 16-bit PCM inputs decoded through `miniaudio` (`.wav`, `.mp3`, `.ogg`, `.flac`). Playback metadata lives in `.rel` banks. |
 | `REL` | Audio metadata banks can be read/written structurally, opened through `GameFileCache`, and round-tripped with unknown entries preserved. `dat10.rel` modular synth presets/synths, `dat16.rel` curves, `dat22.rel` categories, and common `dat54.rel` sound graph entries have typed models, including simple AWC-backed sounds, wrappers, sequential/multitrack/streaming child lists, randomized variations, modular synth sounds, automation/MIDI sounds, note maps, variable-curve and conditional routing, directional/kinetic routing, variable blocks, math operations, parameter transforms, fluctuators, external streams, sound sets, sound-set lists, and sound-hash lists. Other REL item families currently stay as raw entries. |

{fivefury-0.2.4 → fivefury-0.2.5}/README.md

@@ -67,7 +67,7 @@ Support levels:
 
 | Format | Current behavior |
 | --- | --- |
-| `YFT` | Resource texture dictionaries can be discovered/extracted from fragments, but full fragment authoring is not implemented. |
+| `YFT` | Fragment reading/writing for common, damaged, extra and cloth drawables, including geometry, materials, LOD meshes, bounding sphere metadata, fragment flags, physics LODs, physics groups, physics children, child entity drawables, per-child breaking/inertia data, damping constants, damping archetypes, articulated body metadata, link attachments, group and child event references, editable composite bounds, mass/inertia helpers, glass/cloth/vehicle semantic queries, corpus scanning, validation, declarative physics helpers, geometry summaries and embedded texture dictionaries. |
 | `YPT` | Resource texture dictionaries can be discovered/extracted from particle dictionaries, but full particle authoring is not implemented. |
 | `AWC` | Audio wave containers can be read/written structurally, opened through `GameFileCache`, exported back to WAV for PCM/ADPCM streams, and built from mono or multichannel 16-bit PCM inputs decoded through `miniaudio` (`.wav`, `.mp3`, `.ogg`, `.flac`). Playback metadata lives in `.rel` banks. |
 | `REL` | Audio metadata banks can be read/written structurally, opened through `GameFileCache`, and round-tripped with unknown entries preserved. `dat10.rel` modular synth presets/synths, `dat16.rel` curves, `dat22.rel` categories, and common `dat54.rel` sound graph entries have typed models, including simple AWC-backed sounds, wrappers, sequential/multitrack/streaming child lists, randomized variations, modular synth sounds, automation/MIDI sounds, note maps, variable-curve and conditional routing, directional/kinetic routing, variable blocks, math operations, parameter transforms, fluctuators, external streams, sound sets, sound-set lists, and sound-hash lists. Other REL item families currently stay as raw entries. |

{fivefury-0.2.4 → fivefury-0.2.5}/fivefury/__init__.py

@@ -280,7 +280,7 @@ from .gxt2 import (
     save_gxt2,
     save_gxt2_text,
 )
-from .gtxd import Gtxd, TxdRelationship, create_gtxd, read_gtxd, save_gtxd
+from .gtxd import Gtxd, TxdRelationship, create_gtxd, is_gtxd_rbf, read_gtxd, read_gtxd_bytes, save_gtxd
 from .hashing import jenk_hash
 from .metahash import HashString, MetaHash
 from .meta import Meta, read_meta
@@ -476,6 +476,52 @@ from .ydd import (
     rig_ydd_to_bones_radially,
     save_ydd,
 )
+from .yft import (
+    Yft,
+    YftArticulatedBodyType,
+    YftDrawable,
+    YftDrawableMatch,
+    YftFragmentFlag,
+    YftFragmentPointers,
+    YftFragmentState,
+    YftGeometryStats,
+    YftCorpusEntry,
+    DEFAULT_DAMPING_CONSTANTS,
+    IDENTITY_MATRIX34,
+    YftPhysicsChild,
+    YftPhysicsChildFlag,
+    YftPhysicsDampArchetype,
+    YftPhysicsDamping,
+    YftPhysicsDampingKind,
+    YftPhysicsEntity,
+    YftPhysicsEventRefs,
+    YftPhysicsGroup,
+    YftPhysicsGroupEventRefs,
+    YftPhysicsGroupFlag,
+    YftPhysicsInertia,
+    YftPhysicsJointType,
+    YftPhysicsLod,
+    YftPhysicsLodPointers,
+    YftPhysicsReference,
+    YftRawField,
+    YftValidationIssue,
+    YftValidationSeverity,
+    assert_valid_yft,
+    bound_inertia,
+    bound_mass,
+    box_inertia,
+    build_yft_bytes,
+    create_yft,
+    default_articulated_body_type,
+    default_damp_archetype,
+    iter_yft_paths,
+    normalize_physics_lod,
+    read_yft,
+    save_yft,
+    scan_yft_corpus,
+    simple_physics_bound,
+    validate_yft,
+)
 from .ymap import (
     AngleMode,
     Block,
@@ -646,11 +692,44 @@ from .yed import (
     validate_yed,
 )
 from .ytd import Texture, TextureFormat, Ytd, read_ytd, save_ytd
-from .ymf import Ymf, read_ymf, save_ymf
+from .ymf import (
+    HdTxdAssetBinding,
+    ImapDependencies,
+    ImapDependency,
+    InteriorBoundsFile,
+    ItypDependencies,
+    ManifestFlags,
+    MapDataGroup,
+    PackFileMetaData,
+    PackFileMetaDataAssetType,
+    PackFileMetaDataImapGroupType,
+    Ymf,
+    YmfRelationship,
+    YmfRelationshipType,
+    build_ymf_for_ymaps,
+    build_ymf_manifest_for_ymaps,
+    build_ymf,
+    create_ymf_for_ymaps,
+    iter_ymf_relationships,
+    read_ymf,
+    read_ymf_xml,
+    save_ymf,
+)
 from .ymt import (
     PedComponent,
     PedDrawableVariation,
     Ymt,
+    YmtAabb,
+    YmtContentType,
+    YmtFormat,
+    YmtPedInitData,
+    YmtPedMetadata,
+    YmtScenarioPointGroup,
+    YmtScenarioPointManifest,
+    YmtScenarioPointRegionDef,
+    YmtStreamingRequestCommonSet,
+    YmtStreamingRequestFrame,
+    YmtStreamingRequestRecord,
     coerce_ped_component,
     iter_ped_drawables,
     ped_drawable_file_stem,
@@ -1187,6 +1266,50 @@ __all__ = [
     "YedTrackFormat",
     "YedPedExpressionBinding",
     "YedValidationIssue",
+    "Yft",
+    "YftArticulatedBodyType",
+    "YftDrawable",
+    "YftDrawableMatch",
+    "YftFragmentFlag",
+    "YftFragmentPointers",
+    "YftFragmentState",
+    "YftGeometryStats",
+    "YftCorpusEntry",
+    "DEFAULT_DAMPING_CONSTANTS",
+    "IDENTITY_MATRIX34",
+    "YftPhysicsChild",
+    "YftPhysicsChildFlag",
+    "YftPhysicsDampArchetype",
+    "YftPhysicsDamping",
+    "YftPhysicsDampingKind",
+    "YftPhysicsEntity",
+    "YftPhysicsEventRefs",
+    "YftPhysicsGroup",
+    "YftPhysicsGroupEventRefs",
+    "YftPhysicsGroupFlag",
+    "YftPhysicsInertia",
+    "YftPhysicsJointType",
+    "YftPhysicsLod",
+    "YftPhysicsLodPointers",
+    "YftPhysicsReference",
+    "YftRawField",
+    "YftValidationIssue",
+    "YftValidationSeverity",
+    "assert_valid_yft",
+    "bound_inertia",
+    "bound_mass",
+    "box_inertia",
+    "build_yft_bytes",
+    "create_yft",
+    "default_articulated_body_type",
+    "default_damp_archetype",
+    "iter_yft_paths",
+    "normalize_physics_lod",
+    "read_yft",
+    "save_yft",
+    "scan_yft_corpus",
+    "simple_physics_bound",
+    "validate_yft",
     "assimp_to_ynvs",
     "build_junction_heightmap",
     "get_ynd_area_bounds",
@@ -1206,8 +1329,29 @@ __all__ = [
     "YmapLodLightType",
     "YmapMloInstanceFlags",
     "YmapPriorityLevel",
+    "HdTxdAssetBinding",
+    "ImapDependencies",
+    "ImapDependency",
+    "InteriorBoundsFile",
+    "ItypDependencies",
+    "ManifestFlags",
+    "MapDataGroup",
+    "PackFileMetaData",
+    "PackFileMetaDataAssetType",
+    "PackFileMetaDataImapGroupType",
     "Ymf",
+    "YmfRelationship",
+    "YmfRelationshipType",
     "Ymt",
+    "YmtAabb",
+    "YmtPedInitData",
+    "YmtPedMetadata",
+    "YmtScenarioPointGroup",
+    "YmtScenarioPointManifest",
+    "YmtScenarioPointRegionDef",
+    "YmtStreamingRequestCommonSet",
+    "YmtStreamingRequestFrame",
+    "YmtStreamingRequestRecord",
     "ContainerLodDef",
     "YddAsset",
     "Ytd",
@@ -1229,6 +1373,9 @@ __all__ = [
     "build_dlc_extra_title_update_data_xml",
     "build_dlc_list_xml",
     "build_dlc_setup_xml",
+    "build_ymf",
+    "build_ymf_for_ymaps",
+    "build_ymf_manifest_for_ymaps",
     "create_dlc_folder_metadata",
     "create_dlc_list_for_packs",
     "create_dlc_patch_manifest",
@@ -1238,6 +1385,7 @@ __all__ = [
     "clear_hash_resolver",
     "clear_game_crypto",
     "create_rpf",
+    "create_ymf_for_ymaps",
     "create_ydd",
     "create_ydr",
     "convert_audio_to_awc",
@@ -1282,7 +1430,9 @@ __all__ = [
     "read_dlc_list",
     "read_dlc_pack",
     "read_dlc_setup",
+    "is_gtxd_rbf",
     "read_gtxd",
+    "read_gtxd_bytes",
     "read_gxt2",
     "read_gxt2_text",
     "read_ycd",
@@ -1291,6 +1441,8 @@ __all__ = [
     "read_yed",
     "read_shader_library",
     "read_ydr",
+    "read_yft",
+    "save_yft",
     "rig_body_folder_jiggle_bones",
     "rig_mesh_to_bones_radially",
     "rig_ydd_to_bones_radially",
@@ -1314,11 +1466,15 @@ __all__ = [
     "read_ynv",
     "read_ymap",
     "read_ymf",
+    "read_ymf_xml",
     "read_ymt",
     "read_ytd",
     "read_ytyp",
+    "YmtContentType",
+    "YmtFormat",
     "infer_dlc_content_from_folder",
     "iter_ped_drawables",
+    "iter_ymf_relationships",
     "iter_dlc_content_candidates",
     "register_name",
     "register_names",
@@ -1381,4 +1537,6 @@ __all__ = [
     "create_ycd_uv_clip",
     "get_ycd_track_format",
     "parse_ycd_uv_clip_binding",
+    "assert_valid_yft",
+    "validate_yft",
 ]

{fivefury-0.2.4 → fivefury-0.2.5}/fivefury/assets/yft.py

@@ -29,6 +29,9 @@ class YftAsset(ResourceTextureAsset):
         main_drawable_pointer = _u64(self.system_data, 0x30)
         yield from emit("drawable", main_drawable_pointer)
 
+        damaged_drawable_pointer = _u64(self.system_data, 0x50)
+        yield from emit("damaged", damaged_drawable_pointer)
+
         drawable_array_pointer = _u64(self.system_data, 0x38)
         drawable_array_count = _u32(self.system_data, 0x48)
         for index, drawable_pointer in enumerate(

{fivefury-0.2.4 → fivefury-0.2.5}/fivefury/bounds/geometry.py

@@ -1,9 +1,8 @@
 from __future__ import annotations
 
 import dataclasses
-from math import sqrt
-
 from .. import _native as _native_backend
+from ..vector import aabb_center, aabb_from_points, vec_cross, vec_length, vec_sub
 from .model import (
     BoundAabb,
     BoundBVH,
@@ -35,14 +34,7 @@ class BoundTriangleChunk:
 
 
 def _triangle_area_python(vertex0: Vector3, vertex1: Vector3, vertex2: Vector3) -> float:
-    edge1 = (vertex1[0] - vertex0[0], vertex1[1] - vertex0[1], vertex1[2] - vertex0[2])
-    edge2 = (vertex2[0] - vertex0[0], vertex2[1] - vertex0[1], vertex2[2] - vertex0[2])
-    cross = (
-        (edge1[1] * edge2[2]) - (edge1[2] * edge2[1]),
-        (edge1[2] * edge2[0]) - (edge1[0] * edge2[2]),
-        (edge1[0] * edge2[1]) - (edge1[1] * edge2[0]),
-    )
-    return 0.5 * sqrt((cross[0] * cross[0]) + (cross[1] * cross[1]) + (cross[2] * cross[2]))
+    return 0.5 * vec_length(vec_cross(vec_sub(vertex1, vertex0), vec_sub(vertex2, vertex0)))
 
 
 def triangle_area(vertex0: Vector3, vertex1: Vector3, vertex2: Vector3) -> float:
@@ -54,10 +46,7 @@ def triangle_area(vertex0: Vector3, vertex1: Vector3, vertex2: Vector3) -> float
 def _bounds_from_vertices_python(vertices: list[Vector3]) -> tuple[Vector3, Vector3]:
     if not vertices:
         raise ValueError("At least one vertex is required")
-    return (
-        (min(vertex[0] for vertex in vertices), min(vertex[1] for vertex in vertices), min(vertex[2] for vertex in vertices)),
-        (max(vertex[0] for vertex in vertices), max(vertex[1] for vertex in vertices), max(vertex[2] for vertex in vertices)),
-    )
+    return aabb_from_points(vertices)
 
 
 def bounds_from_vertices(vertices: list[Vector3]) -> tuple[Vector3, Vector3]:
@@ -67,19 +56,12 @@ def bounds_from_vertices(vertices: list[Vector3]) -> tuple[Vector3, Vector3]:
 
 
 def center_from_bounds(minimum: Vector3, maximum: Vector3) -> Vector3:
-    return ((minimum[0] + maximum[0]) * 0.5, (minimum[1] + maximum[1]) * 0.5, (minimum[2] + maximum[2]) * 0.5)
+    return aabb_center(minimum, maximum)
 
 
 def _sphere_radius_from_vertices_python(center: Vector3, vertices: list[Vector3]) -> float:
     return max(
-        (
-            sqrt(
-                ((vertex[0] - center[0]) ** 2)
-                + ((vertex[1] - center[1]) ** 2)
-                + ((vertex[2] - center[2]) ** 2)
-            )
-            for vertex in vertices
-        ),
+        (vec_length(vec_sub(vertex, center)) for vertex in vertices),
         default=0.0,
     )
 

{fivefury-0.2.4 → fivefury-0.2.5}/fivefury/bounds/model.py

@@ -8,6 +8,7 @@ from typing import Iterator
 
 from .. import _native as _native_backend
 from ..resource import ResourcePagesInfo
+from ..vector import aabb_center, aabb_from_center_size, vec_add, vec_scale, vec_sub
 from .materials import BoundMaterialType, coerce_bound_material_index, get_bound_material_type
 
 
@@ -57,9 +58,7 @@ def _merge_bounds(bounds: list[BoundAabb], fallback: BoundAabb) -> BoundAabb:
 
 
 def _aabb_from_center_size(center: tuple[float, float, float], size: tuple[float, float, float]) -> BoundAabb:
-    half_size = tuple(float(value) * 0.5 for value in size)
-    minimum = tuple(float(center[axis]) - half_size[axis] for axis in range(3))
-    maximum = tuple(float(center[axis]) + half_size[axis] for axis in range(3))
+    minimum, maximum = aabb_from_center_size(center, size)
     return BoundAabb(minimum, maximum)
 
 
@@ -159,6 +158,46 @@ def _sphere_radius_from_bounds(bounds: BoundAabb, center: tuple[float, float, fl
     )
 
 
+def _box_volume_distribution(size: tuple[float, float, float]) -> tuple[float, float, float]:
+    x, y, z = (abs(float(axis)) for axis in size)
+    return (((y * y) + (z * z)) / 12.0, ((x * x) + (z * z)) / 12.0, ((x * x) + (y * y)) / 12.0)
+
+
+def _sphere_volume_distribution(radius: float) -> tuple[float, float, float]:
+    value = 0.4 * float(radius) * float(radius)
+    return (value, value, value)
+
+
+def _cylinder_volume_distribution(radius: float, length: float) -> tuple[float, float, float]:
+    radius2 = float(radius) * float(radius)
+    central = (radius2 * 0.25) + ((float(length) * float(length)) / 12.0)
+    radial = radius2 * 0.5
+    return (central, radial, central)
+
+
+def _capsule_volume_distribution(radius: float, length: float) -> tuple[float, float, float]:
+    radius = float(radius)
+    length = float(length)
+    denominator = length + (4.0 / 3.0) * radius
+    if denominator <= 0.0:
+        return (0.0, 0.0, 0.0)
+    inverse = 1.0 / denominator
+    radius2 = radius * radius
+    radial = 0.5 * radius2 * (length + 1.0666666666667 * radius) * inverse
+    length2 = length * length
+    central = (
+        (1.0 / 3.0)
+        * (
+            0.25 * length * length2
+            + radius * length2
+            + 2.25 * length * radius2
+            + 1.6 * radius * radius2
+        )
+        * inverse
+    )
+    return (central, radial, central)
+
+
 @dataclasses.dataclass(slots=True)
 class BoundCompositeFlags:
     flags1: BoundCompositeFlag = BoundCompositeFlag.NONE
@@ -629,19 +668,37 @@ class Bound:
     def geometry_count(self) -> int:
         return len(self.geometries)
 
-    @property
+    @property
     def leaf_bounds(self) -> list[Bound]:
         return [bound for bound in self.walk() if not isinstance(bound, BoundComposite)]
 
+    def compute_volume(self) -> float:
+        if self.volume > 0.0 and math.isfinite(self.volume):
+            return float(self.volume)
+        return abs(self.width * self.depth * self.height)
+
+    def compute_volume_distribution(self) -> tuple[float, float, float]:
+        if any(abs(value) > 0.0 for value in self.angular_inertia):
+            return tuple(float(value) for value in self.angular_inertia)
+        return _box_volume_distribution(self.dimensions)
+
+    def compute_angular_inertia(self, mass: float) -> tuple[float, float, float]:
+        distribution = self.compute_volume_distribution()
+        return tuple(float(value) * float(mass) for value in distribution)
+
     def build(self) -> "Bound":
         normalized = _normalize_aabb(self.bounds)
         self.box_min = normalized.minimum
         self.box_max = normalized.maximum
         self.box_center = tuple((normalized.minimum[axis] + normalized.maximum[axis]) * 0.5 for axis in range(3))
+        if self.sphere_center == (0.0, 0.0, 0.0) and self.box_center != (0.0, 0.0, 0.0):
+            self.sphere_center = self.box_center
         self.flags = BoundFlag(int(self.flags))
         self.part_index = int(self.part_index) & 0xFFFF
         self.material_index = coerce_bound_material_index(self.material_index)
         self.ref_count = int(self.ref_count)
+        self.volume = self.compute_volume()
+        self.angular_inertia = self.compute_volume_distribution()
         return self
 
     def validate(self) -> list[str]:
@@ -699,9 +756,18 @@ class BoundSphere(Bound):
     def diameter(self) -> float:
         return self.radius * 2.0
 
+    def compute_volume(self) -> float:
+        return (4.0 / 3.0) * math.pi * (self.radius ** 3)
+
+    def compute_volume_distribution(self) -> tuple[float, float, float]:
+        return _sphere_volume_distribution(self.radius)
+
 
 @dataclasses.dataclass(slots=True)
 class BoundBox(Bound):
+    def compute_volume_distribution(self) -> tuple[float, float, float]:
+        return _box_volume_distribution(self.dimensions)
+
     @classmethod
     def from_bounds(
         cls,
@@ -777,6 +843,13 @@ class BoundCapsule(Bound):
     def total_height(self) -> float:
         return self.shaft_length + (self.radius * 2.0)
 
+    def compute_volume(self) -> float:
+        radius = self.radius
+        return math.pi * radius * radius * (self.shaft_length + (4.0 / 3.0) * radius)
+
+    def compute_volume_distribution(self) -> tuple[float, float, float]:
+        return _capsule_volume_distribution(self.radius, self.shaft_length)
+
 
 @dataclasses.dataclass(slots=True)
 class BoundDisc(Bound):
@@ -846,6 +919,12 @@ class BoundDisc(Bound):
     def thickness(self) -> float:
         return self.half_thickness * 2.0
 
+    def compute_volume(self) -> float:
+        return math.pi * self.radius * self.radius * self.thickness
+
+    def compute_volume_distribution(self) -> tuple[float, float, float]:
+        return _cylinder_volume_distribution(self.radius, self.thickness)
+
 
 @dataclasses.dataclass(slots=True)
 class BoundCylinder(Bound):
@@ -910,6 +989,12 @@ class BoundCylinder(Bound):
     def height(self) -> float:
         return self.half_height * 2.0
 
+    def compute_volume(self) -> float:
+        return math.pi * self.radius * self.radius * self.height
+
+    def compute_volume_distribution(self) -> tuple[float, float, float]:
+        return _cylinder_volume_distribution(self.radius, self.height)
+
 
 @dataclasses.dataclass(slots=True)
 class BoundCloth(Bound):
@@ -1121,6 +1206,70 @@ class BoundComposite(Bound):
         self.children.append(child)
         return child
 
+    def compute_volume(self) -> float:
+        if self.children:
+            return sum(child.bound.compute_volume() for child in self.children)
+        return super().compute_volume()
+
+    def compute_center_of_gravity(
+        self,
+        masses: list[float] | tuple[float, ...] | None = None,
+    ) -> tuple[float, float, float]:
+        weighted = (0.0, 0.0, 0.0)
+        total_weight = 0.0
+        for index, child in enumerate(self.children):
+            weight = (
+                float(masses[index])
+                if masses is not None and index < len(masses)
+                else child.bound.compute_volume()
+            )
+            if weight <= 0.0:
+                continue
+            child_center = _transform_point(child.bound.sphere_center, child.transform)
+            weighted = vec_add(weighted, vec_scale(child_center, weight))
+            total_weight += weight
+        return vec_scale(weighted, 1.0 / total_weight) if total_weight > 0.0 else (0.0, 0.0, 0.0)
+
+    def compute_composite_angular_inertia(
+        self,
+        mass: float,
+        *,
+        masses: list[float] | tuple[float, ...] | None = None,
+        inertias: list[tuple[float, float, float]] | tuple[tuple[float, float, float], ...] | None = None,
+    ) -> tuple[float, float, float]:
+        total_mass = float(mass)
+        total_volume = self.compute_volume()
+        density = total_mass / total_volume if total_volume > 0.0 else 0.0
+        center_of_gravity = self.compute_center_of_gravity(masses)
+        total = (0.0, 0.0, 0.0)
+        for index, child in enumerate(self.children):
+            part_mass = (
+                float(masses[index])
+                if masses is not None and index < len(masses)
+                else density * child.bound.compute_volume()
+            )
+            if inertias is not None and index < len(inertias):
+                part_inertia = inertias[index]
+            else:
+                part_inertia = child.bound.compute_angular_inertia(part_mass)
+            offset = vec_sub(_transform_point(child.bound.sphere_center, child.transform), center_of_gravity)
+            parallel_axis = (
+                part_mass * ((offset[1] * offset[1]) + (offset[2] * offset[2])),
+                part_mass * ((offset[0] * offset[0]) + (offset[2] * offset[2])),
+                part_mass * ((offset[0] * offset[0]) + (offset[1] * offset[1])),
+            )
+            total = vec_add(total, vec_add(part_inertia, parallel_axis))
+        return total
+
+    def compute_volume_distribution(self) -> tuple[float, float, float]:
+        volume = self.compute_volume()
+        if volume <= 0.0:
+            return (0.0, 0.0, 0.0)
+        return vec_scale(self.compute_composite_angular_inertia(volume), 1.0 / volume)
+
+    def compute_angular_inertia(self, mass: float) -> tuple[float, float, float]:
+        return self.compute_composite_angular_inertia(mass)
+
     def build(self) -> "BoundComposite":
         super().build()
         for child in self.children:
@@ -1133,12 +1282,14 @@ class BoundComposite(Bound):
                 for child in self.children
             ]
             overall = _merge_bounds(transformed_bounds, self.bounds)
-            center = tuple((overall.minimum[axis] + overall.maximum[axis]) * 0.5 for axis in range(3))
+            center = aabb_center(overall.minimum, overall.maximum)
             self.box_min = overall.minimum
             self.box_max = overall.maximum
             self.box_center = center
-            self.sphere_center = center
+            self.sphere_center = self.compute_center_of_gravity()
             self.sphere_radius = _sphere_radius_from_bounds(overall, center)
+            self.volume = self.compute_volume()
+            self.angular_inertia = self.compute_volume_distribution()
             if len(self.children) <= 5:
                 self.bvh = None
         else:

{fivefury-0.2.4 → fivefury-0.2.5}/fivefury/cache/assets.py

@@ -154,11 +154,11 @@ class GameFileCacheAssetMixin:
     def list_ymap_entity_assets(self, query: Any, *, include_supporting: bool = True) -> list["AssetRecord"]:
         return list(self.iter_ymap_entity_assets(query, include_supporting=include_supporting))
 
-    def extract_ymap_assets(
-        self,
-        query: Any,
-        destination: str | Path,
-        *,
+    def extract_ymap_assets(
+        self,
+        query: Any,
+        destination: str | Path,
+        *,
         include_supporting: bool = True,
         logical: bool = False,
     ) -> list[Path]:
@@ -168,10 +168,19 @@ class GameFileCacheAssetMixin:
         for asset in self.iter_ymap_entity_assets(query, include_supporting=include_supporting):
             result = self.extract_asset(asset, output_dir / asset.name, logical=logical)
             if result is not None:
-                extracted.append(result)
-        return extracted
-
-    def _coerce_ytd(self, value: Any) -> Ytd | None:
+                extracted.append(result)
+        return extracted
+
+    def create_ymf_for_ymaps(self, ymaps: Any | None = None, **kwargs: Any) -> Any:
+        from ..ymf import create_ymf_for_ymaps
+
+        sources = None if ymaps is None else (ymaps if isinstance(ymaps, (list, tuple, set)) else [ymaps])
+        return create_ymf_for_ymaps(sources, cache=self, **kwargs)
+
+    def build_ymf_for_ymaps(self, ymaps: Any | None = None, **kwargs: Any) -> Any:
+        return self.create_ymf_for_ymaps(ymaps, **kwargs)
+
+    def _coerce_ytd(self, value: Any) -> Ytd | None:
         if isinstance(value, Ytd):
             return value
         if hasattr(value, "textures") and hasattr(value, "to_bytes"):

{fivefury-0.2.4 → fivefury-0.2.5}/fivefury/cache/core.py

@@ -513,6 +513,7 @@ _KIND_DICT_TYPES: dict[str, GameFileType] = {
     "YwrDict": GameFileType.YWR,
     "YvrDict": GameFileType.YVR,
     "Gxt2Dict": GameFileType.GXT2,
+    "GtxdDict": GameFileType.GTXD,
     "AwcDict": GameFileType.AWC,
     "YedDict": GameFileType.YED,
 }

{fivefury-0.2.4 → fivefury-0.2.5}/fivefury/cache/io.py

@@ -21,6 +21,7 @@ from ..ybn import read_ybn
 from ..ydd import read_ydd
 from ..yed import read_yed
 from ..ydr import read_ydr
+from ..yft import read_yft
 from ..ynd import read_ynd
 from ..ynv import read_ynv
 from ..ytd import read_ytd
@@ -70,6 +71,7 @@ def _decode_payload(path: str, data: bytes, *, raw: bytes | None = None) -> tupl
     resource_decoders = {
         ".ydr": (GameFileType.YDR, lambda payload: read_ydr(payload, path=path)),
         ".ydd": (GameFileType.YDD, lambda payload: read_ydd(payload, path=path)),
+        ".yft": (GameFileType.YFT, lambda payload: read_yft(payload, path=path)),
         ".ytd": (GameFileType.YTD, read_ytd),
         ".ycd": (GameFileType.YCD, lambda payload: read_ycd(payload, path=path)),
         ".yed": (GameFileType.YED, lambda payload: read_yed(payload, path=path)),
@@ -225,7 +227,7 @@ class GameFileCacheIOMixin:
             self._log(f"read file {asset.path}")
             logical_native = self._logical_archive_bytes_from_standalone(asset, standalone_native)
             ext = Path(asset.path).suffix.lower()
-            raw_source = standalone_native if ext in {".ytd", ".ydr", ".ydd", ".ycd", ".yed", ".ybn", ".ynd", ".ynv"} else stored_native
+            raw_source = standalone_native if ext in {".ytd", ".ydr", ".ydd", ".yft", ".ycd", ".yed", ".ybn", ".ynd", ".ynv"} else stored_native
             parsed, kind = _decode_payload(asset.path, logical_native, raw=raw_source)
             entry = asset.entry if isinstance(asset.entry, RpfFileEntry) else None
             archive = asset.archive if isinstance(asset.archive, RpfArchive) else None
@@ -249,7 +251,7 @@ class GameFileCacheIOMixin:
             stored = entry.read(logical=False)
             logical = entry.read(logical=True)
             raw_source = None
-            if asset.path.lower().endswith((".ytd", ".ydr", ".ydd", ".ycd", ".yed", ".ybn", ".ynd", ".ynv")):
+            if asset.path.lower().endswith((".ytd", ".ydr", ".ydd", ".yft", ".ycd", ".yed", ".ybn", ".ynd", ".ynv")):
                 raw_source = entry._archive.read_entry_standalone(entry)
             parsed, kind = _decode_payload(asset.path, logical, raw=raw_source)
             game_file = GameFile(