From a8c5e61faf6c75c0e1b9fde382ae3eddf780fa57 Mon Sep 17 00:00:00 2001 From: torsten Date: Sat, 31 Oct 2026 15:43:14 +0100 Subject: [PATCH] feat: Folgekamera folgt der Fahrtrichtung - Kamera nutzt die Bahn-Tangente statt des Koerper-Yaw - Rueckwaerts bleibt sie auf der Bahnseite und zeigt die Laeuferin von vorn - Element-Marker behalten die letzte Fahrtrichtung - 61 Praesentations-Assertions (1193 gesamt) --- docs/architecture.md | 20 ++++-- .../findings-2026-10-31-kamera-rueckwaerts.md | 63 +++++++++++++++++++ docs/manual.md | 4 +- docs/roadmap.md | 1 + .../src/presentation3d/presentation_3d.gd | 29 +++++++-- rinkplanner/tests/run_presentation3d_tests.gd | 46 ++++++++++++++ 6 files changed, 151 insertions(+), 12 deletions(-) create mode 100644 docs/findings-2026-10-31-kamera-rueckwaerts.md diff --git a/docs/architecture.md b/docs/architecture.md index 18965dc..8623fa6 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-arm-gewichte.md` -(Session davor: `docs/findings-2026-10-31-kufenspur.md`) +Letzte Session: `docs/findings-2026-10-31-kamera-rueckwaerts.md` +(Session davor: `docs/findings-2026-10-31-arm-gewichte.md`) ## 1. Leitentscheidung @@ -233,6 +233,14 @@ PSEUDO-VOXELS-Gewichte bleichten sonst in `spine_03`/`head`; die offenen Ärmelflächen verlieren dadurch ihr Volumen. Details: `docs/findings-2026-10-31-arm-gewichte.md`. +**D18 – Die Folgekamera folgt der Fahrtrichtung.** +Der Kamera-Rückwärtsversatz kommt aus der Bahn-Tangente, nicht aus dem +Körper-Yaw. Bei Vorwärtsfahrt ist beides gleich; bei Rückwärtsfahrt bleibt +die Kamera auf derselben Bahnseite, während sich die Läuferin zur Kamera +dreht. Dadurch schwenkt die Kamera am Richtungswechsel nicht um 180°, und +die Läuferin ist auch von vorn zu sehen. Element-Marker behalten die letzte +Fahrtrichtung. + ## 4. View- und Controller-Grenzen - **View** (`Node2D`/`Control`) liest das Modell und zeichnet. Sie verändert @@ -505,10 +513,10 @@ Aktueller Stand: - **3D-Assets:** 57 Assertions für Manifest-Schema, Pfade, FTP-Pfade, Platzierung, Rig-Metadaten, Animationen, Hashes und – falls synchronisiert – Größe, SHA-256 sowie die 8-Bone-Gewichte der GLB-Datei. -- **3D-Vorschau:** 57 Assertions für Koordinatenabbildung, Rink-Geometrie, - Kamera-Modi, Platzhalter-Fallback, Kufenspur (Farbe, zwei Kufen, Reset, - Abbau am Kür-Ende) und den 2D/3D-Moduswechsel samt geteilter - Playback-Position. +- **3D-Vorschau:** 61 Assertions für Koordinatenabbildung, Rink-Geometrie, + Kamera-Modi, Kamera-Fahrtrichtung, Platzhalter-Fallback, Kufenspur + (Farbe, zwei Kufen, Reset, Abbau am Kür-Ende) und den 2D/3D-Moduswechsel + samt geteilter Playback-Position. - **Blender-Werkbank:** Rotoscoping wird separat geprüft (`tools/rotoscope.sh test-reference` → `setup` → `export` → `promote --dry-run`), nicht in `./tools/test.sh`, weil Blender und ffmpeg diff --git a/docs/findings-2026-10-31-kamera-rueckwaerts.md b/docs/findings-2026-10-31-kamera-rueckwaerts.md new file mode 100644 index 0000000..ba52570 --- /dev/null +++ b/docs/findings-2026-10-31-kamera-rueckwaerts.md @@ -0,0 +1,63 @@ +# Findings 2026-10-31 – Folgekamera bei Rückwärtsfahrt + +## Ziel + +Die Kamera soll bei Rückwärtsfahrt nicht wieder hinter die Läuferin +schwenken. Sie soll auf der bisherigen Bahnseite bleiben und die Läuferin +dadurch von vorn zeigen. + +## Ursache + +Die Folgekamera leitete ihre Blickrichtung aus dem **Körper-Yaw** ab. Bei +Rückwärtsfahrt zeigt der Körper gegen die Fahrtrichtung; die Kamera setzte +sich dahinter und sah wieder den Rücken. + +## Lösung + +`Presentation3D` speichert jetzt eine **Fahrtrichtung** (`_travel_direction`): + +- Vorwärts-Segment: Fahrtrichtung = Heading. +- Rückwärts-Segment: Fahrtrichtung = −Heading (also die Bahn-Tangente). +- Element-Marker (Pirouette, Sprung): letzte Fahrtrichtung bleibt erhalten. +- Die Kamera berechnet ihren Rückwärtsversatz und den Blickpunkt aus dieser + Fahrtrichtung, nicht aus dem Körper-Yaw. + +Damit gilt: + +| Situation | Kamera | Ansicht | +| :--- | :--- | :--- | +| Vorwärts | hinter der Fahrtrichtung | Rücken | +| Rückwärts | weiterhin hinter der Fahrtrichtung | **Front** | +| Richtungswechsel | kein 180°-Schwenk | die Läuferin dreht sich | +| Pirouette/Sprung | letzte Fahrtrichtung | ruhige Kamera | + +Die Kamera folgt weiterhin der Translation, sonst würde die Läuferin aus dem +Bild laufen. „Position behalten" heißt hier: **kein Orbit um den Körper**, +sondern dieselbe Seite relativ zur Bahn. + +## Tests + +Neu in `tests/run_presentation3d_tests.gd`: + +- Vorwärtskamera folgt +X. +- Rückwärts bei Heading −X behält die Kamera +X als Fahrtrichtung. +- Die Kameraposition ändert sich beim Richtungswechsel nicht. +- Der Skater-Yaw ist bei Rückwärtsfahrt um 180° gedreht (Front zur Kamera). + +Ergebnis: **61 Assertions** (vorher 57), Gesamtsuite **1193** grün. + +## Visuelle Prüfung + +- Vorwärts bei 1400 × 900: Rückenansicht, türkise Kufenspur. +- Rückwärts: Frontalansicht, orange Kufenspur zwischen Kamera und Läuferin. +- Kein Schwenk am Übergang; die Kamera bleibt auf der Bahnseite. +- Die ringgewichteten Ärmel (v005) bleiben in beiden Ansichten sauber. + +## Dateien + +``` +rinkplanner/src/presentation3d/presentation_3d.gd +rinkplanner/tests/run_presentation3d_tests.gd +docs/manual.md +docs/architecture.md (D18) +``` diff --git a/docs/manual.md b/docs/manual.md index 500a1be..56ce852 100644 --- a/docs/manual.md +++ b/docs/manual.md @@ -24,7 +24,9 @@ der bisherige Bearbeitungsstand wieder da. - **Playback geteilt:** Start/Pause, Reset, Timeline und Geschwindigkeit wirken auf den 2D-Marker und den 3D-Skater gleichzeitig. - **Kamera:** Der Button „Kamera: Folge" wechselt zwischen der - Folgekamera (hinten/seitlich versetzt) und der Übersicht (ganzes Rink). + Folgekamera und der Übersicht (ganzes Rink). Die Folgekamera orientiert + sich an der **Fahrtrichtung**: vorwärts sieht man den Rücken, rückwärts + bleibt sie auf derselben Bahnseite und zeigt die Läuferin von vorn. - **Kufenspur:** Zwei verblassende Spuren an den Kufen zeigen die Fahrtrichtung: **türkis = vorwärts**, **orange = rückwärts**. Beim Pausieren bleibt die Spur stehen; am Kür-Ende, wenn die Wiedergabe diff --git a/docs/roadmap.md b/docs/roadmap.md index 19e5a87..0192cba 100644 --- a/docs/roadmap.md +++ b/docs/roadmap.md @@ -189,6 +189,7 @@ UI-Feedback der Tester ohnehin noch ausstehen. - [x] 3D-Rink, Kamera und Skater auf denselben Kurven (schreibgeschützte Vorschau) - [x] Kufenspur mit Richtungsfarbe (vorwärts türkis, rückwärts orange, Abbau am Kür-Ende) - [x] Ärmel-Skinning mit 8 Bone-Influences und ringweiser Armgewichtung +- [x] Folgekamera folgt der Fahrtrichtung (Frontansicht bei Rückwärtsfahrt) - [x] Erster Produktionsclip `Glide` als 2-s-Loop - [x] Rotoscoping-Workflow (Blender-Werkbank, Referenz, Multi-Clip-Export, Manifest) - [ ] Erste echte Clips aus Referenzmaterial (Vorwärts, Rückwärts, Pirouette) diff --git a/rinkplanner/src/presentation3d/presentation_3d.gd b/rinkplanner/src/presentation3d/presentation_3d.gd index 0f99adb..484f5ce 100644 --- a/rinkplanner/src/presentation3d/presentation_3d.gd +++ b/rinkplanner/src/presentation3d/presentation_3d.gd @@ -30,6 +30,7 @@ var _camera_mode: CameraMode = CameraMode.FOLLOW var _camera_initialized: bool = false var _look_target := Vector3(0.0, 1.0, 0.0) var _last_playback_time: float = -1.0 +var _travel_direction := Vector2.RIGHT func _ready() -> void: @@ -54,6 +55,7 @@ func setup(routine: Routine) -> void: _camera_mode = CameraMode.FOLLOW _camera_initialized = false + _travel_direction = Vector2.RIGHT if routine == null or routine.get_length_m() <= 0.0: skater.clear_pose() _update_camera(0.0, true) @@ -96,6 +98,15 @@ func update_pose( if not _active: return + if segment != null and not segment.is_element_marker(): + var travel := heading + if segment.direction == PathSegment.Direction.BACKWARD: + travel = -heading + if travel.length_squared() > 0.0001: + _travel_direction = travel + elif segment == null and heading.length_squared() > 0.0001: + _travel_direction = heading + var moved := previous.distance_to(skater.position) var jumped := moved > TRAIL_RESET_DISTANCE_M if jumped or time_reset: @@ -125,6 +136,7 @@ func clear_pose() -> void: skater.clear_pose() trail.clear() _last_playback_time = -1.0 + _travel_direction = Vector2.RIGHT _camera_initialized = false if _active: _update_camera(0.0, true) @@ -171,17 +183,24 @@ func get_skater_yaw() -> float: return skater.rotation.y +func get_camera_travel_forward() -> Vector3: + var forward := Vector3( + _travel_direction.x, + 0.0, + -_travel_direction.y + ) + if forward.length_squared() < 0.0001: + return Vector3(0.0, 0.0, 1.0) + return forward.normalized() + + func update_camera_now() -> void: _update_camera(0.0, true) func _update_camera(delta: float, snap: bool = false) -> void: var skater_position := skater.position - var forward := Vector3( - sin(skater.rotation.y), - 0.0, - cos(skater.rotation.y) - ) + var forward := get_camera_travel_forward() var desired := Vector3.ZERO var target := Vector3.ZERO diff --git a/rinkplanner/tests/run_presentation3d_tests.gd b/rinkplanner/tests/run_presentation3d_tests.gd index cb0ece2..498ab83 100644 --- a/rinkplanner/tests/run_presentation3d_tests.gd +++ b/rinkplanner/tests/run_presentation3d_tests.gd @@ -190,6 +190,44 @@ func _test_presentation() -> void: "clear pose clears the trail" ) + presentation.update_pose( + Vector2(0.0, 0.0), + Vector2.RIGHT, + forward_segment + ) + presentation.update_camera_now() + _check( + _vec3_matches( + presentation.get_camera_travel_forward(), + Vector3(1.0, 0.0, 0.0) + ), + "forward camera follows the path direction" + ) + var camera_before := presentation.camera.position + presentation.update_pose( + Vector2(0.0, 0.0), + Vector2.LEFT, + backward_segment + ) + presentation.update_camera_now() + _check( + _vec3_matches( + presentation.get_camera_travel_forward(), + Vector3(1.0, 0.0, 0.0) + ), + "backward camera keeps the travel direction" + ) + _check( + presentation.camera.position.distance_to(camera_before) < 0.01, + "backward skating does not swing the camera" + ) + _check( + absf( + angle_difference(presentation.get_skater_yaw(), -PI * 0.5) + ) < 0.001, + "the skater faces the camera when skating backward" + ) + presentation.set_active(false) _check(not presentation.visible, "inactive presentation is hidden") _check(not presentation.camera.current, "inactive presentation releases the camera") @@ -306,6 +344,14 @@ func _color_matches(actual: Color, expected: Color) -> bool: ) +func _vec3_matches( + actual: Vector3, + expected: Vector3, + tolerance: float = 0.001 +) -> bool: + return actual.distance_to(expected) <= tolerance + + func _check(condition: bool, message: String) -> void: _assertions += 1 if not condition: