From 135f4ce0400ab68da643c11f150d42def0655fda Mon Sep 17 00:00:00 2001 From: torsten Date: Thu, 12 Nov 2026 06:04:47 +0100 Subject: [PATCH] =?UTF-8?q?feat:=20Ultra-Skater=20im=20K=C3=BCrkleid=20und?= =?UTF-8?q?=20Rig-Werkzeug?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Zweiter Durchlauf für Geometrie und Outfit: Referenzbild per Tripo-Image-Edit auf ein petrolfarbenes Kürkleid umgestellt (20 Credits), daraus ein Ultra-Image→3D (geometry_quality=detailed, 50 Credits). - v008: 59.488 Dreiecke, 1,7 m, 222 Control-/30 Deform-Bones, Glide unverändert per Rotations-Retargeting - Lider, Ohren und Haaransatz deutlich besser als v007; Finger bleiben verschmolzen - Manifest-Eintrag auf Version 2 (v008), Skater3D-Fallback und check_export.sh nachgezogen - tools/blender/build_skater.py: Rig, Retarget und Export in einem Befehl, reproduziert die manuelle GLB byte-identisch - Lizenz-Log um Bild-Edit und Ultra-Lauf ergänzt, Doku und AGENTS.md aktualisiert --- AGENTS.md | 4 + assets/license-log.csv | 2 + docs/assets.md | 37 +- docs/findings-2026-11-12-tripo-skater-rig.md | 41 +++ rinkplanner/assets/asset_manifest.json | 18 +- rinkplanner/src/presentation3d/skater_3d.gd | 2 +- tools/blender/build_skater.py | 350 +++++++++++++++++++ tools/check_export.sh | 6 +- 8 files changed, 434 insertions(+), 26 deletions(-) create mode 100644 tools/blender/build_skater.py diff --git a/AGENTS.md b/AGENTS.md index d64018e..3ddecf3 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -68,6 +68,10 @@ „6 ObjectDB instances leaked at exit". - **Blender:** `mcp-for-blender` über `uvx`, Addon in `~/.config/blender/5.2/scripts/addons/blender_mcp.py` (Port 9876). +- **Skater bauen:** `tools/blender/build_skater.py` riggt ein Tripo-GLB mit + AutoRigPro, übernimmt `Glide` und exportiert. Aufruf ohne `-b` (ARP braucht + eine GUI), Details im Modulkopf und in + `docs/findings-2026-11-12-tripo-skater-rig.md`. - **Tripo:** `tripo`-MCP (Toolset `full`) und CLI `/home/torsten/.local/bin/tripo` sind die Quelle für 3D-Meshes. Der MCP-Wrapper in `~/.config/opencode/opencode.jsonc` sourct selbst diff --git a/assets/license-log.csv b/assets/license-log.csv index c16f580..df12c08 100644 --- a/assets/license-log.csv +++ b/assets/license-log.csv @@ -11,3 +11,5 @@ datum,endpoint_id,request_id,prompt,seed,lizenz 2026-11-11,tripo3d/h3.1/image-to-3d,01a1c9d7-d014-77d3-89ff-1b4052294b75,"Image-to-3D from flux2pro_reference_front_1024x1536.png, seed 202",202,Tripo H3.1 via fal; commercial use confirmed by fal Support 2026-11-12; fal terms and no IP indemnity 2026-11-11,tripo3d/h3.1/image-to-3d,01a1c9d7-cf93-7612-be5c-37d303004632,"Image-to-3D from flux2pro_reference_front_1024x1536.png, seed 303",303,Tripo H3.1 via fal; commercial use confirmed by fal Support 2026-11-12; fal terms and no IP indemnity 2026-11-12,tripo/v3.1-20260211/image-to-3d,d8ee7a30-c1dc-4873-8770-4747d98a62ff,"Image-to-3D from flux2pro_reference_front.png, face_limit=60000, texture v3.5",,Tripo pay-as-you-go API; commercial use covered by paid API access +2026-11-12,tripo/chat_image_2.5_sunburst/image-to-image,316752d8-16e7-49c8-beb1-d2223afc9f79,"Image edit of flux2pro_reference_front.png: petrol sequin competition dress, same face and pose",,Tripo pay-as-you-go API; commercial use covered by paid API access +2026-11-12,tripo/v3.1-20260211/image-to-3d,834f0e29-65db-49d2-a02b-7a6239a4d07a,"Image-to-3D from generated_image.png (competition dress), geometry_quality=detailed, face_limit=60000, texture v3.5",,Tripo pay-as-you-go API; commercial use covered by paid API access diff --git a/docs/assets.md b/docs/assets.md index 4c7b26e..ef424d6 100644 --- a/docs/assets.md +++ b/docs/assets.md @@ -184,7 +184,7 @@ eine still veränderte Workbench-Datei wird nicht kopiert, sondern gemeldet. (`skater_figure_tripo*`) sowie `assets/models/*` aus, nehmen aber beide Skater-GLB samt Quelltexturen mit (`assets/external/characters/skater_figure_glide_v006*` und - `skater_figure_glide_v007*`). Fehlt die GLB auf einem frischen Checkout, + `skater_figure_glide_v008*`). Fehlt die GLB auf einem frischen Checkout, baut `Skater3D` weiterhin den Platzhalter; `tools/check_export.sh` weist darauf hin und prüft die Texturen im Build. - Phase 1 bleibt unberührt: Der 2D-Code lädt keine 3D-Ressourcen. @@ -193,7 +193,7 @@ eine still veränderte Workbench-Datei wird nicht kopiert, sondern gemeldet. | ID | Datei | Größe | Rig | Clips | | :--- | :--- | ---: | :--- | :--- | -| `character.skater.figure_tripo_glide` | `skater_figure_glide_v007.glb` | 2,71 MB | 222 Control / 30 Deform, 4 Einflüsse | `Glide` (2-s-Loop) | +| `character.skater.figure_tripo_glide` | `skater_figure_glide_v008.glb` | 3,08 MB | 222 Control / 30 Deform, 4 Einflüsse | `Glide` (2-s-Loop) | | `character.skater.figure` | `skater_figure_glide_v006.glb` | 8,59 MB | 222 Control / 30 Deform, 8 Einflüsse | `Glide` (2-s-Loop) | | `character.skater.figure_tripo` | `skater_figure_tripo_v001_30k.glb` | 7,19 MB | keins (unrigged) | – | @@ -201,24 +201,35 @@ Die 3D-Vorschau lädt `character.skater.figure_tripo_glide` über die Manifest-ID. Fehlt sie, erscheint ein Platzhalter aus Kapsel und Kopf, damit ein frischer Checkout und die Tests laufen. -### Tripo-Skater mit Glide (v007, aktiv) +### Tripo-Skater mit Glide (v008, aktiv) -`character.skater.figure_tripo_glide` ist die erste geriggte Fassung des -Tripo-Meshes und seit 2026-11-12 die Figur, die `Skater3D` lädt: +`character.skater.figure_tripo_glide` ist seit 2026-11-12 die Figur, die +`Skater3D` lädt. Version 2 (v008) entstand im Ultra-Modus und trägt ein +petrolfarbenes Kürkleid mit Pailletten statt des Trainingskleids: -- 59.350 Dreiecke, Textur v3.5, Höhe 1,7 m, Blickrichtung `+Z`, Pivot Füße. -- Tripo-Task `d8ee7a30-c1dc-4873-8770-4747d98a62ff` (Image→3D aus - `flux2pro_reference_front.png`, Modell v3.1, 60k-Face-Budget, 30 Credits, - über die Tripo-Pay-as-you-go-API statt fal). +- 59.488 Dreiecke, Textur v3.5, Höhe 1,7 m, Blickrichtung `+Z`, Pivot Füße. +- Referenzbild per Tripo-Image-Edit aus `flux2pro_reference_front.png` + erzeugt (Task `316752d8-16e7-49c8-beb1-d2223afc9f79`, 20 Credits). +- Mesh: `geometry_quality=detailed`, 60k-Face-Budget, Task + `834f0e29-65db-49d2-a02b-7a6239a4d07a`, 50 Credits. - Rig lokal in Blender mit AutoRigPro: 222 Control-Bones, 30 Deform-Bones, Bind `PSEUDO_VOXELS`, 4 Einflüsse pro Vertex. - `Glide` per reinem Rotations-Retargeting von `skater_figure_glide_v006` übernommen (2-s-Loop, 48 Frames bei 24 fps). - Klingenabstand in der Vorschau: ±0,154 m (Konstante `BLADE_LATERAL_OFFSET_M` in `skater_3d.gd`). -- Bekannte Schwächen: Lider ohne Augengeometrie, spitz zulaufende Ohren, - Finger als verschmolzene Blobs. Bei der Vorschau-Distanz unsichtbar, bei - Nahaufnahmen sichtbar. +- Bekannte Schwächen: Lider ohne Augengeometrie, Finger als verschmolzene + Blobs. Im Ultra-Modus sind Ohren und Gesichtsform deutlich besser, die + Finger bleiben aber ungetrennt. + +Der komplette Weg vom Mesh zum geriggten Export ist als ein Befehl +reproduzierbar: + +```bash +blender --python tools/blender/build_skater.py -- \ + model.glb skater_figure_glide_v008.glb \ + --source-rig rinkplanner/assets/external/characters/skater_figure_glide_v006.glb +``` Ablauf, Stolpersteine und Messwerte: `docs/findings-2026-11-12-tripo-skater-rig.md`. @@ -238,7 +249,7 @@ angebunden und **nicht** in den Export-Presets enthalten: - **Lizenz:** Erzeugt über fal (`tripo3d/h3.1/image-to-3d`); fal Support hat am 2026-11-12 bestätigt, dass der Vertrag mit fal besteht und Tripos Free-/Paid-User-AGB nicht greifen. Seit der Umstellung auf die - Tripo-Pay-as-you-go-API (siehe v007) gilt: kommerzielle Nutzung ist über + Tripo-Pay-as-you-go-API (siehe v008) gilt: kommerzielle Nutzung ist über den bezahlten API-Zugang abgedeckt; fal erhebt keine Rechte an Outputs, garantiert aber keine Originalität oder Nichtrechtsverletzung. Details in `docs/findings-2026-11-11-ai-skater-model-comparison.md`. Aus den diff --git a/docs/findings-2026-11-12-tripo-skater-rig.md b/docs/findings-2026-11-12-tripo-skater-rig.md index 8ab62d8..1320c6a 100644 --- a/docs/findings-2026-11-12-tripo-skater-rig.md +++ b/docs/findings-2026-11-12-tripo-skater-rig.md @@ -114,3 +114,44 @@ neben den Schlittschuhen. `~/Downloads/rinkplanner_skater_tripo_v002/` (`arp_markers_v2.blend`, `arp_matched.blend`, `arp_bound.blend`, `arp_glide.blend`, `glide_new_sheet.png`, `arp_ik_test.png`) + +## Nachtrag: Ultra-Lauf mit Kürkleid (v008) + +Zweiter Durchlauf am selben Tag, zwei Wünsche auf einmal: bessere Geometrie +und ein Kürkleid statt des Trainingsdresses. + +**Referenzbild.** Statt neu zu text→image ging ein Image-Edit auf die +bestehende FLUX-Referenz (`chat_image_2.5_sunburst`, quality `high`, Größe +768×1024). Der Prompt hielt Gesicht, Pose, Bildausschnitt und Beleuchtung fest +und tauschte nur das Outfit: langärmliges Kürkleid, Paillettenverlauf von +Türkis nach Petrol, kurzer Rock, blickdichte Strumpfhose, dieselben weißen +Schlittschuhe. Task `316752d8-16e7-49c8-beb1-d2223afc9f79`, **20 Credits**. +Ergebnis war direkt brauchbar: gleiche Läuferin, gleiche Pose. + +**Mesh.** `tripo_image_to_3d` mit `geometry_quality=detailed` (Ultra), +face_limit 60.000, Textur v3.5, Task +`834f0e29-65db-49d2-a02b-7a6239a4d07a`, **50 Credits**. Ergebnis: 59.488 +Dreiecke, 1,70 m. + +**Was Ultra gebracht hat:** + +- Lider haben jetzt Form und eine Lidfalte – vorher eine glatte Fläche. +- Ohren sind normale Ohren, keine Elfenohren. +- Haaransatz und Dutt zeigen Strähnen statt einer Naht. +- Finger bleiben verschmolzene Blobs; die Trennung ist im Mesh angelegt, + aber nicht durchgezogen. + +**Rig und Clip** liefen unverändert: gleiche Marker-Kalibrierung, gleiche +Erkennung, gleicher Bind (`PSEUDO_VOXELS`, 30 Deform-Bones), gleiches +Rotations-Retargeting. Der Klingenabstand bleibt bei ±0,154 m. + +**Werkzeug.** Der Ablauf steckt jetzt in `tools/blender/build_skater.py`: +ein Aufruf riggt, retargetet und exportiert. Das Skript startet nach dem Bind +einen zweiten, headless Blender-Prozess für Retarget und Export, weil der +glTF-Importer in derselben Datei an der zweiten Armatur namens `rig` +scheitert (`KeyError: 'arm_stretch.l'`). Mit der Trennung ist der Lauf +deterministisch: das Werkzeug erzeugt byte-identisch dieselbe GLB wie der +manuelle Lauf. + +**Kosten gesamt:** 30 Credits (v007) + 20 (Bild-Edit) + 50 (Ultra) = 100 +Credits von 1.000; Rest 900. diff --git a/rinkplanner/assets/asset_manifest.json b/rinkplanner/assets/asset_manifest.json index 9612389..1835929 100644 --- a/rinkplanner/assets/asset_manifest.json +++ b/rinkplanner/assets/asset_manifest.json @@ -36,17 +36,17 @@ }, { "id": "character.skater.figure_tripo_glide", - "version": 1, + "version": 2, "kind": "character", "format": "glb", - "source": "library/characters/skater_figure_glide_v007.glb", - "target": "assets/external/characters/skater_figure_glide_v007.glb", - "remote": "characters/skater_figure_glide_v007.glb", - "sha256": "be3cf6bb864f1ca6390d919d29ea122f83f6378865d38d2fdafbfe2889e8d45c", - "bytes": 2712248, - "source_scene": "source/characters/skater/skater_rig_v007.blend", + "source": "library/characters/skater_figure_glide_v008.glb", + "target": "assets/external/characters/skater_figure_glide_v008.glb", + "remote": "characters/skater_figure_glide_v008.glb", + "sha256": "7a4bcb63cea146a86e47a20f7e3c10e855ee6ca29d74150a3bb01b4a2f8ef0e4", + "bytes": 3083220, + "source_scene": "source/characters/skater/skater_rig_v008.blend", "created": "2026-11-12", - "license": "Tripo H3.1 via Tripo pay-as-you-go API (task d8ee7a30-c1dc-4873-8770-4747d98a62ff); rig and Glide retarget built locally with AutoRigPro, own work.", + "license": "Tripo H3.1 via Tripo pay-as-you-go API (image edit task 316752d8-16e7-49c8-beb1-d2223afc9f79, model task 834f0e29-65db-49d2-a02b-7a6239a4d07a); rig and Glide retarget built locally with AutoRigPro, own work.", "placement": { "up_axis": "Y", "facing": "+Z", @@ -64,7 +64,7 @@ "animations": [ "Glide" ], - "notes": "Tripo-Mesh (59.350 Dreiecke, 60k-Budget, Textur v3.5) mit AutoRigPro geriggt; Glide per Rotations-Retargeting von skater_figure_glide_v006 übernommen. Klingen bei x=±0,154 m." + "notes": "Ultra-Lauf (geometry_quality=detailed) aus einem per Tripo-Image-Edit erzeugten Referenzbild im petrolfarbenen Kürkleid: 59.488 Dreiecke, 1,7 m, AutoRigPro-Bind, Glide per Rotations-Retargeting von v006. Klingen bei x=±0,154 m." }, { "id": "character.skater.figure_tripo", diff --git a/rinkplanner/src/presentation3d/skater_3d.gd b/rinkplanner/src/presentation3d/skater_3d.gd index 583454d..b885a63 100644 --- a/rinkplanner/src/presentation3d/skater_3d.gd +++ b/rinkplanner/src/presentation3d/skater_3d.gd @@ -6,7 +6,7 @@ extends Node3D const MANIFEST_PATH := "res://assets/asset_manifest.json" const ASSET_ID := "character.skater.figure_tripo_glide" -const FALLBACK_MODEL_PATH := "res://assets/external/characters/skater_figure_glide_v007.glb" +const FALLBACK_MODEL_PATH := "res://assets/external/characters/skater_figure_glide_v008.glb" const IDLE_ANIMATION := "Glide" const BLADE_LATERAL_OFFSET_M := 0.154 const BLADE_HEIGHT_M := 0.015 diff --git a/tools/blender/build_skater.py b/tools/blender/build_skater.py new file mode 100644 index 0000000..e70a692 --- /dev/null +++ b/tools/blender/build_skater.py @@ -0,0 +1,350 @@ +"""Baut aus einem Tripo-GLB einen geriggten Spielcharakter mit Glide-Clip. + +Ein Befehl, zwei Blender-Läufe: + + blender --python tools/blender/build_skater.py -- \ + /pfad/model.glb /pfad/ausgabe.glb \ + --source-rig rinkplanner/assets/external/characters/skater_figure_glide_v006.glb + +AutoRigPro braucht eine GUI (es greift auf bpy.context.space_data zu) und +läuft deshalb nur im Vordergrund-Lauf. Das Retargeten und der glTF-Export +laufen danach in einem zweiten, headless Prozess: der glTF-Importer verträgt +sich nicht mit einer zweiten, gleichnamigen Armatur in derselben Datei, die +Trennung ist der zuverlässige Weg. + +Ablauf: + 1. Mesh auf 1,70 m skalieren, Füße auf Z=0, Blick -Y (AutoRigPro-Vorne). + 2. AutoRigPro-Smart-Modus, Marker setzen, Rig erkennen, Match to Rig, Bind. + 3. Zwischenstand als .blend speichern. + 4. Headless: Quell-Rig importieren, Clip per Rotations-Retargeting + übertragen (keine Translationen, sonst wandert die Figur), Export mit + ausschließlich den gewichteten Deform-Bones. + +Marker-Kalibrierung: die Vorgaben sind für eine 1,70-m-Figur in A-Pose +gemessen und werden mit der tatsächlichen Höhe skaliert. Weicht die Pose stark +ab, eine eigene Marker-Datei übergeben: + + {"root": [0.0, 0.0, 0.95], "neck": [...], ...} + +Schlüssel: root, neck, chin, head_tip, shoulder, elbow, hand, hand_tip, +thigh, knee, foot. Koordinaten in Metern, X = links, -Y = vorn, Z = hoch. +""" + +import argparse +import json +import math +import subprocess +import sys +import traceback + +import bpy +from mathutils import Matrix + +REFERENCE_HEIGHT = 1.70 + +DEFAULT_MARKERS = { + "root": (0.000, 0.000, 0.950), + "neck": (0.000, 0.000, 1.500), + "chin": (0.000, -0.090, 1.560), + "head_tip": (0.000, 0.000, 1.700), + "shoulder": (0.155, 0.020, 1.370), + "elbow": (0.210, 0.010, 1.100), + "hand": (0.300, -0.060, 0.860), + "hand_tip": (0.340, -0.100, 0.760), + "thigh": (0.090, 0.000, 0.920), + "knee": (0.100, 0.000, 0.470), + "foot": (0.100, 0.000, 0.090), +} + +# Quell-Bone -> Ziel-Bone. Beide Rigs stammen aus AutoRigPro und teilen die +# Namen; die Twist-Helfer der Produktionsfigur werden mitgenommen. +BONE_MAP = { + "root.x": "root.x", + "spine_01.x": "spine_01.x", + "spine_02.x": "spine_02.x", + "spine_03.x": "spine_03.x", + "neck.x": "neck.x", + "head.x": "head.x", + "shoulder.l": "shoulder.l", + "shoulder.r": "shoulder.r", + "arm_stretch.l": "arm_stretch.l", + "arm_stretch.r": "arm_stretch.r", + "forearm_stretch.l": "forearm_stretch.l", + "forearm_stretch.r": "forearm_stretch.r", + "hand.l": "hand.l", + "hand.r": "hand.r", + "thigh_stretch.l": "thigh_stretch.l", + "thigh_stretch.r": "thigh_stretch.r", + "leg_stretch.l": "leg_stretch.l", + "leg_stretch.r": "leg_stretch.r", + "foot.l": "foot.l", + "foot.r": "foot.r", + "toes_01.l": "toes_01.l", + "toes_01.r": "toes_01.r", + "thigh_twist.l": "thigh_twist.l", + "thigh_twist.r": "thigh_twist.r", + "leg_twist.l": "leg_twist.l", + "leg_twist.r": "leg_twist.r", + "forearm_twist.l": "forearm_twist.l", + "forearm_twist.r": "forearm_twist.r", +} + + +def parse_args(): + argv = sys.argv[sys.argv.index("--") + 1:] if "--" in sys.argv else [] + parser = argparse.ArgumentParser(prog="build_skater.py") + parser.add_argument("input", help="GLB mit dem Rohmesh") + parser.add_argument("output", help="Ziel-GLB") + parser.add_argument("--source-rig", required=True, + help="GLB mit Skelett und dem zu übernehmenden Clip") + parser.add_argument("--clip", default="Glide") + parser.add_argument("--height", type=float, default=REFERENCE_HEIGHT) + parser.add_argument("--markers", help="JSON mit Marker-Positionen") + parser.add_argument("--work-dir", default="/tmp/opencode/build_skater") + parser.add_argument("--phase", choices=["auto", "rig", "retarget"], default="auto") + parser.add_argument("--blend", help="Zwischenstand, den die Rig-Phase schreibt") + return parser.parse_args(argv) + + +def context_override(): + win = bpy.context.window_manager.windows[0] + area = next(a for a in win.screen.areas if a.type == "VIEW_3D") + region = next(r for r in area.regions if r.type == "WINDOW") + return dict(window=win, screen=win.screen, area=area, region=region) + + +def markers_for(height, path): + if path: + with open(path, "r", encoding="utf-8") as handle: + data = json.load(handle) + return {key: tuple(float(v) for v in value) for key, value in data.items()} + factor = height / REFERENCE_HEIGHT + return {key: tuple(component * factor for component in value) + for key, value in DEFAULT_MARKERS.items()} + + +def fit_mesh(path, height): + bpy.ops.wm.read_homefile(use_empty=True) + bpy.ops.import_scene.gltf(filepath=path) + mesh = next(o for o in bpy.data.objects if o.type == "MESH") + + mesh.data.transform(mesh.matrix_world) + mesh.matrix_world = Matrix.Identity(4) + mesh.data.transform(Matrix.Rotation(-math.pi / 2, 4, "Z")) + + coords = [v.co for v in mesh.data.vertices] + low = min(c.z for c in coords) + high = max(c.z for c in coords) + mesh.data.transform(Matrix.Scale(height / (high - low), 4)) + + coords = [v.co for v in mesh.data.vertices] + low_x = min(c.x for c in coords) + high_x = max(c.x for c in coords) + low_y = min(c.y for c in coords) + high_y = max(c.y for c in coords) + low_z = min(c.z for c in coords) + mesh.data.transform(Matrix.Translation( + (-(low_x + high_x) / 2, -(low_y + high_y) / 2, -low_z))) + + width = high_x - low_x + depth = high_y - low_y + if width < depth: + print("WARNUNG: Mesh ist breiter in Y als in X – Blickrichtung prüfen " + "(AutoRigPro erwartet -Y).", file=sys.stderr) + print(f"MESH: {width:.3f} breit, {depth:.3f} tief, {height:.3f} hoch") + return mesh + + +def build_rig(mesh, markers): + scene = bpy.context.scene + bpy.ops.object.select_all(action="DESELECT") + mesh.select_set(True) + bpy.context.view_layer.objects.active = mesh + + with bpy.context.temp_override(**context_override()): + bpy.ops.id.get_selected_objects("EXEC_DEFAULT") + + scene.arp_smart_sym = True + scene.arp_fingers_enable = False + scene.arp_bind_engine = "PSEUDO_VOXELS" + + with bpy.context.temp_override(**context_override()): + for name in markers: + bpy.ops.id.add_marker("EXEC_DEFAULT", body_part=name) + + for name, location in markers.items(): + marker = bpy.data.objects.get(name + "_loc") + if marker is None: + raise RuntimeError(f"Marker {name} wurde nicht angelegt") + marker.location = location + + with bpy.context.temp_override(**context_override()): + bpy.ops.id.go_detect("EXEC_DEFAULT") + + rig = bpy.data.objects.get("rig") + if rig is None: + raise RuntimeError("AutoRigPro hat kein Rig erzeugt – Marker prüfen") + + with bpy.context.temp_override(**context_override()): + bpy.ops.arp.match_to_rig("EXEC_DEFAULT") + + bpy.ops.object.select_all(action="DESELECT") + mesh.select_set(True) + rig.select_set(True) + bpy.context.view_layer.objects.active = rig + with bpy.context.temp_override(**context_override()): + bpy.ops.arp.bind_to_rig("EXEC_DEFAULT") + + weighted = {group.name for group in mesh.vertex_groups} + print(f"RIG: {len(rig.data.bones)} Bones, {len(weighted)} gewichtete Gruppen") + return rig, weighted + + +def hierarchy_order(rig): + order = [] + + def walk(bone, depth): + order.append((depth, bone.name)) + for child in bone.children: + walk(child, depth + 1) + + for bone in rig.data.bones: + if bone.parent is None: + walk(bone, 0) + return [name for _, name in order] + + +def phase_rig(args): + markers = markers_for(args.height, args.markers) + mesh = fit_mesh(args.input, args.height) + build_rig(mesh, markers) + bpy.ops.wm.save_as_mainfile(filepath=args.blend) + print(f"BLEND: {args.blend}") + + +def phase_retarget(args): + bpy.ops.wm.open_mainfile(filepath=args.blend) + rig = bpy.data.objects["rig"] + mesh = next(o for o in bpy.data.objects + if o.type == "MESH" and 'tripo' in o.name.lower()) + weighted = {group.name for group in mesh.vertex_groups} + + bpy.ops.import_scene.gltf(filepath=args.source_rig) + source = next(o for o in bpy.data.objects if o.type == "ARMATURE" and o is not rig) + action = bpy.data.actions.get(args.clip) + if action is None: + raise RuntimeError(f"Clip {args.clip} fehlt im Quell-GLB") + source.animation_data.action = action + start, end = int(action.frame_range[0]), int(action.frame_range[1]) + + rig.animation_data_create() + baked = bpy.data.actions.new(args.clip) + rig.animation_data.action = baked + + order = [n for n in hierarchy_order(rig) if n in weighted and n in BONE_MAP.values()] + for name in order: + back = next(src for src, dst in BONE_MAP.items() if dst == name) + if source.pose.bones.get(back) is None: + raise RuntimeError(f"Quell-Bone {back} fehlt im Quell-Rig") + + scene = bpy.context.scene + for frame in range(start, end + 1): + scene.frame_set(frame) + bpy.context.view_layer.update() + + world = {} + for name in order: + src_name = next(src for src, dst in BONE_MAP.items() if dst == name) + rest_src = source.data.bones[src_name].matrix_local.to_3x3() + rest_tgt = rig.data.bones[name].matrix_local.to_3x3() + delta = source.pose.bones[src_name].matrix.to_3x3() @ rest_src.inverted() + world[name] = (delta @ rest_tgt).to_quaternion() + + posed_parent = {} + for name in order: + bone = rig.data.bones[name] + rest_tgt = bone.matrix_local.to_3x3() + parent = bone.parent + parent_rot = (posed_parent[parent.name] if parent and parent.name in posed_parent + else (parent.matrix_local.to_3x3() if parent else Matrix.Identity(3))) + rest_local = (parent.matrix_local.to_3x3().inverted() @ rest_tgt) if parent else rest_tgt + basis = rest_local.inverted() @ parent_rot.inverted() @ world[name].to_matrix() + pose_bone = rig.pose.bones[name] + pose_bone.rotation_mode = "QUATERNION" + pose_bone.rotation_quaternion = basis.to_quaternion() + pose_bone.keyframe_insert("rotation_quaternion", frame=frame) + posed_parent[name] = world[name].to_matrix() + + scene.frame_start = start + scene.frame_end = end + print(f"CLIP: {args.clip}, Frames {start}-{end}, {len(order)} Bones") + + for obj in list(bpy.data.objects): + if obj.type == "ARMATURE" and obj is not rig: + for child in list(obj.children): + bpy.data.objects.remove(child, do_unlink=True) + bpy.data.objects.remove(obj, do_unlink=True) + for obj in list(bpy.data.objects): + if obj.type == "MESH" and obj is not mesh and not obj.name.startswith("cs_"): + bpy.data.objects.remove(obj, do_unlink=True) + + for bone in rig.data.bones: + bone.use_deform = bone.name in weighted + + for other in list(bpy.data.actions): + if other is not baked: + bpy.data.actions.remove(other) + baked.name = args.clip + baked.use_fake_user = True + + bpy.ops.object.select_all(action="DESELECT") + mesh.select_set(True) + rig.select_set(True) + bpy.context.view_layer.objects.active = rig + + bpy.ops.export_scene.gltf( + filepath=args.output, + export_format="GLB", + use_selection=True, + export_animations=True, + export_frame_range=True, + export_def_bones=True, + export_anim_single_armature=True, + export_apply=True, + export_yup=True, + ) + print(f"EXPORT: {args.output}") + + +def run_gui_phase(): + args = parse_args() + args.blend = args.blend or args.work_dir.rstrip("/") + "/build_skater.blend" + try: + phase_rig(args) + subprocess.run( + [bpy.app.binary_path, "-b", "--python", __file__, "--", + args.input, args.output, "--source-rig", args.source_rig, + "--clip", args.clip, "--phase", "retarget", "--blend", args.blend], + check=True, + ) + except Exception: + traceback.print_exc() + finally: + bpy.ops.wm.quit_blender() + + +def main(): + args = parse_args() + if args.phase == "retarget": + args.blend = args.blend or args.work_dir.rstrip("/") + "/build_skater.blend" + phase_retarget(args) + return + if bpy.app.background: + raise SystemExit( + "AutoRigPro braucht eine GUI. Aufruf ohne -b, mit DISPLAY:\n" + " blender --python tools/blender/build_skater.py -- --source-rig " + ) + bpy.app.timers.register(run_gui_phase, first_interval=0.5) + + +main() diff --git a/tools/check_export.sh b/tools/check_export.sh index d74c55b..79293a4 100755 --- a/tools/check_export.sh +++ b/tools/check_export.sh @@ -25,7 +25,7 @@ trap 'rm -rf "$TMP_DIR"' EXIT BINARY="$TMP_DIR/rinkplanner.x86_64" LOG="$TMP_DIR/run.log" -GLB="$PROJECT_DIR/assets/external/characters/skater_figure_glide_v007.glb" +GLB="$PROJECT_DIR/assets/external/characters/skater_figure_glide_v008.glb" echo "Exportiere Linux-Release nach $TMP_DIR …" build_preset "Linux" release "$BINARY" @@ -63,11 +63,11 @@ if grep -q "skater_figure_tripo_v001_30k_" "$STRINGS_FILE"; then fi if [[ -f "$GLB" ]]; then - if ! grep -q "skater_figure_glide_v007.glb-" "$STRINGS_FILE"; then + if ! grep -q "skater_figure_glide_v008.glb-" "$STRINGS_FILE"; then echo "FEHLER: Die Skater-Szene fehlt im Export." >&2 exit 1 fi - if ! grep -q "skater_figure_glide_v007_Color" "$STRINGS_FILE"; then + if ! grep -q "skater_figure_glide_v008_Color" "$STRINGS_FILE"; then echo "FEHLER: Die Skater-Texturen fehlen im Export." >&2 exit 1 fi