feat(animator3d): add GLB decompression support for EXT_meshopt_compression

Implement a function to decompress GLB files with EXT_meshopt_compression using `gltf-transform copy`, ensuring compatibility with Blender's GLTF importer. Update asset import functions to utilize this decompression step, enhancing the import process for GLB files. Additionally, refactor related functions to improve file handling and streamline the asset processing workflow.

Author: maikramer

Animator3D/src/animator3d/bpy_ops.py

@@ -19,6 +19,31 @@ def clear_scene() -> None:
     bpy.ops.wm.read_factory_settings(use_empty=True)
 
 
+def _decompress_meshopt_glb(src: Path) -> Path:
+    """Se ``src`` é GLB com EXT_meshopt_compression (que bpy não importa),
+    descompressa via ``gltf-transform copy`` para um tmpfile e devolve o path
+    novo. Caso contrário, devolve ``src``.
+    """
+    import shutil as _sh
+    import subprocess as _sp
+    import tempfile as _tf
+
+    if _sh.which("npx") is None:
+        return src
+    with _tf.NamedTemporaryFile(suffix=".glb", delete=False) as _tmp:
+        out = Path(_tmp.name)
+    try:
+        r = _sp.run(
+            ["npx", "--yes", "@gltf-transform/cli", "copy", str(src), str(out)],
+            capture_output=True, text=True, timeout=300, check=False,
+        )
+    except (FileNotFoundError, _sp.TimeoutExpired):
+        return src
+    if r.returncode != 0 or not out.is_file():
+        return src
+    return out
+
+
 def import_asset(path: Path) -> list[str]:
     """Importa GLB/GLTF ou FBX. Devolve nomes de objectos de topo criados."""
     bpy = _bpy()
@@ -30,6 +55,9 @@ def import_asset(path: Path) -> list[str]:
     before = {o.name for o in bpy.context.scene.objects}
 
     if suffix in {".glb", ".gltf"}:
+        # bpy GLTF importer não suporta EXT_meshopt_compression; descompressa
+        # silenciosamente quando preciso (no-op se já descompresso).
+        path = _decompress_meshopt_glb(path)
         bpy.ops.import_scene.gltf(filepath=str(path))
     elif suffix == ".fbx":
         bpy.ops.import_scene.fbx(filepath=str(path))
@@ -2350,10 +2378,10 @@ def project_texture_to_parts(
     bpy = _bpy()
     clear_scene()
 
-    bpy.ops.import_scene.gltf(filepath=str(original_glb.resolve()))
+    bpy.ops.import_scene.gltf(filepath=str(_decompress_meshopt_glb(original_glb.resolve())))
     source_objs = [o for o in bpy.context.selected_objects if o.type == "MESH"]
 
-    bpy.ops.import_scene.gltf(filepath=str(parts_glb.resolve()))
+    bpy.ops.import_scene.gltf(filepath=str(_decompress_meshopt_glb(parts_glb.resolve())))
     all_objs = list(bpy.context.selected_objects)
     part_objs = [o for o in all_objs if o not in source_objs and o.type == "MESH"]
 

GameAssets/src/gameassets/paths.py

@@ -210,6 +210,16 @@ def _resolve_intermediate_or_main(canonical: Path, mesh_final: Path) -> Path | N
     return None
 
 
+def _clean_existing(mesh_final: Path) -> Path | None:
+    """Encontra o GLB ``_clean`` em ``meshes/`` ou ``_intermediate/``."""
+    return _resolve_intermediate_or_main(_clean_path(mesh_final), mesh_final)
+
+
+def _rigged_hi_existing(mesh_final: Path) -> Path | None:
+    """Encontra o GLB ``_rigged_hi`` em ``meshes/`` ou ``_intermediate/``."""
+    return _resolve_intermediate_or_main(_rigged_hi_path(mesh_final), mesh_final)
+
+
 def _shape_existing(mesh_final: Path) -> Path | None:
     """Devolve o ``id_shape.glb`` existente em ``meshes/`` ou ``_intermediate/``."""
     return _resolve_intermediate_or_main(_shape_path(mesh_final), mesh_final)
@@ -273,25 +283,25 @@ def _classify_row_state_master(
     """
     shape_any = _shape_existing(mesh_final)
     painted_any = _painted_existing(mesh_final)
-    clean = _clean_path(mesh_final)
+    clean_any = _clean_existing(mesh_final)
     lod0 = _lod_path(mesh_final, 0)
     lod1 = _lod_path(mesh_final, 1)
     lod2 = _lod_path(mesh_final, 2)
-    rigged_hi = _rigged_hi_path(mesh_final)
+    rigged_hi_any = _rigged_hi_existing(mesh_final)
 
     if not _valid_file(img_final) and shape_any is None:
         return _ROW_NEED_IMAGE
     if shape_any is None:
         return _ROW_NEED_SHAPE
-    if not _valid_file(clean):
+    if clean_any is None:
         return _ROW_NEED_TOPOLOGY_FIX
     if want_texture and painted_any is None:
         return _ROW_NEED_PAINT
     if not _valid_file(lod0):
         return _ROW_NEED_BAKE_MASTER
     if wants_lod and (not _valid_file(lod1) or not _valid_file(lod2)):
         return _ROW_NEED_LOD_GEN
-    if wants_rig and not _valid_file(rigged_hi):
+    if wants_rig and rigged_hi_any is None:
         return _ROW_NEED_RIG_HI
     if wants_rig:
         # checa transfers

GameAssets/src/gameassets/pipeline_master.py

@@ -31,7 +31,9 @@
 from .helpers import effective_face_ratio
 from .manifest import ManifestRow
 from .paths import (
+    _clean_existing,
     _clean_path,
+    _rigged_hi_existing,
     _intermediate_dir,
     _lod_animated_path,
     _lod_path,
@@ -266,24 +268,29 @@ def _run(name: str, argv: list[str], output: Path | None = None) -> StageResult:
     # (após uma run anterior). Resolve dinamicamente para permitir resume.
     shape_p = _shape_existing(mesh_final) or _shape_path(mesh_final)
     painted_p = _painted_existing(mesh_final) or _painted_path(mesh_final)
-    clean_p = _clean_path(mesh_final)
+    clean_existing = _clean_existing(mesh_final)
+    clean_p = clean_existing if clean_existing is not None else _clean_path(mesh_final)
 
     if not shape_p.is_file():
         res.ok = False
         res.stages.append(StageResult("preflight", False, 0.0, f"shape ausente: {shape_p}"))
         return res
 
-    # Stage 2 — topology-fix (shape → clean)
+    # Stage 2 — topology-fix (shape → clean). Skip se já temos um clean
+    # válido (em meshes/ ou _intermediate/) — resume-friendly.
     clean_p.parent.mkdir(parents=True, exist_ok=True)
-    s = _run(
-        "topology-fix",
-        [text3d_bin, "topology-fix", str(shape_p), "-o", str(clean_p)],
-        clean_p,
-    )
-    res.stages.append(s)
-    if not s.ok:
-        res.ok = False
-        return res
+    if clean_existing is not None and clean_existing.is_file():
+        res.stages.append(StageResult("topology-fix", True, 0.0, "skipped (clean existente)", clean_p))
+    else:
+        s = _run(
+            "topology-fix",
+            [text3d_bin, "topology-fix", str(shape_p), "-o", str(clean_p)],
+            clean_p,
+        )
+        res.stages.append(s)
+        if not s.ok:
+            res.ok = False
+            return res
 
     # Stage 4 — bake-master (painted → lod0 com tangents/KTX2/meshopt)
     if not painted_p.is_file():
@@ -309,6 +316,15 @@ def _run(name: str, argv: list[str], output: Path | None = None) -> StageResult:
     ]
     if bake_normals:
         bake_argv.append("--bake-normals")
+    # Quando há rigging/anim downstream, o LOD0 vai ser re-importado por bpy
+    # (rigging3d, animator3d). bpy não suporta EXT_meshopt_compression,
+    # portanto saltamos a compressão em bake-master e re-aplicamos
+    # gltf_transform_finish na promoção (Stage 9.5) sobre o output final.
+    needs_bpy_downstream = (with_rig and rigging3d_bin is not None) or (
+        with_animate and animator3d_bin is not None
+    )
+    if needs_bpy_downstream:
+        bake_argv.extend(["--no-meshopt", "--no-ktx2"])
     s = _run("bake-master", bake_argv, lod0_p)
     res.stages.append(s)
     if not s.ok:
@@ -340,6 +356,10 @@ def _run(name: str, argv: list[str], output: Path | None = None) -> StageResult:
             "--min-faces-lod2",
             str(lod_target_lod2),
         ]
+        # Igual a bake-master: salta finish quando bpy precisa importar
+        # depois (rigging/animação por LOD). Re-comprimimos na promoção.
+        if needs_bpy_downstream:
+            lod_argv.append("--no-finish")
         s = _run("lod", lod_argv)
         res.stages.append(s)
 
@@ -372,32 +392,61 @@ def _run(name: str, argv: list[str], output: Path | None = None) -> StageResult:
             except Exception as exc:  # noqa: BLE001
                 log.warning("master: finish collision falhou: %s", exc)
 
-    # Stage 7 — rigging3d pipeline sobre _clean.glb
-    rigged_hi_p = _rigged_hi_path(mesh_final)
+    # Stage 7 — rigging3d pipeline sobre _clean.glb. Skip se já temos um
+    # rigged_hi válido (em meshes/ ou _intermediate/) — resume-friendly.
+    rigged_hi_existing = _rigged_hi_existing(mesh_final)
+    rigged_hi_p = rigged_hi_existing if rigged_hi_existing is not None else _rigged_hi_path(mesh_final)
     if with_rig and rigging3d_bin:
-        rig_argv = [rigging3d_bin, "pipeline", "--input", str(clean_p), "--output", str(rigged_hi_p)]
-        s = _run("rigging3d-hi", rig_argv, rigged_hi_p)
-        res.stages.append(s)
-        if not s.ok:
-            with_rig = False  # bloqueia stages dependentes mas não aborta o asset
-
-    # Stage 8 — transfer-weights para LOD0/1/2 (CLI já aplica gltf_transform_finish
-    # em cada output rigged: KTX2+meshopt+tangents+dedup+prune — Round 2 Fase 1.4).
+        if rigged_hi_existing is not None and rigged_hi_existing.is_file():
+            res.stages.append(StageResult("rigging3d-hi", True, 0.0, "skipped (rigged_hi existente)", rigged_hi_p))
+        else:
+            rig_argv = [rigging3d_bin, "pipeline", "--input", str(clean_p), "--output", str(rigged_hi_p)]
+            s = _run("rigging3d-hi", rig_argv, rigged_hi_p)
+            res.stages.append(s)
+            if not s.ok:
+                with_rig = False  # bloqueia stages dependentes mas não aborta o asset
+
+    # Stage 8 — Rigging por LOD via ``rigging3d merge``.
+    #
+    # Estratégia: re-usa o skeleton+skin do ``_rigged_hi.glb`` e fá-lo
+    # "merge" com cada LOD low-poly, produzindo um GLB com Armature real
+    # (re-importável por bpy → animator3d funciona). Não corre o modelo
+    # de inferência de novo (sem GPU), apenas faz re-skinning analítico.
+    #
+    # ``rigging3d transfer-weights`` (bpy.data_transfer) é alternativa mas
+    # o exportador GLTF do Blender não detecta o output como skinned —
+    # mantido apenas como ferramenta experimental.
     rigged_lods: list[Path] = []
     if with_rig and rigging3d_bin and rigged_hi_p.is_file():
         targets: list[Path] = [lod0_p]
         if lod1_p.is_file():
             targets.append(lod1_p)
         if lod2_p.is_file():
             targets.append(lod2_p)
-        outs = [_lod_rigged_path(mesh_final, i) for i in range(len(targets))]
-        tw_argv = [rigging3d_bin, "transfer-weights", "--source", str(rigged_hi_p)]
-        for t, o in zip(targets, outs, strict=False):
-            tw_argv.extend(["--target", str(t), "--output", str(o)])
-        s = _run("transfer-weights", tw_argv)
-        res.stages.append(s)
-        if s.ok:
-            rigged_lods = [o for o in outs if o.is_file()]
+        for i, tgt in enumerate(targets):
+            out = _lod_rigged_path(mesh_final, i)
+            merge_argv = [
+                rigging3d_bin,
+                "merge",
+                "--source",
+                str(rigged_hi_p),
+                "--target",
+                str(tgt),
+                "--output",
+                str(out),
+            ]
+            s = _run(f"rigging3d-merge-lod{i}", merge_argv, out)
+            res.stages.append(s)
+            if s.ok and out.is_file():
+                # Aplica gltf_transform_finish para alinhar com regras
+                # rigged.yaml (KTX2+meshopt+tangents+dedup+prune).
+                try:
+                    from text3d.utils.gltf_finish import gltf_transform_finish
+
+                    gltf_transform_finish(out, out)
+                except Exception as exc:  # noqa: BLE001
+                    log.warning("master: finish rigged-lod%d falhou: %s", i, exc)
+                rigged_lods.append(out)
 
     # Stage 9 — animate cada LOD rigged. Round 2: preset por categoria.
     animated_lods: list[Path] = []
@@ -475,6 +524,17 @@ def _run(name: str, argv: list[str], output: Path | None = None) -> StageResult:
                 promoted_levels.add(level)
             except OSError as exc:
                 log.warning("master: promoção %s→%s falhou: %s", w, target, exc)
+                continue
+            # Garante que o output final está totalmente optimizado
+            # (KTX2+meshopt+tangents+dedup+prune). Bake-master e
+            # rigging/animação correm com finish minimal quando há bpy
+            # downstream — aplicamos a finalização pesada aqui no fim.
+            try:
+                from text3d.utils.gltf_finish import gltf_transform_finish
+
+                gltf_transform_finish(target, target)
+            except Exception as exc:  # noqa: BLE001
+                log.warning("master: finish promoted lod%d falhou: %s", level, exc)
 
         # Se animated promovido, mover _rigged.glb para _intermediate/.
         if promotion_kind == "animated":

GameAssets/src/gameassets/resume_cmd.py

@@ -212,9 +212,10 @@ def append_log(rec: dict) -> None:
         row_wants_rig = _row_wants_rig(row, has_rigging_profile)
         row_wants_animate = _row_wants_animate(row, want_rig, has_rigging_profile)
 
+        master_state: str | None = None
         if getattr(profile, "master_pipeline", False):
             # Round 2: usa classificador do DAG novo.
-            state = _classify_row_state_master(
+            master_state = _classify_row_state_master(
                 img_final=img_final,
                 mesh_final=mesh_final,
                 want_texture=row.generate_paint,
@@ -223,6 +224,28 @@ def append_log(rec: dict) -> None:
                 wants_lod=row.generate_lod,
                 wants_collision=row.generate_collision,
             )
+            # Mapeia para os 6 buckets clássicos usados pelo planeador/loop
+            # do resume_cmd. O bucket determina onde a execução vai retomar:
+            # need_paint cobre topology-fix/bake-master/lod_gen (todos
+            # rodam dentro do pipeline_master, que é despachado a partir do
+            # passo paint).
+            _master_to_legacy = {
+                "need_image": _ROW_NEED_IMAGE,
+                "need_shape": _ROW_NEED_SHAPE,
+                "need_topology_fix": _ROW_NEED_PAINT,
+                "need_paint": _ROW_NEED_PAINT,
+                "need_bake_master": _ROW_NEED_PAINT,
+                "need_lod_gen": _ROW_NEED_PAINT,
+                "need_collision": _ROW_NEED_PAINT,
+                "need_rig_hi": _ROW_NEED_RIG,
+                "need_rig": _ROW_NEED_RIG,
+                "need_transfer": _ROW_NEED_RIG,
+                "need_animate_lod": _ROW_NEED_ANIMATE,
+                "need_animate": _ROW_NEED_ANIMATE,
+                "need_validate": _ROW_DONE,
+                _ROW_DONE: _ROW_DONE,
+            }
+            state = _master_to_legacy.get(master_state, _ROW_NEED_PAINT)
         else:
             state = _classify_row_state(
                 img_final=img_final,
@@ -243,6 +266,7 @@ def append_log(rec: dict) -> None:
                 "idx": idx,
                 "row": row,
                 "state": state,
+                "master_state": master_state,
                 "img_final": img_final,
                 "mesh_final": mesh_final,
                 "row_work": row_work,
@@ -254,7 +278,7 @@ def append_log(rec: dict) -> None:
         )
 
     # --- Relatório ---
-    counts = {
+    counts: dict[str, int] = {
         _ROW_NEED_IMAGE: 0,
         _ROW_NEED_SHAPE: 0,
         _ROW_NEED_PAINT: 0,
@@ -263,7 +287,7 @@ def append_log(rec: dict) -> None:
         _ROW_DONE: 0,
     }
     for it in items:
-        counts[it["state"]] += 1
+        counts[it["state"]] = counts.get(it["state"], 0) + 1
 
     plan_table = Table(title="[bold]Plano de execução[/bold]", box=box.ROUNDED, show_header=True)
     plan_table.add_column("Fase", style="bold")