diff --git a/.gitignore b/.gitignore index 7392264..9baf099 100644 --- a/.gitignore +++ b/.gitignore @@ -18,6 +18,9 @@ mono_crash.*.json # Workbench (extern archiviert, nicht versionieren) workbench/ +# Externe 3D-Assets (liegen im Workbench-Archiv, werden per Manifest synchronisiert) +rinkplanner/assets/external/ + # Export builds /build/ diff --git a/README.md b/README.md index 07a5ac8..3dbad51 100644 --- a/README.md +++ b/README.md @@ -8,4 +8,5 @@ Planner for Figure Skating free skate - **Architektur und Entscheidungen:** [`docs/architecture.md`](docs/architecture.md) - **ISU-Regelwerk:** [`docs/isu-rules.md`](docs/isu-rules.md) - **Roadmap:** [`docs/roadmap.md`](docs/roadmap.md) +- **3D-Assets:** [`docs/assets.md`](docs/assets.md) - **Builds:** [`docs/builds.md`](docs/builds.md) diff --git a/docs/architecture.md b/docs/architecture.md index 32de37f..f47ddda 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -3,8 +3,8 @@ Stand: 2026-10-31 Grundlage: `rinkplanner/rinkplanner_definition_agent_guidelines.md` Übergeordnete Reihenfolge: `docs/roadmap.md` -Letzte Session: `docs/findings-2026-10-31-sprungkombinationen.md` -(Session davor: `docs/findings-2026-10-31-adult-2026-27.md`) +Letzte Session: `docs/findings-2026-10-31-arp-rig.md` +(Session davor: `docs/findings-2026-10-31-sprungkombinationen.md`) ## 1. Leitentscheidung @@ -30,6 +30,8 @@ wird nicht weiterentwickelt. Phase 2 konsumiert später dasselbe Datenmodell │ └── whiteboard/ # Phase 1: view / ctrl / io ├── scenes/ # dünne Szenen, die Views zusammensetzen ├── assets/ + │ ├── asset_manifest.json # externe 3D-Assets (Metadaten) + │ └── external/ # synchronisiert, gitignored ├── tests/ # headless GDScript-Tests └── prototype/3d_test/ # alter 3D-Test, eingefroren ``` @@ -170,6 +172,17 @@ Text erhalten. Sprungfolgen verlangen einen Axel als zweiten oder dritten Sprung. Der Export verwendet die zusammengesetzte Caption (`3Lz+2T`, `3Lz+2A+SEQ`). +**D13 – 3D-Assets liegen extern, das Repo hält nur das Manifest.** +Die Binärdateien (GLB, `.blend`, Texturen) liegen im Workbench-Archiv unter +`~/Documents/workbench_rinkplanner`, nicht im Git-Repo. Das Repo enthält +`assets/asset_manifest.json` mit ID, Quell-/Zielpfad, SHA-256, Größe, +Platzierungsdaten und Rig-Metadaten. `tools/sync_assets.sh` prüft beide +Seiten gegen den Hash, kopiert nach `assets/external/` (gitignored) und stößt +den Godot-Import an. Damit bleiben Checkout und Build klein, während die +Arbeitsdateien versioniert und reproduzierbar bleiben. Phase 1 lädt keine +3D-Ressourcen; die Pipeline ist Vorbereitung für Phase 2. Details: +`docs/assets.md`. + ## 4. View- und Controller-Grenzen - **View** (`Node2D`/`Control`) liest das Modell und zeichnet. Sie verändert @@ -439,6 +452,9 @@ Aktueller Stand: PASV/EPSV/MDTM-Parsing, Sync-Stand und die Einstellungs-Verdrahtung. Der FTP-Client wurde zusätzlich gegen den echten Zielserver geprüft (Upload, Download, Übernahme, Konflikt, Aufräumen). +- **3D-Assets:** 48 Assertions für Manifest-Schema, Pfade, Platzierung, + Rig-Metadaten, Hashes und – falls synchronisiert – Größe und SHA-256 der + GLB-Datei. Autosave/Restore wird zusätzlich in einem isolierten `XDG_DATA_HOME` end-to-end geprüft. diff --git a/docs/assets.md b/docs/assets.md new file mode 100644 index 0000000..75009f7 --- /dev/null +++ b/docs/assets.md @@ -0,0 +1,160 @@ +# 3D-Assets (extern) + +Stand: 2026-10-31 + +Die 3D-Assets liegen bewusst außerhalb des Git-Repos. Das Repo enthält nur +ein Manifest, ein Sync-Werkzeug und die Dokumentation. Die Binärdateien +bleiben im Workbench-Archiv. + +## Verzeichnisse + +``` +/home/torsten/Documents/workbench_rinkplanner/ +├── inbox/ # Eingang, unverändert lassen +├── library/ # kuratiert, vom Manifest referenziert +│ └── characters/ +├── source/ # .blend, Rig, Rohdaten +│ └── characters/skater/ +└── archive/ # alte Stände, Videos, Bilder +``` + +``` +rinkplanner/ +├── assets/ +│ ├── asset_manifest.json # versioniert +│ └── external/ # gitignored, per Sync befüllt +└── tests/run_asset_manifest_tests.gd +tools/sync_assets.sh +``` + +`assets/external/` wird nie committet. Ein frischer Checkout braucht einmal +`./tools/sync_assets.sh --sync`, sonst fehlen die 3D-Dateien. + +## Workflow + +1. Neue Datei in `inbox/` ablegen. +2. Prüfen, bei Bedarf konvertieren und als versionierte Datei nach + `library/` legen (`..._v001.glb`, `..._v002.glb`). +3. Die bearbeitbare Quelle (`.blend`, Rig, Referenzvideo) nach `source/`. +4. Eintrag in `rinkplanner/assets/asset_manifest.json` ergänzen: + ID, Quelle, Ziel, SHA-256, Größe, Platzierung, Rig, Animationen. +5. `./tools/sync_assets.sh --sync` kopiert und importiert. +6. Vor dem Commit `./tools/sync_assets.sh --check` laufen lassen. + +### Befehle + +```bash +./tools/sync_assets.sh --check # Standard: nur prüfen +./tools/sync_assets.sh --sync # fehlende Dateien kopieren + Godot-Import +./tools/sync_assets.sh --sync --force # abweichendes Ziel überschreiben +``` + +Umgebungsvariablen: + +| Variable | Standard | Zweck | +| :--- | :--- | :--- | +| `RINKPLANNER_WORKBENCH` | `~/Documents/workbench_rinkplanner` | Archivpfad | +| `GODOT` | `/opt/godot/Godot_v4.7.2-stable_linux.x86_64` | Import-Binary | + +Das Skript prüft **Quelle und Ziel** gegen den Hash aus dem Manifest. Eine +still veränderte Workbench-Datei wird nicht kopiert, sondern gemeldet. + +## Manifest + +```json +{ + "id": "character.skater.figure", + "version": 2, + "kind": "character", + "format": "glb", + "source": "library/characters/skater_figure_rigged_deform_v002.glb", + "target": "assets/external/characters/skater_figure_rigged_deform_v002.glb", + "sha256": "1c1f0646…", + "bytes": 8345424, + "source_scene": "source/characters/skater/skater_rig_v002.blend", + "placement": { + "up_axis": "Y", + "facing": "+Z", + "pivot": "feet", + "height_m": 1.898, + "ground_offset_m": 0.0 + }, + "rig": { + "type": "humanoid", + "control_bones": 226, + "deform_bones": 30, + "bind": "PSEUDO_VOXELS" + }, + "animations": [] +} +``` + +| Feld | Bedeutung | +| :--- | :--- | +| `id` | stabile Kennung; Code und Szenen referenzieren die ID, nicht den Dateinamen | +| `version` | Zähler der kuratierten Fassung | +| `source` | Pfad relativ zum Workbench-Archiv | +| `target` | Pfad relativ zum Godot-Projekt, immer unter `assets/external/` | +| `sha256` / `bytes` | Integritätsprüfung | +| `source_scene` | bearbeitbare Quelle (`.blend`) für Rig/Animation | +| `placement` | Up-Achse, Blickrichtung, Pivot und Höhe für die 3D-Szene | +| `rig` | Control-/Deform-Bones und Bind-Verfahren | +| `animations` | Liste der exportierten Clipnamen | + +## Versionierung + +- Dateinamen tragen `_vNNN`; vorhandene Versionen werden nicht überschrieben. +- Eine neue Fassung ist eine neue Datei plus neuer Manifest-Eintrag bzw. + aktualisierte `version` und `sha256`. +- Alte Versionen bleiben in `library/` und im Archiv nachvollziehbar. +- Nicht parsebare oder verworfene Experimente gehören nicht ins Manifest. + +## Godot und Export + +- `assets/external/` ist gitignored und wird nach dem Sync importiert. +- `asset_manifest.json` wird über `include_filter="*.json"` mit exportiert. +- Die aktuellen Phase-1-Export-Presets schließen `assets/external/*` aus. + Für einen 3D-Build muss bewusst ein eigenes Preset die Dateien einschließen. + Desktop kann die GLB einbetten; für Android sind 1K-Texturen oder ein + separater Asset-Pack vorgesehen. +- Phase 1 bleibt unberührt: Der 2D-Code lädt keine 3D-Ressourcen. + +## Aktueller Bestand + +| ID | Datei | Größe | Rig | Clips | +| :--- | :--- | ---: | :--- | :--- | +| `character.skater.figure` | `skater_figure_rigged_deform_v002.glb` | 8,35 MB | 226 Control / 30 Deform | keine (Produktion) | + +Testdateien (nicht im Manifest): `skater_figure_anim_test_v001.glb` mit dem +2-Sekunden-Clip `TestWave`. + +## Rig-Pipeline (AutoRigPro) + +1. GLB in Blender importieren, Füße auf Z=0, Transform anwenden. +2. ARP Smart Rig: Marker für Neck, Chin, Shoulder, Hand, Root, Foot setzen. +3. `PSEUDO_VOXELS` als Bind-Engine; das Mesh hat 37 Inseln und offene Kanten, + Heat-Map-Weighting ist dafür ungeeignet. +4. **`Match to Rig` ist Pflicht:** Erst danach sitzen Knie, Füße und Arme + exakt auf dem Mesh. Der erste Auto-Rig-Lauf hatte die Füße bei x = 0,24 + statt 0,10. +5. Animationen auf dem Control-Rig erstellen (IK/FK, Fußrollen, Root Motion). +6. Export mit `export_def_bones=True`; der Exporter backt Constraints + automatisch. Im GLB landen nur die 30 Deform-Bones. +7. Ergebnis in Godot prüfen (`tests/manual/inspect_rig.gd`, + `tests/manual/capture_rig.gd`). + +Details und Messwerte: `docs/findings-2026-10-31-arp-rig.md`. + +## Backup und Lizenz + +- Das Workbench-Archiv liegt außerhalb des Repos und wird **nicht** vom + Git-Remote gesichert. `library/` und `source/` separat sichern + (restic/rsync). +- Die Skaterin ist ein eigenes GenAI-Asset; das Rig wurde mit AutoRigPro + erstellt. Vor einer Veröffentlichung die Lizenz der Basistexturen prüfen. + +## Tests + +`tests/run_asset_manifest_tests.gd` prüft Schema, Pfade, Hashes und – falls +synchronisiert – Größe und SHA-256 der Zieldatei. Fehlt das Asset (z. B. in +CI), wird der Dateicheck übersprungen, der Schema-Test bleibt aktiv. diff --git a/docs/findings-2026-10-31-arp-rig.md b/docs/findings-2026-10-31-arp-rig.md new file mode 100644 index 0000000..7b79a29 --- /dev/null +++ b/docs/findings-2026-10-31-arp-rig.md @@ -0,0 +1,120 @@ +# Findings 2026-10-31 – AutoRigPro, Skater-Rig und Asset-Pipeline + +## Ziel + +Prüfen, ob sich die GenAI-Skaterin mit AutoRigPro in Blender 5.2 riggen +lässt, ob der Export nach Godot trägt und wie die externen Assets +reproduzierbar ins Projekt kommen. + +## Ausgangsdatei + +`workbench_rinkplanner/inbox/figure_skater_blades_aligned.glb` + +| Eigenschaft | Wert | +| :--- | :--- | +| Mesh | 8.188 Vertices, 13.956 Dreiecke, 1 Objekt | +| Topologie | 37 zusammenhängende Inseln, 2.346 offene/Non-Manifold-Kanten | +| Texturen | 3 × 2048² PNG (BaseColor, Normal, MetallicRoughness) | +| Maße | 1,66 × 0,35 × 1,90 m, Füße bei Z = 0 | +| Ausrichtung | T-Pose, Blick +Z, Pivot Körpermitte | +| Animation | keine, kein Skelett | + +## AutoRigPro + +- ARP liegt als Blender-5.2-Extension unter + `~/.config/blender/5.2/extensions/superhivemarket_com/`. +- Die AI-Marker-Dateien fehlen (`~/Documents/AutoRigPro/AI` existiert nicht). + Die Marker wurden deshalb skriptbasiert gesetzt: + Neck, Chin, Head Tip, Root, Thigh, Knee, Foot, Shoulder, Elbow, Hand, + Hand Tip. +- Smart Rig mit `arp_smart_sym = True`, Finger aus, Bind-Engine + `PSEUDO_VOXELS`. +- Ergebnis: 226-Bone-Control-Rig, 33 Deform-Bones, Bindung in 1,3 s. + +### Befund: erste Platzierung war falsch + +Der erste Lauf setzte die Beinkette zu weit außen: + +| Knochen | erster Lauf | korrekt | +| :--- | ---: | ---: | +| Fuß x | 0,24 | 0,10 | +| Knie x | 0,17 | 0,095 | +| Hand z | 1,17 | 1,50 | + +Die Reference-Bones waren bereits korrekt; nur die Deform-/IK-Kette wich ab. +**`arp.match_to_rig` („Match to Rig")** baut die Deform-Kette aus den +Reference-Bones neu, aktualisiert die Gewichte und setzt die Armature-Scale +auf 1,0. Danach sitzen Fuß, Knie, Hand und Schulter exakt auf dem Mesh. +Dieser Schritt ist bei diesem Mesh-Typ Pflicht. + +### Testpose + +Arm hoch/tief, Bein gehoben, Kopf gedreht, Oberkörper geneigt. Rock, Haare +und Schlittschuhe folgen ohne sichtbare Artefakte. Die Bindung wurde nicht +manuell nachgearbeitet. + +## Export + +| Variante | Bones | Größe | +| :--- | ---: | ---: | +| vollständiger Control-Rig | 226 | 8,41 MB | +| nur Deform-Bones (`export_def_bones`) | 30 | 8,35 MB | + +Der Exporter meldet: + +- mehr als 4 Joint-Einflüsse → auf die 4 stärksten gekürzt und normalisiert +- mehrere Shader-Tex-Image-Knoten → Sampler-Warnung, visuell unauffällig +- Constraints nicht glTF-fähig → Animationen werden gebacken + +## Godot + +- Import über `res://assets/external/characters/`. +- `Skeleton3D` mit 30 Bones, eine skinnende `MeshInstance3D`, AABB + 1,659 × 1,898 × 0,352 m, Material `model`. +- Testclip `TestWave`: 2,0 s, 90 Kanäle (3 pro Joint), als + `AnimationPlayer` mit Länge 2,0 s importiert und bei t = 1,0 gerendert. +- Prüfwerkzeuge: `tests/manual/inspect_rig.gd`, `tests/manual/capture_rig.gd`. + +## Asset-Pipeline + +- `assets/asset_manifest.json` beschreibt ID, Quelle, Ziel, SHA-256, Größe, + Platzierung und Rig-Metadaten. +- `tools/sync_assets.sh --check|--sync [--force]` prüft Quelle und Ziel gegen + den Hash, kopiert nach `assets/external/` und importiert in Godot. +- `assets/external/` ist gitignored. +- Die Phase-1-Export-Presets schließen `assets/external/*` aus; 3D-Builds + brauchen ein eigenes Preset. +- Neuer Test `tests/run_asset_manifest_tests.gd`: 48 Assertions für Schema, + Pfade, Platzierung, Rig-Daten und optional die synchronisierte Datei. +- Gesamtsuite: **1123 Assertions** grün. + +## Dateien + +``` +workbench/source/characters/skater/ +├── skater_rig_v002.blend # Produktions-Rig, ohne Testaktion +├── skater_anim_test.blend # Rig + TestWave +├── skater_rig_v001.blend # erster Lauf (vergleichen) +└── skater_rig_test_01.blend # vor dem Rig + +workbench/library/characters/ +├── skater_figure_rigged_deform_v002.glb # 30 Bones, 8,35 MB +├── skater_figure_anim_test_v001.glb # + TestWave +└── ... (Vergleichsversionen) +``` + +## Entscheidungen + +- **D13:** 3D-Assets bleiben extern; das Repo hält Manifest und Sync-Werkzeug. +- Der Produktions-Rig bleibt im `.blend`; exportiert werden nur Deform-Bones. +- Animationen werden beim glTF-Export gebacken, nicht als Constraints + mitgeschleppt. +- Der Testclip bleibt aus dem Produktions-Rig und aus dem Manifest. + +## Offen + +- 3D-Rink und Skater im Godot-Prototyp bewegen (Kurven-Sampling aus Phase 1). +- Rotoscoping-Workflow: Referenzvideo, Kamera, Action-/NLA-Konventionen. +- Erste echte Clips (Vorwärtsgleiten, Rückwärts, Pirouette). +- Android: Texturen auf 1K reduzieren oder separater Asset-Pack. +- Workbench-Backup außerhalb des Repos sicherstellen. diff --git a/docs/roadmap.md b/docs/roadmap.md index c33afd0..5a35706 100644 --- a/docs/roadmap.md +++ b/docs/roadmap.md @@ -182,10 +182,14 @@ UI-Feedback der Tester ohnehin noch ausstehen. ## Phase 2 – 3D-Präsentation -- [ ] 3D-Rink und Skater auf Basis desselben Datenmodells +- [x] Externe Asset-Pipeline (Manifest, Hash-Prüfung, Sync nach `assets/external/`) +- [x] Geriggter Skater (AutoRigPro, 226 Control-/30 Deform-Bones, glTF-Export) +- [x] Animations-Bake und Godot-Import eines Testclips (`TestWave`) +- [ ] 3D-Rink und Skater auf Basis desselben Datenmodells im Godot-Prototyp +- [ ] Rotoscoping-Workflow und erste echte Animationsclips - [ ] NLA-/Animations-Tracks aus Blender - [ ] Blender-MCP und Godot-Editor-MCP für den Asset-Workflow -- [ ] Klare Trennung: Phase 1 bleibt ohne 3D-Abhängigkeiten lauffähig +- [x] Klare Trennung: Phase 1 bleibt ohne 3D-Abhängigkeiten lauffähig ## Bewusst nicht jetzt diff --git a/rinkplanner/assets/asset_manifest.json b/rinkplanner/assets/asset_manifest.json new file mode 100644 index 0000000..e4c69bb --- /dev/null +++ b/rinkplanner/assets/asset_manifest.json @@ -0,0 +1,34 @@ +{ + "schema_version": 1, + "description": "Externe 3D-Assets. Die Binärdateien liegen im Workbench-Archiv und werden mit tools/sync_assets.sh nach rinkplanner/assets/external/ kopiert. Das Verzeichnis ist gitignored.", + "assets": [ + { + "id": "character.skater.figure", + "version": 2, + "kind": "character", + "format": "glb", + "source": "library/characters/skater_figure_rigged_deform_v002.glb", + "target": "assets/external/characters/skater_figure_rigged_deform_v002.glb", + "sha256": "1c1f06461b58b02d9b8332a756fdc88f533ff2d25f65a59d21ca0209b65128cb", + "bytes": 8345424, + "source_scene": "source/characters/skater/skater_rig_v002.blend", + "created": "2026-10-31", + "license": "Eigenes GenAI-Asset, Rig mit AutoRigPro erstellt.", + "placement": { + "up_axis": "Y", + "facing": "+Z", + "pivot": "feet", + "height_m": 1.898, + "ground_offset_m": 0.0 + }, + "rig": { + "type": "humanoid", + "control_bones": 226, + "deform_bones": 30, + "bind": "PSEUDO_VOXELS" + }, + "animations": [], + "notes": "T-Pose, statisches Rig ohne Clips. Testclip und Vergleichsversionen liegen in derselben Workbench-Library." + } + ] +} diff --git a/rinkplanner/export_presets.cfg b/rinkplanner/export_presets.cfg index ac5f996..90f0dd5 100644 --- a/rinkplanner/export_presets.cfg +++ b/rinkplanner/export_presets.cfg @@ -8,7 +8,7 @@ dedicated_server=false custom_features="" export_filter="all_resources" include_filter="*.json" -exclude_filter="tests/*,prototype/*,docs/*,addons/*,assets/models/*" +exclude_filter="tests/*,prototype/*,docs/*,addons/*,assets/models/*,assets/external/*" export_path="build/linux/rinkplanner.x86_64" patches=PackedStringArray() encryption_include_filters="" @@ -40,7 +40,7 @@ dedicated_server=false custom_features="" export_filter="all_resources" include_filter="*.json" -exclude_filter="tests/*,prototype/*,docs/*,addons/*,assets/models/*" +exclude_filter="tests/*,prototype/*,docs/*,addons/*,assets/models/*,assets/external/*" export_path="build/windows/rinkplanner.exe" patches=PackedStringArray() encryption_include_filters="" @@ -95,7 +95,7 @@ dedicated_server=false custom_features="" export_filter="all_resources" include_filter="*.json" -exclude_filter="tests/*,prototype/*,docs/*,addons/*,assets/models/*" +exclude_filter="tests/*,prototype/*,docs/*,addons/*,assets/models/*,assets/external/*" export_path="build/macos/rinkplanner.zip" patches=PackedStringArray() encryption_include_filters="" @@ -215,7 +215,7 @@ dedicated_server=false custom_features="" export_filter="all_resources" include_filter="*.json" -exclude_filter="tests/*,prototype/*,docs/*,addons/*,assets/models/*" +exclude_filter="tests/*,prototype/*,docs/*,addons/*,assets/models/*,assets/external/*" export_path="build/android/rinkplanner.apk" patches=PackedStringArray() encryption_include_filters="" diff --git a/rinkplanner/tests/manual/capture_rig.gd b/rinkplanner/tests/manual/capture_rig.gd new file mode 100644 index 0000000..01a9459 --- /dev/null +++ b/rinkplanner/tests/manual/capture_rig.gd @@ -0,0 +1,87 @@ +extends SceneTree + +## Rendert ein externes GLB mit Kamera, Licht und Boden für die Sichtprüfung. +## +## Aufruf: +## xvfb-run -a godot --path rinkplanner \ +## --script res://tests/manual/capture_rig.gd -- 640 840 /tmp/opencode/godot_rig.png + +const MODEL_PATH := "res://assets/external/characters/skater_figure_rigged_deform_v002.glb" + + +func _init() -> void: + _capture.call_deferred() + + +func _capture() -> void: + var args := OS.get_cmdline_user_args() + var width := int(args[0]) if args.size() > 0 else 640 + var height := int(args[1]) if args.size() > 1 else 840 + var output := args[2] if args.size() > 2 else "user://capture_rig.png" + var model_path := args[3] if args.size() > 3 else MODEL_PATH + var anim_time := float(args[4]) if args.size() > 4 else -1.0 + + var packed := load(model_path) as PackedScene + if packed == null: + push_error("GLB konnte nicht geladen werden: " + model_path) + quit(1) + return + + var scene := Node3D.new() + root.add_child(scene) + var instance := packed.instantiate() + scene.add_child(instance) + + if anim_time >= 0.0: + var players := instance.find_children("*", "AnimationPlayer", true, false) + if not players.is_empty(): + var player := players[0] as AnimationPlayer + var animation_names := player.get_animation_list() + if not animation_names.is_empty(): + player.play(animation_names[0]) + player.seek(anim_time, true) + player.pause() + + var environment := Environment.new() + environment.background_mode = Environment.BG_COLOR + environment.background_color = Color("d9dee6") + environment.ambient_light_source = Environment.AMBIENT_SOURCE_COLOR + environment.ambient_light_color = Color("ffffff") + environment.ambient_light_energy = 0.7 + var world_environment := WorldEnvironment.new() + world_environment.environment = environment + scene.add_child(world_environment) + + var key_light := DirectionalLight3D.new() + key_light.rotation_degrees = Vector3(-50.0, -35.0, 0.0) + key_light.light_energy = 1.4 + scene.add_child(key_light) + + var ground_mesh := PlaneMesh.new() + ground_mesh.size = Vector2(6.0, 6.0) + var ground := MeshInstance3D.new() + ground.mesh = ground_mesh + var ground_material := StandardMaterial3D.new() + ground_material.albedo_color = Color("cfd6df") + ground.set_surface_override_material(0, ground_material) + scene.add_child(ground) + + var camera := Camera3D.new() + camera.fov = 42.0 + scene.add_child(camera) + camera.look_at_from_position( + Vector3(2.6, 1.45, 3.9), + Vector3(0.0, 0.95, 0.0), + Vector3.UP + ) + camera.current = true + + root.size = Vector2i(width, height) + await process_frame + await process_frame + await process_frame + + var image := root.get_texture().get_image() + image.save_png(output) + print("SAVED ", output) + quit(0) diff --git a/rinkplanner/tests/manual/capture_rig.gd.uid b/rinkplanner/tests/manual/capture_rig.gd.uid new file mode 100644 index 0000000..ad9ffdd --- /dev/null +++ b/rinkplanner/tests/manual/capture_rig.gd.uid @@ -0,0 +1 @@ +uid://dogoc8fyx1pj2 diff --git a/rinkplanner/tests/manual/inspect_rig.gd b/rinkplanner/tests/manual/inspect_rig.gd new file mode 100644 index 0000000..f6dbf3a --- /dev/null +++ b/rinkplanner/tests/manual/inspect_rig.gd @@ -0,0 +1,57 @@ +extends SceneTree + +## Headless-Prüfung für ein externes GLB mit Skelett. +## +## Aufruf: +## godot --headless --path rinkplanner --script res://tests/manual/inspect_rig.gd + +const MODEL_PATH := "res://assets/external/characters/skater_figure_rigged_deform_v002.glb" + + +func _init() -> void: + _run.call_deferred() + + +func _run() -> void: + var args := OS.get_cmdline_user_args() + var model_path := args[0] if args.size() > 0 else MODEL_PATH + var packed := load(model_path) as PackedScene + if packed == null: + push_error("GLB konnte nicht geladen werden: " + model_path) + quit(1) + return + + var instance := packed.instantiate() + root.add_child(instance) + + var skeletons := instance.find_children("*", "Skeleton3D", true, false) + var meshes := instance.find_children("*", "MeshInstance3D", true, false) + var animations := instance.find_children("*", "AnimationPlayer", true, false) + + print("INSTANCE: ", instance.name) + print("SKELETONS: ", skeletons.size()) + for skeleton: Skeleton3D in skeletons: + print(" BONES: ", skeleton.get_bone_count()) + print(" ROOT_BONES: ", skeleton.get_bone_count() if skeleton.get_bone_count() == 0 else _root_bones(skeleton)) + + print("MESHES: ", meshes.size()) + for mesh_instance: MeshInstance3D in meshes: + var aabb := mesh_instance.get_aabb() + print(" AABB_SIZE: ", aabb.size, " SKIN: ", mesh_instance.skin != null) + var material := mesh_instance.get_active_material(0) + print(" MATERIAL: ", material.resource_name if material != null else "") + + print("ANIMATION_PLAYERS: ", animations.size()) + for player: AnimationPlayer in animations: + for animation_name: String in player.get_animation_list(): + var animation := player.get_animation(animation_name) + print(" ANIMATION: ", animation_name, " LENGTH: ", animation.length) + quit(0) + + +func _root_bones(skeleton: Skeleton3D) -> PackedStringArray: + var roots := PackedStringArray() + for index: int in range(skeleton.get_bone_count()): + if skeleton.get_bone_parent(index) == -1: + roots.append(skeleton.get_bone_name(index)) + return roots diff --git a/rinkplanner/tests/manual/inspect_rig.gd.uid b/rinkplanner/tests/manual/inspect_rig.gd.uid new file mode 100644 index 0000000..2463b0a --- /dev/null +++ b/rinkplanner/tests/manual/inspect_rig.gd.uid @@ -0,0 +1 @@ +uid://c8rpij6kym7hd diff --git a/rinkplanner/tests/run_asset_manifest_tests.gd b/rinkplanner/tests/run_asset_manifest_tests.gd new file mode 100644 index 0000000..7205ddf --- /dev/null +++ b/rinkplanner/tests/run_asset_manifest_tests.gd @@ -0,0 +1,258 @@ +extends SceneTree + +## Headless-Prüfung für das externe Asset-Manifest. +## +## Prüft Schema, Pfade, Hashes und – falls vorhanden – die synchronisierten +## Dateien. Fehlt ein Asset (z. B. in CI ohne Workbench), wird der Dateicheck +## übersprungen, ohne den Test fehlschlagen zu lassen. +## +## Aufruf: +## godot --headless --path rinkplanner --script res://tests/run_asset_manifest_tests.gd + +const MANIFEST_PATH := "res://assets/asset_manifest.json" +const EXTERNAL_PREFIX := "assets/external/" +const ALLOWED_KINDS := ["character", "prop", "rink", "animation"] +const ALLOWED_FORMATS := ["glb", "gltf", "png"] + + +var _assertions: int = 0 +var _failures: PackedStringArray = PackedStringArray() + + +func _init() -> void: + _run.call_deferred() + + +func _run() -> void: + _check(FileAccess.file_exists(MANIFEST_PATH), "manifest exists") + + var parsed: Variant = _read_json(MANIFEST_PATH) + _check(parsed is Dictionary, "manifest is valid JSON") + if not parsed is Dictionary: + _finish() + return + + var document: Dictionary = parsed + _check( + int(document.get("schema_version", 0)) == 1, + "manifest uses schema version 1" + ) + + var assets: Variant = document.get("assets", null) + _check(assets is Array, "manifest contains an asset list") + if not assets is Array: + _finish() + return + + var asset_list: Array = assets + _check(not asset_list.is_empty(), "asset list is not empty") + + var seen_ids := {} + var seen_targets := {} + for entry: Variant in asset_list: + _check(entry is Dictionary, "asset entry is an object") + if not entry is Dictionary: + continue + _validate_asset(entry, seen_ids, seen_targets) + + _finish() + + +func _validate_asset( + asset: Dictionary, + seen_ids: Dictionary, + seen_targets: Dictionary +) -> void: + for key: String in [ + "id", + "version", + "kind", + "format", + "source", + "target", + "sha256", + "bytes", + "placement", + "rig", + "animations", + ]: + _check(asset.has(key), "asset has field '%s'" % key) + + var asset_id := str(asset.get("id", "")) + _check(not asset_id.is_empty(), "asset id is not empty") + _check(not asset_id.contains(" "), "asset id has no spaces") + _check(not seen_ids.has(asset_id), "asset id '%s' is unique" % asset_id) + seen_ids[asset_id] = true + + var version := int(asset.get("version", 0)) + _check(version >= 1, "asset '%s' has a positive version" % asset_id) + + var kind := str(asset.get("kind", "")) + _check(kind in ALLOWED_KINDS, "asset '%s' has a known kind" % asset_id) + + var format := str(asset.get("format", "")) + _check(format in ALLOWED_FORMATS, "asset '%s' has a known format" % asset_id) + + var source := str(asset.get("source", "")) + _check(_is_relative_path(source), "asset '%s' source is relative" % asset_id) + _check(not source.contains(".."), "asset '%s' source has no '..'" % asset_id) + + var target := str(asset.get("target", "")) + _check( + target.begins_with(EXTERNAL_PREFIX), + "asset '%s' target lives under %s" % [asset_id, EXTERNAL_PREFIX] + ) + _check(_is_relative_path(target), "asset '%s' target is relative" % asset_id) + _check(not target.contains(".."), "asset '%s' target has no '..'" % asset_id) + _check( + not seen_targets.has(target), + "asset '%s' target is unique" % asset_id + ) + seen_targets[target] = true + + var sha256 := str(asset.get("sha256", "")) + _check(sha256.length() == 64, "asset '%s' has a SHA-256 length" % asset_id) + _check(_is_hex(sha256), "asset '%s' has a hexadecimal SHA-256" % asset_id) + + var size := int(asset.get("bytes", 0)) + _check(size > 0, "asset '%s' has a positive size" % asset_id) + + var placement: Variant = asset.get("placement", null) + _check(placement is Dictionary, "asset '%s' has placement data" % asset_id) + if placement is Dictionary: + _validate_placement(asset_id, placement) + + var rig: Variant = asset.get("rig", null) + _check(rig is Dictionary, "asset '%s' has rig data" % asset_id) + if rig is Dictionary: + _validate_rig(asset_id, rig) + + var animations: Variant = asset.get("animations", null) + _check(animations is Array, "asset '%s' lists animations" % asset_id) + if animations is Array: + for animation: Variant in animations: + _check(animation is String, "asset '%s' animation is a string" % asset_id) + + if asset.has("source_scene"): + var scene_path := str(asset.get("source_scene", "")) + _check( + _is_relative_path(scene_path), + "asset '%s' scene path is relative" % asset_id + ) + + _validate_synced_file(asset_id, target, sha256, size) + + +func _validate_placement(asset_id: String, placement: Dictionary) -> void: + _check( + str(placement.get("up_axis", "")) == "Y", + "asset '%s' uses Y as up axis" % asset_id + ) + _check( + str(placement.get("facing", "")) in ["+Z", "-Z", "+X", "-X"], + "asset '%s' has a valid facing" % asset_id + ) + _check( + not str(placement.get("pivot", "")).is_empty(), + "asset '%s' defines a pivot" % asset_id + ) + _check( + float(placement.get("height_m", 0.0)) > 0.0, + "asset '%s' has a positive height" % asset_id + ) + _check( + placement.get("ground_offset_m", null) is float + or placement.get("ground_offset_m", null) is int, + "asset '%s' has a numeric ground offset" % asset_id + ) + + +func _validate_rig(asset_id: String, rig: Dictionary) -> void: + var control_bones := int(rig.get("control_bones", 0)) + var deform_bones := int(rig.get("deform_bones", 0)) + _check(control_bones > 0, "asset '%s' has control bones" % asset_id) + _check(deform_bones > 0, "asset '%s' has deform bones" % asset_id) + _check( + deform_bones <= control_bones, + "asset '%s' keeps deform bones within the control rig" % asset_id + ) + _check( + not str(rig.get("bind", "")).is_empty(), + "asset '%s' names its bind method" % asset_id + ) + + +func _validate_synced_file( + asset_id: String, + target: String, + expected_sha: String, + expected_size: int +) -> void: + var absolute := "res://" + target + if not FileAccess.file_exists(absolute): + print( + "SKIP: asset '%s' is not synced (%s); run tools/sync_assets.sh --sync" + % [asset_id, target] + ) + return + + var file := FileAccess.open(absolute, FileAccess.READ) + _check(file != null, "asset '%s' can be opened" % asset_id) + if file == null: + return + + _check( + file.get_length() == expected_size, + "asset '%s' has the expected size" % asset_id + ) + var bytes := file.get_buffer(file.get_length()) + var context := HashingContext.new() + context.start(HashingContext.HASH_SHA256) + context.update(bytes) + _check( + context.finish().hex_encode() == expected_sha, + "asset '%s' has the expected SHA-256" % asset_id + ) + + +func _is_relative_path(path: String) -> bool: + return ( + not path.is_empty() + and not path.begins_with("/") + and not path.contains("\\") + and not path.contains(":") + ) + + +func _is_hex(text: String) -> bool: + if text.is_empty(): + return false + for character: String in text: + if not "0123456789abcdef".contains(character): + return false + return true + + +func _read_json(path: String) -> Variant: + var file := FileAccess.open(path, FileAccess.READ) + if file == null: + return null + return JSON.parse_string(file.get_as_text()) + + +func _check(condition: bool, message: String) -> void: + _assertions += 1 + if not condition: + _failures.append(message) + + +func _finish() -> void: + if _failures.is_empty(): + print("PASS: %d assertions" % _assertions) + quit(0) + return + + for failure: String in _failures: + printerr("FAIL: %s" % failure) + printerr("%d of %d assertions failed" % [_failures.size(), _assertions]) + quit(1) diff --git a/rinkplanner/tests/run_asset_manifest_tests.gd.uid b/rinkplanner/tests/run_asset_manifest_tests.gd.uid new file mode 100644 index 0000000..bf53e6d --- /dev/null +++ b/rinkplanner/tests/run_asset_manifest_tests.gd.uid @@ -0,0 +1 @@ +uid://bcyd8l8y1ichl diff --git a/tools/sync_assets.sh b/tools/sync_assets.sh new file mode 100755 index 0000000..21f91de --- /dev/null +++ b/tools/sync_assets.sh @@ -0,0 +1,195 @@ +#!/usr/bin/env bash +# Synchronisiert externe 3D-Assets aus dem Workbench-Archiv in das Godot-Projekt. +# +# Die Binärdateien werden nicht versioniert. Das Manifest +# rinkplanner/assets/asset_manifest.json beschreibt Quelle, Ziel, Hash und +# Metadaten. Nach dem Kopieren wird der Godot-Import angestoßen. +set -euo pipefail + +REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)" +PROJECT_DIR="$REPO_ROOT/rinkplanner" +MANIFEST="$PROJECT_DIR/assets/asset_manifest.json" +WORKBENCH="${RINKPLANNER_WORKBENCH:-$HOME/Documents/workbench_rinkplanner}" +GODOT="${GODOT:-/opt/godot/Godot_v4.7.2-stable_linux.x86_64}" + +MODE="check" +FORCE=0 + +usage() { + cat <<'EOF' +Aufruf: tools/sync_assets.sh [--check|--sync] [--force] + + --check Prüft nur, ob die Ziele vorhanden und hashes korrekt sind (Standard). + --sync Kopiert fehlende Assets und importiert sie in Godot. + --force Überschreibt vorhandene Ziele mit abweichendem Hash (nur mit --sync). + +Umgebung: + RINKPLANNER_WORKBENCH Pfad zum Workbench-Archiv + (Standard: ~/Documents/workbench_rinkplanner) + GODOT Godot-Binary für den Import +EOF +} + +while [[ $# -gt 0 ]]; do + case "$1" in + --check) MODE="check" ;; + --sync) MODE="sync" ;; + --force) FORCE=1 ;; + -h|--help) usage; exit 0 ;; + *) echo "Unbekannte Option: $1" >&2; usage >&2; exit 2 ;; + esac + shift +done + +if [[ ! -f "$MANIFEST" ]]; then + echo "Manifest nicht gefunden: $MANIFEST" >&2 + exit 1 +fi + +if [[ "$FORCE" -eq 1 && "$MODE" != "sync" ]]; then + echo "--force ist nur zusammen mit --sync sinnvoll." >&2 + exit 2 +fi + +mapfile -t rows < <(python3 - "$MANIFEST" <<'PY' +import json +import sys + +with open(sys.argv[1], encoding="utf-8") as handle: + document = json.load(handle) + +for asset in document.get("assets", []): + print("\t".join([ + asset["id"], + asset["source"], + asset["target"], + asset["sha256"], + str(asset["bytes"]), + ])) +PY +) + +if [[ ${#rows[@]} -eq 0 ]]; then + echo "Keine Assets im Manifest." >&2 + exit 1 +fi + +problems=0 +copied=0 + +check_asset() { + local source_path="$1" + local target_path="$2" + local expected_sha="$3" + local expected_bytes="$4" + + if [[ ! -f "$source_path" ]]; then + echo " FEHLT (Quelle): $source_path" >&2 + return 1 + fi + + local actual_bytes actual_sha + actual_bytes="$(stat -c '%s' "$source_path")" + actual_sha="$(sha256sum "$source_path" | cut -d' ' -f1)" + if [[ "$actual_bytes" != "$expected_bytes" || "$actual_sha" != "$expected_sha" ]]; then + echo " HASH-FEHLER (Quelle): $source_path" >&2 + echo " erwartet: $expected_bytes Bytes / $expected_sha" >&2 + echo " gefunden: $actual_bytes Bytes / $actual_sha" >&2 + return 1 + fi + + if [[ ! -f "$target_path" ]]; then + echo " FEHLT (Ziel): $target_path" >&2 + return 1 + fi + + actual_bytes="$(stat -c '%s' "$target_path")" + actual_sha="$(sha256sum "$target_path" | cut -d' ' -f1)" + if [[ "$actual_bytes" != "$expected_bytes" || "$actual_sha" != "$expected_sha" ]]; then + echo " HASH-FEHLER (Ziel): $target_path" >&2 + echo " erwartet: $expected_bytes Bytes / $expected_sha" >&2 + echo " gefunden: $actual_bytes Bytes / $actual_sha" >&2 + return 1 + fi + + return 0 +} + +for row in "${rows[@]}"; do + IFS=$'\t' read -r asset_id relative_source relative_target expected_sha expected_bytes <<< "$row" + source_path="$WORKBENCH/$relative_source" + target_path="$PROJECT_DIR/$relative_target" + + echo "[$asset_id]" + + if [[ "$MODE" == "check" ]]; then + if check_asset "$source_path" "$target_path" "$expected_sha" "$expected_bytes"; then + echo " OK" + else + problems=$((problems + 1)) + fi + continue + fi + + if [[ ! -f "$source_path" ]]; then + echo " FEHLT (Quelle): $source_path" >&2 + problems=$((problems + 1)) + continue + fi + + source_bytes="$(stat -c '%s' "$source_path")" + source_sha="$(sha256sum "$source_path" | cut -d' ' -f1)" + if [[ "$source_bytes" != "$expected_bytes" || "$source_sha" != "$expected_sha" ]]; then + echo " HASH-FEHLER (Quelle): $source_path" >&2 + echo " Manifest und Workbench-Datei passen nicht zusammen." >&2 + problems=$((problems + 1)) + continue + fi + + if [[ -f "$target_path" ]]; then + target_sha="$(sha256sum "$target_path" | cut -d' ' -f1)" + if [[ "$target_sha" == "$expected_sha" ]]; then + echo " OK (bereits synchronisiert)" + continue + fi + if [[ "$FORCE" -ne 1 ]]; then + echo " ABWEICHUNG: $target_path" >&2 + echo " Ziel hat einen anderen Hash. Mit --force überschreiben." >&2 + problems=$((problems + 1)) + continue + fi + fi + + mkdir -p "$(dirname "$target_path")" + cp "$source_path" "$target_path" + target_sha="$(sha256sum "$target_path" | cut -d' ' -f1)" + if [[ "$target_sha" != "$expected_sha" ]]; then + echo " KOPIERFEHLER: $target_path" >&2 + problems=$((problems + 1)) + continue + fi + + echo " Kopiert: $relative_target" + copied=$((copied + 1)) +done + +if [[ "$problems" -gt 0 ]]; then + echo "" >&2 + echo "$problems Asset(s) nicht in Ordnung." >&2 + if [[ "$MODE" == "check" ]]; then + echo "Mit tools/sync_assets.sh --sync kopieren." >&2 + fi + exit 1 +fi + +if [[ "$MODE" == "sync" && "$copied" -gt 0 ]]; then + if [[ -x "$GODOT" ]]; then + echo "Godot-Import..." + "$GODOT" --headless --path "$PROJECT_DIR" --import >/dev/null + else + echo "Godot-Binary nicht gefunden: $GODOT" >&2 + echo "Assets liegen bereit, Import bitte manuell anstoßen." >&2 + fi +fi + +echo "Assets OK." diff --git a/tools/test.sh b/tools/test.sh index 87d4736..2ac816f 100755 --- a/tools/test.sh +++ b/tools/test.sh @@ -60,3 +60,6 @@ fi "$GODOT" --headless --path "$PROJECT_DIR" \ --script res://tests/run_sync_tests.gd + +"$GODOT" --headless --path "$PROJECT_DIR" \ + --script res://tests/run_asset_manifest_tests.gd