feat: Tablet- und Web-Bedienung härten
- Oberfläche in CSS-Pixeln layouten (stretch disabled, content_scale_factor = Bildschirm-Skalierung), damit 56-px-Ziele auf Tablets auch 56 CSS-Pixel groß sind - Kompakte Werkzeugleiste unter 1280 px, umbruchfähige Timing-Leiste; 1024 px (iPad-Landscape) und 1400 px (Tab S9+) geprüft - Chrome-Guard gegen synthetische Maus-Events vor/nach Touch-Gesten - Web-Export-Preset und tools/export_web.sh (single-threaded) - Kurven-Cache und Linien-Fastpath: Stresstest mit 480 Segmenten von ca. 48 ms auf ca. 7-10 ms pro Redraw - Neue Suiten für Touch/Layout und Performance, Tablet-Testanleitung in docs/web-test.md
This commit is contained in:
parent
0df49873d1
commit
d44a4e1e2f
18 changed files with 924 additions and 111 deletions
|
|
@ -38,6 +38,19 @@ $GODOT --headless --path rinkplanner --script res://tests/run_timing_tests.gd
|
|||
|
||||
# Run SVG export tests
|
||||
$GODOT --headless --path rinkplanner --script res://tests/run_export_tests.gd
|
||||
|
||||
# Run touch gesture tests
|
||||
$GODOT --headless --path rinkplanner --script res://tests/run_touch_tests.gd
|
||||
|
||||
# Run canvas performance stress test
|
||||
$GODOT --headless --path rinkplanner --script res://tests/run_perf_tests.gd
|
||||
```
|
||||
|
||||
Manueller visueller Smoke-Test (Layout bei einer Fenstergröße prüfen):
|
||||
|
||||
```bash
|
||||
xvfb-run -a $GODOT --path rinkplanner \
|
||||
--script res://tests/manual/capture.gd -- 1024 768 /tmp/capture.png
|
||||
```
|
||||
|
||||
Exit code `0` means all assertions passed. Failures are printed to stderr.
|
||||
|
|
|
|||
37
rinkplanner/tests/manual/capture.gd
Normal file
37
rinkplanner/tests/manual/capture.gd
Normal file
|
|
@ -0,0 +1,37 @@
|
|||
extends SceneTree
|
||||
|
||||
## Manual visual smoke test: renders the whiteboard at a given window size.
|
||||
##
|
||||
## Usage:
|
||||
## xvfb-run -a godot --path rinkplanner \
|
||||
## --script res://tests/manual/capture.gd -- 1024 768 /tmp/capture.png
|
||||
##
|
||||
## The output path is optional. This is a development tool, not part of
|
||||
## `tools/test.sh`; the headless suites cover the behaviour.
|
||||
|
||||
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 1024
|
||||
var height := int(args[1]) if args.size() > 1 else 768
|
||||
var output := args[2] if args.size() > 2 else "user://capture.png"
|
||||
|
||||
var packed := load("res://scenes/whiteboard/whiteboard.tscn") as PackedScene
|
||||
var instance := packed.instantiate()
|
||||
var controller := instance as WhiteboardController
|
||||
if controller != null:
|
||||
controller.restore_autosave = false
|
||||
controller.autosave_enabled = false
|
||||
root.add_child(instance)
|
||||
root.size = Vector2i(width, height)
|
||||
await process_frame
|
||||
await process_frame
|
||||
await RenderingServer.frame_post_draw
|
||||
|
||||
var path := ProjectSettings.globalize_path(output)
|
||||
root.get_texture().get_image().save_png(path)
|
||||
print("Saved %s at %dx%d" % [path, width, height])
|
||||
quit(0)
|
||||
1
rinkplanner/tests/manual/capture.gd.uid
Normal file
1
rinkplanner/tests/manual/capture.gd.uid
Normal file
|
|
@ -0,0 +1 @@
|
|||
uid://w420v5ksey3v
|
||||
133
rinkplanner/tests/run_perf_tests.gd
Normal file
133
rinkplanner/tests/run_perf_tests.gd
Normal file
|
|
@ -0,0 +1,133 @@
|
|||
extends SceneTree
|
||||
|
||||
## Performance stress test for the whiteboard canvas.
|
||||
##
|
||||
## Builds many sections and segments, then measures the cost of a forced
|
||||
## redraw. The bound is deliberately generous so the test stays useful on
|
||||
## slow machines; the goal is to catch accidental super-linear behaviour,
|
||||
## not to benchmark exact frame times.
|
||||
|
||||
const WhiteboardScene := preload("res://scenes/whiteboard/whiteboard.tscn")
|
||||
const EXTRA_SECTIONS := 11
|
||||
const SEGMENTS_PER_SECTION := 40
|
||||
const MAX_AVG_DRAW_MS := 120.0
|
||||
|
||||
var _assertions: int = 0
|
||||
var _failures: PackedStringArray = PackedStringArray()
|
||||
|
||||
|
||||
func _init() -> void:
|
||||
_run.call_deferred()
|
||||
|
||||
|
||||
func _run() -> void:
|
||||
var scene := WhiteboardScene.instantiate()
|
||||
var controller := scene as WhiteboardController
|
||||
if controller == null:
|
||||
printerr("FAIL: scene is not a WhiteboardController")
|
||||
quit(1)
|
||||
return
|
||||
controller.restore_autosave = false
|
||||
controller.autosave_enabled = false
|
||||
root.add_child(scene)
|
||||
await process_frame
|
||||
await process_frame
|
||||
|
||||
var canvas := controller.rink_canvas
|
||||
var routine := controller.get_routine()
|
||||
_fill_section(controller.get_active_section(), 0)
|
||||
for index: int in range(1, EXTRA_SECTIONS + 1):
|
||||
_fill_section(controller.add_section(), index)
|
||||
|
||||
var expected := (EXTRA_SECTIONS + 1) * SEGMENTS_PER_SECTION
|
||||
var total_segments := 0
|
||||
for section: RoutineSection in routine.sections:
|
||||
total_segments += section.segments.size()
|
||||
_check(
|
||||
total_segments == expected,
|
||||
"stress routine has %d segments (got %d)" % [expected, total_segments]
|
||||
)
|
||||
|
||||
canvas.fit_rink()
|
||||
canvas.refresh()
|
||||
await process_frame
|
||||
|
||||
# Warm up font/theme caches before measuring.
|
||||
for _index: int in range(3):
|
||||
canvas.refresh()
|
||||
await process_frame
|
||||
|
||||
var samples: PackedFloat64Array = PackedFloat64Array()
|
||||
for _index: int in range(20):
|
||||
var started := Time.get_ticks_usec()
|
||||
canvas.refresh()
|
||||
await process_frame
|
||||
samples.append(float(Time.get_ticks_usec() - started) / 1000.0)
|
||||
|
||||
var total := 0.0
|
||||
for sample: float in samples:
|
||||
total += sample
|
||||
var average := total / float(samples.size())
|
||||
print(
|
||||
"Perf: %d segments in %d sections, average redraw %.2f ms"
|
||||
% [total_segments, routine.sections.size(), average]
|
||||
)
|
||||
_check(
|
||||
average < MAX_AVG_DRAW_MS,
|
||||
"average redraw stays below %.0f ms (got %.2f ms)"
|
||||
% [MAX_AVG_DRAW_MS, average]
|
||||
)
|
||||
|
||||
scene.queue_free()
|
||||
await process_frame
|
||||
_finish()
|
||||
|
||||
|
||||
func _fill_section(section: RoutineSection, lane_offset: int) -> void:
|
||||
var rink := RinkDimensions.new()
|
||||
var lane_count := maxi(1, SEGMENTS_PER_SECTION)
|
||||
var usable := rink.get_half_width() * 2.0 - 4.0
|
||||
for index: int in range(lane_count):
|
||||
var y := -rink.get_half_width() + 2.0 + usable * float(index) / float(lane_count)
|
||||
y += float(lane_offset) * 0.05
|
||||
var start := Vector2(-rink.get_half_length() + 6.0, y)
|
||||
var end := Vector2(rink.get_half_length() - 6.0, y + 0.2)
|
||||
var segment := PathSegment.new()
|
||||
segment.segment_id = "perf-%d-%d" % [lane_offset, index]
|
||||
segment.curve = Curve2D.new()
|
||||
if index % 3 == 0:
|
||||
segment.template = PathSegment.Template.ARC
|
||||
segment.arc_bulge_left = index % 2 == 0
|
||||
segment.arc_depth_ratio = 0.12
|
||||
var points := ArcGeometry.build_points(
|
||||
start, end, segment.arc_bulge_left, segment.arc_depth_ratio, rink
|
||||
)
|
||||
for point: Vector2 in points:
|
||||
segment.curve.add_point(point)
|
||||
else:
|
||||
segment.template = PathSegment.Template.LINE
|
||||
segment.curve.add_point(start)
|
||||
segment.curve.add_point(end)
|
||||
segment.direction = (
|
||||
PathSegment.Direction.BACKWARD if index % 5 == 0
|
||||
else PathSegment.Direction.FORWARD
|
||||
)
|
||||
section.segments.append(segment)
|
||||
|
||||
|
||||
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)
|
||||
1
rinkplanner/tests/run_perf_tests.gd.uid
Normal file
1
rinkplanner/tests/run_perf_tests.gd.uid
Normal file
|
|
@ -0,0 +1 @@
|
|||
uid://tokudpp114t6
|
||||
284
rinkplanner/tests/run_touch_tests.gd
Normal file
284
rinkplanner/tests/run_touch_tests.gd
Normal file
|
|
@ -0,0 +1,284 @@
|
|||
extends SceneTree
|
||||
|
||||
## Headless tests for the touch gesture layer.
|
||||
##
|
||||
## Run with:
|
||||
## godot --headless --path rinkplanner --script res://tests/run_touch_tests.gd
|
||||
|
||||
const WhiteboardScene := preload("res://scenes/whiteboard/whiteboard.tscn")
|
||||
|
||||
var _assertions: int = 0
|
||||
var _failures: PackedStringArray = PackedStringArray()
|
||||
|
||||
|
||||
func _init() -> void:
|
||||
_run.call_deferred()
|
||||
|
||||
|
||||
func _run() -> void:
|
||||
var scene := WhiteboardScene.instantiate()
|
||||
var controller := scene as WhiteboardController
|
||||
if controller != null:
|
||||
controller.restore_autosave = false
|
||||
controller.autosave_enabled = false
|
||||
root.add_child(scene)
|
||||
await process_frame
|
||||
|
||||
_check(controller != null, "touch scene has a controller")
|
||||
if controller == null:
|
||||
_finish()
|
||||
return
|
||||
|
||||
var canvas := controller.rink_canvas
|
||||
var view := canvas.get_view_transform()
|
||||
var section := controller.get_active_section()
|
||||
_check(
|
||||
canvas.size.x > 0.0 and canvas.size.y > 0.0,
|
||||
"canvas receives a touch layout size"
|
||||
)
|
||||
|
||||
# One-finger drawing.
|
||||
controller.set_tool(WhiteboardController.Tool.LINE)
|
||||
var count_before_draw := section.segments.size()
|
||||
var draw_start := view.model_to_screen(Vector2(-10.0, 5.0))
|
||||
var draw_end := view.model_to_screen(Vector2(0.0, 5.0))
|
||||
_touch(canvas, 0, draw_start, true)
|
||||
_drag(canvas, 0, draw_end, draw_end - draw_start)
|
||||
_touch(canvas, 0, draw_end, false)
|
||||
|
||||
_check(
|
||||
section.segments.size() == count_before_draw + 1,
|
||||
"one-finger drag draws a segment"
|
||||
)
|
||||
var drawn := section.segments[section.segments.size() - 1]
|
||||
_check(drawn.get_length_m() > 9.5, "touch-drawn segment has the drag length")
|
||||
|
||||
# Chrome emits a synthetic mouse press immediately before the touch press.
|
||||
# The touch press must cancel that stray mouse segment.
|
||||
canvas._ignore_mouse_until_msec = 0
|
||||
controller.set_tool(WhiteboardController.Tool.LINE)
|
||||
var count_before_combined := section.segments.size()
|
||||
var combined_start := view.model_to_screen(Vector2(-8.0, -3.0))
|
||||
var combined_end := view.model_to_screen(Vector2(2.0, -3.0))
|
||||
_mouse_button(canvas, combined_start, true)
|
||||
_touch(canvas, 0, combined_start, true)
|
||||
_drag(canvas, 0, combined_end, combined_end - combined_start)
|
||||
_touch(canvas, 0, combined_end, false)
|
||||
_check(
|
||||
section.segments.size() == count_before_combined + 1,
|
||||
"touch replaces the preceding synthetic mouse segment"
|
||||
)
|
||||
controller.set_tool(WhiteboardController.Tool.LINE)
|
||||
|
||||
# Browsers may emit a synthetic mouse gesture after touchend. It must not
|
||||
# create a second segment.
|
||||
var count_after_touch := section.segments.size()
|
||||
var mouse_start := view.model_to_screen(Vector2(-10.0, -5.0))
|
||||
var mouse_end := view.model_to_screen(Vector2(0.0, -5.0))
|
||||
_mouse_button(canvas, mouse_start, true)
|
||||
_mouse_motion(canvas, mouse_end)
|
||||
_mouse_button(canvas, mouse_end, false)
|
||||
_check(
|
||||
section.segments.size() == count_after_touch,
|
||||
"synthetic mouse after touch is ignored"
|
||||
)
|
||||
|
||||
# Two-finger pan.
|
||||
controller.set_tool(WhiteboardController.Tool.SELECT)
|
||||
var count_before_pan := section.segments.size()
|
||||
var origin_before := view.origin_px
|
||||
var pan_a := view.model_to_screen(Vector2(20.0, -10.0))
|
||||
var pan_b := view.model_to_screen(Vector2(20.0, -6.0))
|
||||
_touch(canvas, 0, pan_a, true)
|
||||
_touch(canvas, 1, pan_b, true)
|
||||
_drag(canvas, 0, pan_a + Vector2(30.0, 0.0), Vector2(30.0, 0.0))
|
||||
_drag(canvas, 1, pan_b + Vector2(30.0, 0.0), Vector2(30.0, 0.0))
|
||||
_touch(canvas, 0, pan_a + Vector2(30.0, 0.0), false)
|
||||
_touch(canvas, 1, pan_b + Vector2(30.0, 0.0), false)
|
||||
_check(view.origin_px != origin_before, "two-finger drag pans the canvas")
|
||||
_check(
|
||||
section.segments.size() == count_before_pan,
|
||||
"two-finger pan does not create a segment"
|
||||
)
|
||||
|
||||
# Pinch zoom.
|
||||
canvas.fit_rink()
|
||||
var ppm_before := view.pixels_per_meter
|
||||
var center := canvas.size * 0.5
|
||||
var pinch_a := center + Vector2(-30.0, 0.0)
|
||||
var pinch_b := center + Vector2(30.0, 0.0)
|
||||
var pinch_a2 := center + Vector2(-60.0, 0.0)
|
||||
var pinch_b2 := center + Vector2(60.0, 0.0)
|
||||
_touch(canvas, 0, pinch_a, true)
|
||||
_touch(canvas, 1, pinch_b, true)
|
||||
_drag(canvas, 0, pinch_a2, pinch_a2 - pinch_a)
|
||||
_drag(canvas, 1, pinch_b2, pinch_b2 - pinch_b)
|
||||
_touch(canvas, 0, pinch_a2, false)
|
||||
_touch(canvas, 1, pinch_b2, false)
|
||||
_check(
|
||||
view.pixels_per_meter > ppm_before,
|
||||
"two-finger pinch zooms in"
|
||||
)
|
||||
|
||||
# Tap selection.
|
||||
canvas.fit_rink()
|
||||
var target := section.segments[0]
|
||||
var target_point := target.curve.sample_baked(target.get_length_m() * 0.5)
|
||||
_touch(canvas, 0, view.model_to_screen(target_point), true)
|
||||
_touch(canvas, 0, view.model_to_screen(target_point), false)
|
||||
_check(
|
||||
controller.get_selected_segment() == target,
|
||||
"touch tap selects a segment"
|
||||
)
|
||||
|
||||
# Touch handle editing.
|
||||
var old_start := target.curve.get_point_position(0)
|
||||
var new_start := old_start + Vector2(-2.0, 1.0)
|
||||
_touch(canvas, 0, view.model_to_screen(old_start), true)
|
||||
_drag(
|
||||
canvas,
|
||||
0,
|
||||
view.model_to_screen(new_start),
|
||||
view.model_to_screen(new_start) - view.model_to_screen(old_start)
|
||||
)
|
||||
_touch(canvas, 0, view.model_to_screen(new_start), false)
|
||||
_check_vec(
|
||||
target.curve.get_point_position(0),
|
||||
new_start,
|
||||
"touch handle drag moves the segment start"
|
||||
)
|
||||
|
||||
# A second finger cancels an in-progress drawing gesture.
|
||||
controller.set_tool(WhiteboardController.Tool.LINE)
|
||||
var count_before_cancel := section.segments.size()
|
||||
var inside := view.model_to_screen(Vector2(5.0, 5.0))
|
||||
_touch(canvas, 0, inside, true)
|
||||
_check(
|
||||
section.segments.size() == count_before_cancel + 1,
|
||||
"first finger starts a temporary segment"
|
||||
)
|
||||
_touch(canvas, 1, inside + Vector2(20.0, 0.0), true)
|
||||
_check(
|
||||
section.segments.size() == count_before_cancel,
|
||||
"second finger cancels the temporary segment"
|
||||
)
|
||||
_drag(canvas, 0, inside + Vector2(40.0, 0.0), Vector2(40.0, 0.0))
|
||||
_drag(canvas, 1, inside + Vector2(60.0, 0.0), Vector2(40.0, 0.0))
|
||||
_touch(canvas, 0, inside + Vector2(40.0, 0.0), false)
|
||||
_touch(canvas, 1, inside + Vector2(60.0, 0.0), false)
|
||||
_check(
|
||||
section.segments.size() == count_before_cancel,
|
||||
"pinch after cancel does not leave a segment"
|
||||
)
|
||||
|
||||
# Responsive toolbar: wide screens keep the full labels, tablet-landscape
|
||||
# width switches to the compact labels and must not clip the bars.
|
||||
root.size = Vector2i(1400, 900)
|
||||
await process_frame
|
||||
await process_frame
|
||||
_check(controller.get_node("%Title").visible, "wide layout shows the app title")
|
||||
_check(
|
||||
controller.get_node("%UndoButton").text == "Rückgängig",
|
||||
"wide layout uses the full undo label"
|
||||
)
|
||||
|
||||
root.size = Vector2i(1024, 768)
|
||||
await process_frame
|
||||
await process_frame
|
||||
_check(
|
||||
not controller.get_node("%Title").visible,
|
||||
"compact layout hides the app title"
|
||||
)
|
||||
_check(
|
||||
controller.get_node("%UndoButton").text == "Undo",
|
||||
"compact layout uses the short undo label"
|
||||
)
|
||||
var top_bar: Control = controller.get_node("Layout/TopBar")
|
||||
var timing_bar: Control = controller.get_node("Layout/TimingBar")
|
||||
var playback_bar: Control = controller.get_node("Layout/PlaybackBar")
|
||||
_check(
|
||||
top_bar.get_combined_minimum_size().x <= 1024.0,
|
||||
"top bar fits a 1024 px landscape tablet (min %.0f)"
|
||||
% top_bar.get_combined_minimum_size().x
|
||||
)
|
||||
_check(
|
||||
timing_bar.get_combined_minimum_size().x <= 1024.0,
|
||||
"timing bar fits a 1024 px landscape tablet"
|
||||
)
|
||||
_check(
|
||||
playback_bar.get_combined_minimum_size().x <= 1024.0,
|
||||
"playback bar fits a 1024 px landscape tablet"
|
||||
)
|
||||
|
||||
scene.queue_free()
|
||||
await process_frame
|
||||
_finish()
|
||||
|
||||
|
||||
func _touch(
|
||||
canvas: RinkCanvas,
|
||||
index: int,
|
||||
position: Vector2,
|
||||
pressed: bool
|
||||
) -> void:
|
||||
var event := InputEventScreenTouch.new()
|
||||
event.index = index
|
||||
event.position = position
|
||||
event.pressed = pressed
|
||||
canvas._gui_input(event)
|
||||
|
||||
|
||||
func _drag(
|
||||
canvas: RinkCanvas,
|
||||
index: int,
|
||||
position: Vector2,
|
||||
relative: Vector2
|
||||
) -> void:
|
||||
var event := InputEventScreenDrag.new()
|
||||
event.index = index
|
||||
event.position = position
|
||||
event.relative = relative
|
||||
canvas._gui_input(event)
|
||||
|
||||
|
||||
func _mouse_button(
|
||||
canvas: RinkCanvas,
|
||||
position: Vector2,
|
||||
pressed: bool
|
||||
) -> void:
|
||||
var event := InputEventMouseButton.new()
|
||||
event.button_index = MOUSE_BUTTON_LEFT
|
||||
event.pressed = pressed
|
||||
event.position = position
|
||||
canvas._gui_input(event)
|
||||
|
||||
|
||||
func _mouse_motion(canvas: RinkCanvas, position: Vector2) -> void:
|
||||
var event := InputEventMouseMotion.new()
|
||||
event.position = position
|
||||
canvas._gui_input(event)
|
||||
|
||||
|
||||
func _check(condition: bool, message: String) -> void:
|
||||
_assertions += 1
|
||||
if not condition:
|
||||
_failures.append(message)
|
||||
|
||||
|
||||
func _check_vec(actual: Vector2, expected: Vector2, message: String) -> void:
|
||||
_check(
|
||||
actual.distance_to(expected) <= 0.01,
|
||||
"%s (expected %s, got %s)" % [message, expected, actual]
|
||||
)
|
||||
|
||||
|
||||
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)
|
||||
1
rinkplanner/tests/run_touch_tests.gd.uid
Normal file
1
rinkplanner/tests/run_touch_tests.gd.uid
Normal file
|
|
@ -0,0 +1 @@
|
|||
uid://cxkc6u04un1qn
|
||||
Loading…
Add table
Add a link
Reference in a new issue