Implement M9.3 camera navigation and bounded input intentions

This commit is contained in:
dingo
2026-10-01 17:26:35 -04:00
parent 04c7715646
commit bb0412cd0f
19 changed files with 899 additions and 27 deletions
+2
View File
@@ -170,3 +170,5 @@ The optional SDL3 probe is separate from the headless targets. See
[client dependency preparation and checks](docs/engineering/CLIENT_DEPENDENCIES.md).
M9.2 supplies the [native engineering client](docs/engineering/CLIENT.md), with
an immutable frame boundary and tested window/resource lifecycle.
M9.3 adds [camera navigation and input intentions](docs/engineering/CAMERA_INPUT.md),
with explicit UI capture and no authoritative movement or network connection.
+71 -6
View File
@@ -1,7 +1,9 @@
#include "evo/client/application.hpp"
#include <algorithm>
#include <array>
#include <charconv>
#include <chrono>
#include <cmath>
#include <cstdio>
#include <exception>
#include <string_view>
@@ -34,14 +36,77 @@ int main(int argc, char** argv) try {
std::fprintf(stderr, "client initialization error=%d\n", static_cast<int>(app.error()));
return 1;
}
// Presentation fixture only. No simulated organisms or world state.
const std::array<evo::render::Rectangle, 1> boxes{{{24, 24, 160, 96, {64, 180, 140, 255}}}};
const auto frame = evo::render::Frame::create(boxes, {16, 20, 28, 255});
if (!frame)
// A minimized native window may start with no drawable area. Adopt the
// native viewport before projecting; until then use the requested size.
auto camera =
evo::client::Camera::create({config.width, config.height, config.width, config.height});
if (!camera)
return 1;
unsigned count = 0;
std::puts("Arrows: pan | wheel: zoom | WASD: intention indicator | Tab: UI capture (orange)");
std::uint64_t count = 0;
auto previous = std::chrono::steady_clock::now();
while (frames == 0 || count < frames) {
const auto result = (*app)->step(*frame);
if (auto result = (*app)->poll_events(); !result) {
std::fprintf(stderr, "client event error=%d\n", static_cast<int>(result.error()));
return 1;
}
const auto state = (*app)->state();
if (state.closed)
break;
const auto now = std::chrono::steady_clock::now();
const double seconds =
std::clamp(std::chrono::duration<double>(now - previous).count(), 0.0, 0.1);
previous = now;
const auto navigation = (*app)->take_navigation();
// Fixture ticks only. No server session or simulation clock exists here.
const auto intention = (*app)->sample_intention(count);
if (!intention)
return 1;
std::array<evo::render::Rectangle, 3> boxes{};
if (state.logical_width > 0 && state.logical_height > 0 && state.pixel_width > 0 &&
state.pixel_height > 0) {
if (!camera->resize({state.logical_width, state.logical_height, state.pixel_width,
state.pixel_height}))
return 1;
if (auto result =
camera->pan({navigation.x * 400 * seconds, navigation.y * 400 * seconds});
!result && result.error() != evo::client::CameraError::out_of_range)
return 1;
const evo::client::ScreenPoint anchor{
std::clamp(navigation.pointer.x, 0.0, static_cast<double>(state.logical_width)),
std::clamp(navigation.pointer.y, 0.0, static_cast<double>(state.logical_height))};
if (auto result = camera->zoom(std::exp2(navigation.wheel / 4), anchor);
!result && result.error() != evo::client::CameraError::out_of_range)
return 1;
// Local-mm presentation fixture only. Clip before float conversion.
const auto upper = camera->world_to_screen({-80, 48});
const auto lower = camera->world_to_screen({80, -48});
if (!upper || !lower)
return 1;
const double left = std::clamp(upper->x, 0.0, static_cast<double>(state.logical_width));
const double top = std::clamp(upper->y, 0.0, static_cast<double>(state.logical_height));
const double right =
std::clamp(lower->x, 0.0, static_cast<double>(state.logical_width));
const double bottom =
std::clamp(lower->y, 0.0, static_cast<double>(state.logical_height));
boxes[0] = {static_cast<float>(left),
static_cast<float>(top),
static_cast<float>(right - left),
static_cast<float>(bottom - top),
{64, 180, 140, 255}};
}
boxes[1] = {8, 8, 64, 8,
(*app)->ui_captured() ? evo::render::Color{240, 140, 32, 255}
: evo::render::Color{64, 180, 140, 255}};
boxes[2] = {36 + static_cast<float>(intention->move_x) / 50,
48 - static_cast<float>(intention->move_y) / 50,
8,
8,
{240, 240, 240, 255}};
const auto frame = evo::render::Frame::create(boxes, {16, 20, 28, 255});
if (!frame)
return 1;
const auto result = (*app)->present(*frame);
if (!result) {
std::fprintf(stderr, "client frame error=%d\n", static_cast<int>(result.error()));
return 1;
+5 -2
View File
@@ -46,19 +46,22 @@ if(EVO_BUILD_CLIENT_PROBE)
endif()
if(EVO_BUILD_CLIENT)
add_library(evo_client_controls STATIC src/client/camera/camera.cpp src/client/input/input.cpp)
target_include_directories(evo_client_controls PUBLIC "${PROJECT_SOURCE_DIR}/include")
evo_owned_target(evo_client_controls)
add_library(evo_render_frame STATIC src/render/frame.cpp)
target_include_directories(evo_render_frame PUBLIC "${PROJECT_SOURCE_DIR}/include")
evo_owned_target(evo_render_frame)
add_library(evo_client_platform STATIC src/client/platform/application.cpp src/render/sdl_renderer.cpp)
target_include_directories(evo_client_platform PRIVATE "${PROJECT_SOURCE_DIR}/src")
target_link_libraries(evo_client_platform PUBLIC evo_render_frame PRIVATE SDL3::SDL3)
target_link_libraries(evo_client_platform PUBLIC evo_render_frame evo_client_controls PRIVATE SDL3::SDL3)
evo_owned_target(evo_client_platform)
add_executable(evo-client apps/evo-client/main.cpp)
target_link_libraries(evo-client PRIVATE evo_client_platform)
evo_owned_target(evo-client)
evo_client_runtime(evo-client)
if(BUILD_TESTING)
add_executable(evo-client-lifecycle-tests tests/client_lifecycle.cpp)
add_executable(evo-client-lifecycle-tests tests/client_lifecycle.cpp tests/client_controls.cpp)
target_include_directories(evo-client-lifecycle-tests PRIVATE "${PROJECT_SOURCE_DIR}/src")
target_link_libraries(evo-client-lifecycle-tests PRIVATE evo_client_platform SDL3::SDL3)
evo_owned_target(evo-client-lifecycle-tests)
+7 -1
View File
@@ -398,7 +398,13 @@ The added Gitea client job awaits remote verification.
surface/resource lifecycle implemented under ADR-0078; Windows/Linux tests,
analysis, ASan/UBSan and headless replay evidence in engineering/VALIDATION.md.
Physical DPI/input and real GPU loss remain hardware qualification, not claims
from injected events. Next gate: M9.3.
from injected events.
**M9.3 status (2026-10-01):** local-mm camera, logical/drawable conversion,
cursor-anchored zoom, bounded sequence/tick intentions and focus/UI/backlog
suppression implemented under ADR-0079. Camera round trips and native event
regressions are recorded in engineering/VALIDATION.md. The app uses local
fixture ticks, not server time. Next gate: M9.4.
**Goal:** a native desktop cellular viewer/controller with input, camera, renderer,
readable organism/environment views and a real development-server connection.
+8 -8
View File
@@ -2,17 +2,17 @@
## Current gate — 2026-10-01
M9.2 adds an opt-in native `evo-client`, immutable presentation frame contract and
RAII platform/renderer lifecycle ([ADR-0078](adr/0078-native-client-lifecycle.md)).
Resize/pixel scale, focus, minimized/hidden windows, reset/loss and orderly close
are covered by Windows/Linux tests. Direct X11 linking resolves the observed
M9.1 unload allocation issue in repeated sanitizer checks. See
M9.3 adds local-mm pan/zoom camera mapping and bounded sequence/tick input
intentions ([ADR-0079](adr/0079-camera-and-input-intentions.md)). Focus loss,
UI capture/release and saturated event batches cancel held input. WASD controls
an intention indicator; arrows/wheel navigate the presentation fixture. See
[CLIENT.md](engineering/CLIENT.md) and [VALIDATION.md](engineering/VALIDATION.md).
Updated remote Gitea client execution remains unverified locally.
Next: **M9.3**, camera and bounded input intentions. The window displays a static
presentation fixture, not organisms or a connected world. No deployment,
simulation rules, persistent formats or world state changed in M9.2.
Next: **M9.4**, rendering microscopic environment views. The client displays a
camera-controlled fixture, not organisms or a connected world. Its tick is a
local input fixture counter. No deployment, simulation rules, persistent formats
or world state changed in M9.3.
The sections below retain earlier milestone delivery history.
@@ -0,0 +1,64 @@
# ADR-0079: Local camera and bounded input intentions
## Status
Accepted for M9.3 engineering client. No movement physics, network format or tick
frequency is selected. Controls are engineering bindings, not final player UI.
## Context
M9.2 has logical/drawable sizes but no navigation or input state. M6 views use a
caller-selected local XY habitat, measured in millimetres; pixels cannot become
authoritative positions. Focus changes can otherwise leave held movement active.
## Decision
Use SDL-free camera and input value contracts. Camera doubles are presentation
only, in the local XY plane (+X right, +Y up), with named millimetre coordinates.
Screen coordinates are logical window units (+Y down); drawable conversion uses
independent X/Y ratios. Content scale is not applied twice. Camera resize retains
centre/zoom; cursor-anchored zoom preserves the selected world point. Reject
non-finite values, zero viewports and out-of-range operations without mutation.
Input has fixed held-key state and bounded wheel accumulation, not an event or
command queue. WASD produces a signed quantized movement vector of norm <=1000;
arrows pan the camera and wheel zooms. UI capture (Tab in the engineering app)
and window focus/visibility gate both. Losing admission clears all held keys and
wheel state. Regaining admission requires a fresh non-repeat keydown; ignored
presses never resume by themselves. A release always clears its key.
External UI capture release drains pending events before re-admission, and a
saturated 256-event batch similarly quarantines its remaining input until drained.
Sampling produces one intention with a monotonically increasing sequence and
strictly increasing caller-supplied tick; suppressed input emits a neutral vector.
Invalid ticks or counter exhaustion fail without consuming sequence. No time is
read by input code. The standalone app labels its frame counter as a local input
fixture tick; M9.6 must bind this contract to validated session/tick context and
server-side admission. Never transmit native struct memory or trust client ticks.
Split platform polling from presentation so input and camera projection use the
current viewport before drawing; retain `step(frame)` as the combined convenience.
No new dependencies. No authoritative simulation or world format changes.
## Alternatives considered
- SDL keyboard state polling: can resurrect physically held keys after focus/UI
capture; explicit event-held state gives clear re-arm semantics.
- Mouse pixels as world coordinates: changes intent with DPI; rejected.
- Unbounded input event queue: unnecessary until session/prediction contracts exist.
- Variable simulation delta: camera pacing is presentation only, not simulation time.
## Benefits
Testable without SDL, bounded memory, no stuck input, explicit units and sequence
semantics; camera changes cannot change biological state.
## Costs
Local projection has finite numeric bounds and approximate floating-point round
trips. Bindings and single-window capture are deliberately narrow.
## Risks
Synthetic events do not qualify physical keyboard layouts, IME or multi-monitor
DPI. M9.6/M10 still need authentication, tick windows, replay protection and rate
limits. This contract is neither a secure session nor a networking implementation.
## Consequences
Public camera/input headers, host caller and tests change together. M9.4 will
project environmental data through this camera. UI capture is an explicit host
API; a future UI must set it before polling its world-input batch.
+1
View File
@@ -90,3 +90,4 @@ design. No unadopted candidate is a link dependency of the proof.
- [ADR-0077: Scoped native client dependencies](0077-scoped-native-client-dependencies.md) - SDL 3.4.16 window/events and 2D renderer for the opt-in M9.1 probe; no simulation dependency.
- [ADR-0078: Native client lifecycle](0078-native-client-lifecycle.md) - main-thread RAII application, immutable presentation frames and explicit surface/device failure handling.
- [ADR-0079: Camera and input intentions](0079-camera-and-input-intentions.md) - local-mm projection, bounded sequence/tick intentions, focus/UI capture and explicit host event ordering.
+9 -3
View File
@@ -1,4 +1,4 @@
# Native client boundary (M9.2)
# Native client boundary (M9.2–M9.3)
Implemented scope: desktop lifecycle and primitive presentation, not gameplay.
ADR-0077 selects SDL; ADR-0078 defines its ownership and view boundary.
@@ -23,7 +23,7 @@ main or be used/destroyed on another thread.
valid until frame destruction/assignment. `Application::step(const Frame&)`
borrows it for the call only; there is no queue, stored pointer or simulation
mutation. Coordinates are logical window units, top-left origin, +Y down. They
are presentation units, never world millimetres. M9.3 owns world-screen mapping;
are presentation units, never world millimetres. M9.3 implements world-screen mapping;
M9.4 projects environment samples. In particular, do not retain M6 validation
tokens/store pointers in a renderer or serialize them as a client protocol.
@@ -32,7 +32,7 @@ separately. Resizes/display changes query SDL rather than trust event payloads.
Drawing scales independently by pixel/logical width and height; content scale is
for future UI sizing, not a second pixel multiplier. Hidden/minimized/zero-area
windows skip rendering. Focus loss disables the future input admission flag;
there are no held gameplay inputs in M9.2. Close is terminal.
M9.3 clears all held intentions on admission loss. Close is terminal.
Each step consumes at most 256 events, filters window-specific events and renders
one frame. Target reset needs only redraw (no cached textures). Device reset
@@ -41,6 +41,12 @@ failure latch an error until destruction; no silent backend substitution or busy
recovery loop. Typed errors reach the process boundary. The host paces frames
outside the renderer and catches allocation/standard-library exceptions.
M9.3 also exposes separate `poll_events()` and `present(frame)` calls so camera
mapping uses current resize/input state. SDL-free camera and input contracts are
specified in [CAMERA_INPUT.md](../engineering/CAMERA_INPUT.md) and ADR-0079.
UI capture and event-backlog handling suppress held world input; sequence/tick
intentions do not confer server authority. M9.6 owns session binding.
Failure tests inject actual SDL events, including foreign window IDs, with no
test-only production hooks. Real device failures and physical DPI/input require
manual hardware qualification at M9.8. The native client is opt-in and never
+78
View File
@@ -0,0 +1,78 @@
# M9.3 camera and input contract
Decision: [ADR-0079](../adr/0079-camera-and-input-intentions.md).
Headers: `include/evo/client/camera.hpp`, `input.hpp`, `application.hpp`.
No SDL types enter the camera/input contracts. Neither library mutates or links
the simulation. The world coordinate header supplies numeric bounds only.
## Coordinates and camera
`WorldPoint` stores presentation doubles in millimetres in a caller-selected
region-local XY plane, +Y up. Its half-open range matches M5/M6 voxel bounds
times the 1000 mm pitch: [-1048576000, 1048576000) on both axes. Do not mix
frames/worlds or silently map the old periodic particle fixture into this plane.
M6 micrometre habitat offsets require explicit conversion to mm at M9.4 projection.
`ScreenPoint` is logical window space, top-left origin and +Y down. `PixelPoint`
is drawable space. Viewport dimensions must be 1..32768; zero/minimized surfaces
are not a camera viewport. Application skips viewport updates while zero-area.
`units_per_mm` is logical units per mm, bounded [0.0001, 10000]. Screen/pixel
conversions validate finite values within +/-1e15; world projection may be
offscreen. Clip to the viewport before converting to renderer float primitives.
The projection is `screen_x = (world_x - centre_x) * scale + width/2` and
`screen_y = (centre_y - world_y) * scale + height/2`. Pixel conversions apply
pixel_width/width and pixel_height/height independently. Display content scale
is not a further multiplier. Round trips are approximate; tests use 1e-6 mm
tolerance for their bounded fixtures, not a global deterministic-state promise.
Resize retains centre/zoom. Pan moves the camera in screen-axis directions by
at most 32768 logical units per component per call. Positive X moves the camera
right; positive Y moves it down. Zoom requires a positive finite factor and an
anchor inside the logical viewport. It preserves the world point under that
anchor; requests beyond zoom/world bounds reject without mutation. These are
engineering numeric limits, not biological movement or world-size rules.
## Input and host ordering
`InputState` has eight held-key slots, one cursor and bounded accumulated wheel
steps ([-8,8], individual inputs must be finite and within [-128,128]). Navigation
consumes wheel steps once; held pan directions persist until release/admission
loss. Pointer events require finite coordinates within +/-32768 logical units.
Invalid values reject rather than entering camera math.
`Intention` carries sequence, tick and a signed movement vector. Cardinal
components are +/-1000, diagonals +/-707 (norm <=1000); opposite keys cancel.
This is direction/demand, never velocity, distance, energy or accepted position.
Sequences start at 1 by default; the host can seed a local stream counter but
that is not an authenticated resume grant. Successful samples require strictly
increasing ticks. Exhaustion/stale tick rejection consumes neither tick nor
sequence. Inactive input still samples a neutral intention, allowing later
session adapters to express stopped input. No pending command queue exists.
Use `poll_events()` -> read current window/navigation -> update camera ->
`sample_intention(tick)` -> build immutable frame -> `present(frame)`.
`step(frame)` retains the combined poll/present convenience for lifecycle tests.
Focus loss, hidden/minimized/closed/failed/zero-area state, or UI capture clears
held state. A fresh non-repeat keydown is needed to re-arm; releases always
clear keys. UI code calls `set_ui_capture` before world polling. Tab toggles an
engineering capture mode in the adapter; repeats do not retoggle it. Window
close remains available while captured.
A 256-event saturated batch clears admission. Remaining queued keydowns are
ignored until a later poll drains the backlog; the drained state remains neutral
until a fresh keydown. This prevents delayed releases from sustaining movement.
All window-specific input filters the owned SDL window ID.
Releasing capture through the external UI API also drains the pending SDL batch
before re-admission, preventing keys queued while captured from becoming world
presses. Poll once after release, then fresh presses are admitted. The engineering
Tab toggle is processed in event order, so subsequent presses after that toggle
belong to its new capture state.
The standalone host uses an increasing **local fixture tick**, not server time.
It draws a world-anchored rectangle, a capture indicator and an intention dot.
Camera panning uses 400 logical units/second with elapsed time clamped to 0.1 s;
wheel zoom uses 2^(steps/4). These are presentation controls. No network messages,
world modifications or organism actions occur. M9.6 must bind intention ticks
and counters to secure sessions; the server independently validates all requests.
+10 -2
View File
@@ -1,8 +1,9 @@
# Native engineering client (M9.2)
# Native engineering client (M9.2–M9.3)
This opens a resizable native window containing a static presentation fixture.
This opens a resizable native window containing a camera-controlled presentation fixture.
It does not simulate a world, connect to a server or implement cellular gameplay.
Contract: [client architecture](../architecture/CLIENT_ARCHITECTURE.md), ADR-0078.
Camera/input: [contracts and limits](CAMERA_INPUT.md), ADR-0079.
## Build and run
@@ -26,6 +27,13 @@ one explicit backend, without fallback. `--frames N` exits after N bounded steps
window and pauses drawing. These options permit unattended smoke checks.
Usage errors exit 2, lifecycle failures exit 1, orderly exit returns 0.
Engineering controls: arrow keys pan, mouse wheel zooms around the pointer, WASD
updates the small intention indicator without moving the world fixture. Tab
toggles UI capture: the top-left bar turns orange and navigation/movement input
is suppressed. Leaving capture/focus loss requires fresh presses. This is a
focus exercise, not the final player UI. The host's input tick is a local fixture
counter and is never interpreted as authoritative server time.
For native X11 regression on a CI host:
```sh
+44
View File
@@ -3240,3 +3240,47 @@ boundary requires single-main-thread use. Tests do not establish physical
multi-monitor DPI, real keyboard/focus behavior, Wayland, hardware GPU loss or
human visual acceptance. Those remain M9.3/M9.8 qualification work. No cluster
operation was performed.
## M9.3 camera and input intentions — 2026-10-01
Implemented ADR-0079 and CAMERA_INPUT.md: SDL-free local-mm camera and held input
state, explicit logical/pixel conversion, cursor-anchored zoom, bounded
sequence/tick intentions and polling-before-projection. The app demonstrates
arrows/wheel navigation, a WASD intention indicator and Tab UI capture. Its tick
is a local fixture counter; no server/session/authoritative movement is present.
Executed:
- Windows MSVC 19.44 Release via `tools/windows-check.ps1 -Preset client -Action
check`: 3/3 labeled tests passed. Native Windows lifecycle/input executable
and the final `evo-client --frames 3` smoke passed.
- Linux GCC 14 Release, existing combined probe/client build: 5/5 labeled tests
passed; native Xvfb/X11 lifecycle and input events passed. The final app-only
startup/error-reporting adjustment was additionally built/tested with MSVC and
Clang ASan below (the GCC suite preceded that adjustment).
- Clang 19 Debug ASan/UBSan: all owned camera/input/platform/app/test code built;
3/3 labeled tests and native Xvfb/X11 tests passed with leak detection enabled,
without preload or suppressions. Final hidden/software three-frame app smoke
also passed. SDL/system libraries remain outside comprehensive instrumentation.
- Pure camera tests cover 220 world/logical/pixel round trips over four viewport/
DPI/aspect combinations and five zoom scales (1e-6 mm tolerance for fixtures),
anchor preservation, pan direction, resize stability, NaN/infinity, numeric
limits and unchanged state after rejected operations.
- Input tests cover key release/opposites/diagonals, focus re-arm, ignored repeats,
UI capture, bounded/consumed wheel accumulation, invalid input, monotonically
increasing sequence/tick and stale/overflow rejection. Native SDL tests cover
WASD/arrows, Tab repeat, focus loss/regain, wheel direction/pointer, minimize,
saturated event batches and queued keys crossing external capture release.
- clang-tidy 19 with warnings-as-errors passed on all six changed/new translation
units; corrected a duplicated wheel-error branch. Final app-only adjustment
also passed analysis. Repository format-check passed.
- Headless Release configured with both client options OFF, rebuilt `evo-sim`,
replayed seed 123456 / eight entities / 1000 ticks: unchanged
`d61ad5bf0c928c76`, `replay_verified=true`.
The existing client CI target now picks up the controls library and expanded
lifecycle suite automatically. Docker/Gitea execution was not observed locally.
No full headless suite or TSan rerun; owned client state remains main-thread-only.
No physical keyboard/IME, human visual, real multi-monitor DPI, Wayland or real
GPU-failure qualification is claimed from injected events and Xvfb. No network
traffic, database, world mutation or deployment operation was introduced.
+9 -1
View File
@@ -1,4 +1,5 @@
#pragma once
#include "evo/client/input.hpp"
#include "evo/render/frame.hpp"
#include <cstdint>
#include <expected>
@@ -27,7 +28,8 @@ struct WindowState {
float content_scale{1};
bool focused{}, minimized{}, hidden{}, closed{}, failed{};
[[nodiscard]] bool accepts_input() const noexcept {
return focused && !minimized && !hidden && !closed && !failed;
return focused && !minimized && !hidden && !closed && !failed && logical_width > 0 &&
logical_height > 0 && pixel_width > 0 && pixel_height > 0;
}
};
// One owner, process main thread only (including destruction). No SDL owner may coexist.
@@ -39,6 +41,12 @@ class Application {
Application(const Application&) = delete;
Application& operator=(const Application&) = delete;
[[nodiscard]] WindowState state() const noexcept;
[[nodiscard]] std::expected<void, Error> poll_events();
[[nodiscard]] std::expected<Step, Error> present(const render::Frame& frame);
void set_ui_capture(bool captured) noexcept;
[[nodiscard]] bool ui_captured() const noexcept;
[[nodiscard]] Navigation take_navigation() noexcept;
[[nodiscard]] std::expected<Intention, InputError> sample_intention(std::uint64_t tick);
// Borrows the immutable frame for this call only. Errors latch until destruction.
[[nodiscard]] std::expected<Step, Error> step(const render::Frame& frame);
+48
View File
@@ -0,0 +1,48 @@
#pragma once
#include <cstdint>
#include <expected>
namespace evo::client {
struct WorldPoint {
double x_mm{}, y_mm{};
};
struct ScreenPoint {
double x{}, y{};
}; // Logical window units, not pixels.
struct PixelPoint {
double x{}, y{};
};
struct Viewport {
int width{}, height{}, pixel_width{}, pixel_height{};
};
enum class CameraError : std::uint8_t { invalid_viewport, invalid_value, out_of_range };
class Camera {
public:
[[nodiscard]] static std::expected<Camera, CameraError>
create(Viewport viewport, WorldPoint centre = {}, double units_per_mm = 1);
[[nodiscard]] std::expected<void, CameraError> resize(Viewport viewport);
// Move the camera in screen-axis directions; the scene moves oppositely.
[[nodiscard]] std::expected<void, CameraError> pan(ScreenPoint delta);
[[nodiscard]] std::expected<void, CameraError> zoom(double factor, ScreenPoint anchor);
[[nodiscard]] std::expected<ScreenPoint, CameraError> world_to_screen(WorldPoint point) const;
[[nodiscard]] std::expected<WorldPoint, CameraError> screen_to_world(ScreenPoint point) const;
[[nodiscard]] std::expected<PixelPoint, CameraError> to_pixels(ScreenPoint point) const;
[[nodiscard]] std::expected<ScreenPoint, CameraError> from_pixels(PixelPoint point) const;
[[nodiscard]] Viewport viewport() const noexcept {
return viewport_;
}
[[nodiscard]] WorldPoint centre() const noexcept {
return centre_;
}
[[nodiscard]] double units_per_mm() const noexcept {
return scale_;
}
private:
Camera(Viewport viewport, WorldPoint centre, double scale)
: viewport_{viewport}, centre_{centre}, scale_{scale} {}
Viewport viewport_;
WorldPoint centre_;
double scale_;
};
} // namespace evo::client
+54
View File
@@ -0,0 +1,54 @@
#pragma once
#include "evo/client/camera.hpp"
#include <array>
#include <cstdint>
#include <expected>
#include <optional>
namespace evo::client {
enum class Key : std::uint8_t { left, right, up, down, pan_left, pan_right, pan_up, pan_down };
enum class InputError : std::uint8_t {
invalid_key,
invalid_pointer,
invalid_wheel,
stale_tick,
exhausted
};
struct Intention {
std::uint64_t sequence{}, tick{};
std::int16_t move_x{}, move_y{}; // Signed unit vector *1000, local XY (+Y up).
};
struct Navigation {
int x{}, y{};
double wheel{};
ScreenPoint pointer{};
};
// Main-thread value state; no event queue or authoritative position.
class InputState {
public:
// Host-owned sequence seed, for local streams/tests; not a session resume grant.
explicit InputState(std::uint64_t last_sequence = 0) : sequence_{last_sequence} {}
void admit(bool enabled) noexcept;
void capture(bool captured) noexcept;
[[nodiscard]] bool captured() const noexcept {
return captured_;
}
[[nodiscard]] bool enabled() const noexcept {
return admitted_ && !captured_;
}
[[nodiscard]] std::expected<void, InputError> key(Key key, bool down, bool repeat = false);
[[nodiscard]] std::expected<void, InputError> pointer(ScreenPoint point);
[[nodiscard]] std::expected<void, InputError> wheel(double steps);
[[nodiscard]] Navigation take_navigation() noexcept;
[[nodiscard]] std::expected<Intention, InputError> sample(std::uint64_t tick);
private:
void clear() noexcept;
std::array<bool, 8> keys_{};
bool admitted_{false}, captured_{false};
ScreenPoint pointer_{};
double wheel_{};
std::uint64_t sequence_{};
std::optional<std::uint64_t> tick_;
};
} // namespace evo::client
+101
View File
@@ -0,0 +1,101 @@
#include "evo/client/camera.hpp"
#include "evo/world/coordinates.hpp"
#include <cmath>
namespace evo::client {
namespace {
constexpr double world_limit = static_cast<double>(world::voxel_limit * world::cell_pitch_mm);
bool valid(Viewport v) {
return v.width > 0 && v.height > 0 && v.pixel_width > 0 && v.pixel_height > 0 &&
v.width <= 32768 && v.height <= 32768 && v.pixel_width <= 32768 &&
v.pixel_height <= 32768;
}
bool valid(WorldPoint p) {
return std::isfinite(p.x_mm) && std::isfinite(p.y_mm) && p.x_mm >= -world_limit &&
p.y_mm >= -world_limit && p.x_mm < world_limit && p.y_mm < world_limit;
}
bool valid(ScreenPoint p) {
return std::isfinite(p.x) && std::isfinite(p.y) && std::abs(p.x) <= 1e15 &&
std::abs(p.y) <= 1e15;
}
bool valid_scale(double scale) {
return std::isfinite(scale) && scale >= 1e-4 && scale <= 1e4;
}
} // namespace
std::expected<Camera, CameraError> Camera::create(Viewport viewport, WorldPoint centre,
double scale) {
if (!valid(viewport))
return std::unexpected(CameraError::invalid_viewport);
if (!valid(centre) || !valid_scale(scale))
return std::unexpected(CameraError::invalid_value);
return Camera{viewport, centre, scale};
}
std::expected<void, CameraError> Camera::resize(Viewport viewport) {
if (!valid(viewport))
return std::unexpected(CameraError::invalid_viewport);
viewport_ = viewport;
return {};
}
std::expected<ScreenPoint, CameraError> Camera::world_to_screen(WorldPoint point) const {
if (!valid(point))
return std::unexpected(CameraError::invalid_value);
return ScreenPoint{(point.x_mm - centre_.x_mm) * scale_ + viewport_.width / 2.0,
(centre_.y_mm - point.y_mm) * scale_ + viewport_.height / 2.0};
}
std::expected<WorldPoint, CameraError> Camera::screen_to_world(ScreenPoint point) const {
if (!valid(point))
return std::unexpected(CameraError::invalid_value);
const WorldPoint result{centre_.x_mm + (point.x - viewport_.width / 2.0) / scale_,
centre_.y_mm - (point.y - viewport_.height / 2.0) / scale_};
if (!valid(result))
return std::unexpected(CameraError::out_of_range);
return result;
}
std::expected<PixelPoint, CameraError> Camera::to_pixels(ScreenPoint point) const {
if (!valid(point))
return std::unexpected(CameraError::invalid_value);
const PixelPoint result{point.x * viewport_.pixel_width / viewport_.width,
point.y * viewport_.pixel_height / viewport_.height};
if (!valid(ScreenPoint{result.x, result.y}))
return std::unexpected(CameraError::out_of_range);
return result;
}
std::expected<ScreenPoint, CameraError> Camera::from_pixels(PixelPoint point) const {
if (!valid(ScreenPoint{point.x, point.y}))
return std::unexpected(CameraError::invalid_value);
const ScreenPoint result{point.x * viewport_.width / viewport_.pixel_width,
point.y * viewport_.height / viewport_.pixel_height};
if (!valid(result))
return std::unexpected(CameraError::out_of_range);
return result;
}
std::expected<void, CameraError> Camera::pan(ScreenPoint delta) {
if (!valid(delta) || std::abs(delta.x) > 32768 || std::abs(delta.y) > 32768)
return std::unexpected(CameraError::invalid_value);
const WorldPoint next{centre_.x_mm + delta.x / scale_, centre_.y_mm - delta.y / scale_};
if (!valid(next))
return std::unexpected(CameraError::out_of_range);
centre_ = next;
return {};
}
std::expected<void, CameraError> Camera::zoom(double factor, ScreenPoint anchor) {
if (!std::isfinite(factor) || factor <= 0 || !valid(anchor) || anchor.x < 0 || anchor.y < 0 ||
anchor.x > viewport_.width || anchor.y > viewport_.height)
return std::unexpected(CameraError::invalid_value);
const double next_scale = scale_ * factor;
if (!valid_scale(next_scale))
return std::unexpected(CameraError::out_of_range);
if (factor == 1)
return {};
const auto world = screen_to_world(anchor);
if (!world)
return std::unexpected(world.error());
const WorldPoint next{world->x_mm - (anchor.x - viewport_.width / 2.0) / next_scale,
world->y_mm + (anchor.y - viewport_.height / 2.0) / next_scale};
if (!valid(next))
return std::unexpected(CameraError::out_of_range);
centre_ = next;
scale_ = next_scale;
return {};
}
} // namespace evo::client
+64
View File
@@ -0,0 +1,64 @@
#include "evo/client/input.hpp"
#include <algorithm>
#include <cmath>
#include <limits>
namespace evo::client {
void InputState::clear() noexcept {
keys_.fill(false);
wheel_ = 0;
}
void InputState::admit(bool enabled) noexcept {
if (!enabled)
clear();
admitted_ = enabled;
}
void InputState::capture(bool captured) noexcept {
if (captured)
clear();
captured_ = captured;
}
std::expected<void, InputError> InputState::key(Key key, bool down, bool repeat) {
const auto index = static_cast<std::size_t>(key);
if (index >= keys_.size())
return std::unexpected(InputError::invalid_key);
if (!down)
keys_[index] = false;
else if (enabled() && !repeat)
keys_[index] = true;
return {};
}
std::expected<void, InputError> InputState::pointer(ScreenPoint point) {
if (!std::isfinite(point.x) || !std::isfinite(point.y) || std::abs(point.x) > 32768 ||
std::abs(point.y) > 32768)
return std::unexpected(InputError::invalid_pointer);
pointer_ = point;
return {};
}
std::expected<void, InputError> InputState::wheel(double steps) {
if (!std::isfinite(steps) || std::abs(steps) > 128)
return std::unexpected(InputError::invalid_wheel);
if (enabled())
wheel_ = std::clamp(wheel_ + steps, -8.0, 8.0);
return {};
}
Navigation InputState::take_navigation() noexcept {
const Navigation result{static_cast<int>(keys_[5]) - static_cast<int>(keys_[4]),
static_cast<int>(keys_[7]) - static_cast<int>(keys_[6]), wheel_,
pointer_};
wheel_ = 0;
return result;
}
std::expected<Intention, InputError> InputState::sample(std::uint64_t tick) {
if (tick_ && tick <= *tick_)
return std::unexpected(InputError::stale_tick);
if (sequence_ == std::numeric_limits<std::uint64_t>::max())
return std::unexpected(InputError::exhausted);
const int x = static_cast<int>(keys_[1]) - static_cast<int>(keys_[0]);
const int y = static_cast<int>(keys_[2]) - static_cast<int>(keys_[3]);
const int magnitude = x != 0 && y != 0 ? 707 : 1000;
tick_ = tick;
return Intention{++sequence_, tick, static_cast<std::int16_t>(x * magnitude),
static_cast<std::int16_t>(y * magnitude)};
}
} // namespace evo::client
+93 -4
View File
@@ -9,6 +9,28 @@
namespace evo::client {
namespace {
bool runtime_owned = false; // Process main-thread-only contract; no hidden threads.
std::optional<Key> input_key(SDL_Scancode code) {
switch (code) {
case SDL_SCANCODE_A:
return Key::left;
case SDL_SCANCODE_D:
return Key::right;
case SDL_SCANCODE_W:
return Key::up;
case SDL_SCANCODE_S:
return Key::down;
case SDL_SCANCODE_LEFT:
return Key::pan_left;
case SDL_SCANCODE_RIGHT:
return Key::pan_right;
case SDL_SCANCODE_UP:
return Key::pan_up;
case SDL_SCANCODE_DOWN:
return Key::pan_down;
default:
return std::nullopt;
}
}
struct Runtime {
bool acquired{false};
~Runtime() {
@@ -26,6 +48,8 @@ struct Application::Impl {
std::string renderer_name;
WindowState state;
std::optional<Error> failure;
InputState input;
bool backlogged{false};
std::expected<void, Error> refresh() {
if (!SDL_GetWindowSize(window.get(), &state.logical_width, &state.logical_height) ||
@@ -47,6 +71,24 @@ WindowState Application::state() const noexcept {
result.failed = impl_->failure.has_value();
return result;
}
void Application::set_ui_capture(bool captured) noexcept {
if (impl_->input.captured() && !captured) {
// An external UI can release capture with old input still queued in SDL.
// Drain that batch before admitting fresh world presses.
impl_->backlogged = true;
impl_->input.admit(false);
}
impl_->input.capture(captured);
}
bool Application::ui_captured() const noexcept {
return impl_->input.captured();
}
Navigation Application::take_navigation() noexcept {
return impl_->input.take_navigation();
}
std::expected<Intention, InputError> Application::sample_intention(std::uint64_t tick) {
return impl_->input.sample(tick);
}
std::expected<std::unique_ptr<Application>, Error> Application::open(const Config& config) {
if (config.width <= 0 || config.height <= 0 || config.width > 32768 || config.height > 32768 ||
config.renderer.size() > 64 || config.renderer.find('\0') != std::string::npos)
@@ -79,15 +121,22 @@ std::expected<std::unique_ptr<Application>, Error> Application::open(const Confi
return std::unique_ptr<Application>{new Application{std::move(impl)}};
}
std::expected<Step, Error> Application::step(const render::Frame& frame) {
if (auto result = poll_events(); !result)
return std::unexpected(result.error());
return present(frame);
}
std::expected<void, Error> Application::poll_events() {
auto& p = *impl_;
if (p.failure)
return std::unexpected(*p.failure);
if (p.state.closed)
return Step::closed;
return {};
p.input.admit(p.state.accepts_input() && !p.backlogged);
const auto id = SDL_GetWindowID(p.window.get());
bool reset = false;
SDL_Event event{};
for (int count = 0; count < 256 && SDL_PollEvent(&event); ++count) {
int count = 0;
for (; count < 256 && SDL_PollEvent(&event); ++count) {
if (event.type == SDL_EVENT_QUIT)
p.state.closed = true;
if (event.type >= SDL_EVENT_WINDOW_FIRST && event.type <= SDL_EVENT_WINDOW_LAST &&
@@ -119,6 +168,29 @@ std::expected<Step, Error> Application::step(const render::Frame& frame) {
break;
}
}
// Admission changes clear held inputs immediately, even if focus returns in this batch.
p.input.admit(p.state.accepts_input() && !p.backlogged);
if ((event.type == SDL_EVENT_KEY_DOWN || event.type == SDL_EVENT_KEY_UP) &&
event.key.windowID == id) {
const bool down = event.type == SDL_EVENT_KEY_DOWN;
if (event.key.scancode == SDL_SCANCODE_TAB && down && !event.key.repeat &&
p.state.accepts_input() && !p.backlogged)
p.input.capture(!p.input.captured());
if (const auto key = input_key(event.key.scancode)) {
if (auto result = p.input.key(*key, down, event.key.repeat); !result)
p.input.admit(false);
}
}
if (event.type == SDL_EVENT_MOUSE_MOTION && event.motion.windowID == id) {
if (auto result = p.input.pointer({event.motion.x, event.motion.y}); !result)
p.input.admit(false);
}
if (event.type == SDL_EVENT_MOUSE_WHEEL && event.wheel.windowID == id) {
const double direction = event.wheel.direction == SDL_MOUSEWHEEL_FLIPPED ? -1 : 1;
if (!p.input.pointer({event.wheel.mouse_x, event.wheel.mouse_y}) ||
!p.input.wheel(event.wheel.y * direction))
p.input.admit(false);
}
if (event.type >= SDL_EVENT_RENDER_TARGETS_RESET &&
event.type <= SDL_EVENT_RENDER_DEVICE_LOST && event.render.windowID == id) {
if (event.type == SDL_EVENT_RENDER_DEVICE_LOST)
@@ -127,32 +199,49 @@ std::expected<Step, Error> Application::step(const render::Frame& frame) {
reset = true;
}
}
if (p.failure)
if (p.failure) {
p.input.admit(false);
return std::unexpected(*p.failure);
}
p.backlogged = count == 256;
p.input.admit(p.state.accepts_input() && !p.backlogged);
if (p.state.closed)
return Step::closed;
return {};
if (reset) {
p.renderer.reset();
auto renderer = detail::make_renderer(p.window.get(), p.renderer_name);
if (!renderer) {
p.failure = renderer.error();
p.input.admit(false);
return std::unexpected(*p.failure);
}
p.renderer = std::move(*renderer);
}
if (auto result = p.refresh(); !result) {
p.failure = result.error();
p.input.admit(false);
return std::unexpected(*p.failure);
}
p.input.admit(p.state.accepts_input() && !p.backlogged);
return {};
}
std::expected<Step, Error> Application::present(const render::Frame& frame) {
auto& p = *impl_;
if (p.failure)
return std::unexpected(*p.failure);
if (p.state.closed)
return Step::closed;
if (p.state.hidden || p.state.minimized || p.state.logical_width == 0 ||
p.state.logical_height == 0 || p.state.pixel_width == 0 || p.state.pixel_height == 0)
return Step::paused;
if (auto result = detail::draw(p.renderer.get(), frame, p.state); !result) {
p.failure = result.error();
p.input.admit(false);
return std::unexpected(*p.failure);
}
if (!SDL_RenderPresent(p.renderer.get())) {
p.failure = Error::draw;
p.input.admit(false);
return std::unexpected(*p.failure);
}
return Step::rendered;
+133
View File
@@ -0,0 +1,133 @@
#include "evo/client/camera.hpp"
#include "evo/client/input.hpp"
#include <array>
#include <cmath>
#include <limits>
#include <source_location>
#include <stdexcept>
#include <string>
namespace {
using namespace evo::client;
void check(bool value, std::source_location at = std::source_location::current()) {
if (!value)
throw std::runtime_error("client controls line " + std::to_string(at.line()));
}
#define CHECK(...) check(static_cast<bool>(__VA_ARGS__))
bool near(double a, double b) {
return std::abs(a - b) < 1e-6;
}
void camera_checks() {
constexpr std::array<Viewport, 4> views{{{800, 600, 800, 600},
{800, 600, 1600, 1200},
{1200, 500, 1800, 1000},
{320, 240, 640, 360}}};
for (const auto view : views)
for (const double scale : {1e-4, 0.25, 1.0, 32.0, 1e4}) {
auto camera = Camera::create(view, {1000000, -1000000}, scale);
CHECK(camera);
for (int i = -5; i <= 5; ++i) {
const WorldPoint world{1000000 + i * 17.125, -1000000 + i * 8.375};
const auto screen = camera->world_to_screen(world);
CHECK(screen);
const auto pixels = camera->to_pixels(*screen);
CHECK(pixels);
const auto logical = camera->from_pixels(*pixels);
CHECK(logical);
const auto restored = camera->screen_to_world(*logical);
CHECK(restored);
CHECK(near(restored->x_mm, world.x_mm) && near(restored->y_mm, world.y_mm));
}
const auto centre = camera->world_to_screen(camera->centre());
CHECK(centre && near(centre->x, view.width / 2.0) &&
near(centre->y, view.height / 2.0));
}
auto camera = Camera::create(views[0]);
CHECK(camera);
const ScreenPoint anchor{123, 456};
const auto before = camera->screen_to_world(anchor);
CHECK(before);
CHECK(camera->zoom(2, anchor));
const auto after = camera->screen_to_world(anchor);
CHECK(after && near(before->x_mm, after->x_mm) && near(before->y_mm, after->y_mm));
CHECK(camera->zoom(0.5, anchor));
CHECK(near(camera->centre().x_mm, 0) && near(camera->centre().y_mm, 0));
CHECK(camera->pan({20, -10}));
CHECK(near(camera->centre().x_mm, 20) && near(camera->centre().y_mm, 10));
CHECK(camera->resize(views[2]));
CHECK(camera->units_per_mm() == 1 && near(camera->centre().x_mm, 20));
const double nan = std::numeric_limits<double>::quiet_NaN();
CHECK(!camera->resize({0, 1, 1, 1}));
CHECK(camera->viewport().width == views[2].width);
CHECK(!camera->zoom(nan, anchor) && !camera->zoom(1e10, anchor));
CHECK(!camera->zoom(1, {-1, 5}) && !camera->pan({nan, 0}));
CHECK(!camera->pan({40000, 0}));
CHECK(!camera->screen_to_world({nan, 0}));
CHECK(!camera->world_to_screen({std::numeric_limits<double>::infinity(), 0}));
CHECK(!camera->from_pixels({nan, 0}) && !camera->to_pixels({nan, 0}));
CHECK(camera->units_per_mm() == 1 && near(camera->centre().x_mm, 20));
CHECK(!Camera::create(views[0], {}, 0));
CHECK(!Camera::create(views[0], {1048576000, 0}));
auto edge = Camera::create(views[0], {1048575999, 0});
CHECK(edge && !edge->pan({2, 0}));
CHECK(edge->centre().x_mm == 1048575999);
CHECK(!edge->screen_to_world({800, 300}));
}
Intention required(std::expected<Intention, InputError> result) {
CHECK(result);
return result.value();
}
void input_checks() {
InputState input;
CHECK(input.key(Key::up, true)); // No focus: ignored.
auto first = input.sample(0);
CHECK(first && first->sequence == 1 && first->move_y == 0 && first->tick == 0);
input.admit(true);
CHECK(input.key(Key::up, true, true)); // Repeats cannot re-arm an ignored press.
CHECK(required(input.sample(1)).move_y == 0);
CHECK(input.key(Key::up, true));
CHECK(input.key(Key::right, true));
const auto diagonal = input.sample(2);
CHECK(diagonal && diagonal->move_x == 707 && diagonal->move_y == 707);
CHECK(diagonal->move_x * diagonal->move_x + diagonal->move_y * diagonal->move_y <= 1000000);
CHECK(input.key(Key::right, false));
const auto straight = input.sample(3);
CHECK(straight && straight->move_x == 0 && straight->move_y == 1000);
CHECK(input.key(Key::down, true));
CHECK(required(input.sample(4)).move_y == 0);
CHECK(input.key(Key::pan_right, true));
CHECK(input.pointer({20, 30}) && input.wheel(128));
const auto nav = input.take_navigation();
CHECK(nav.x == 1 && nav.y == 0 && nav.wheel == 8 && nav.pointer.x == 20);
CHECK(input.take_navigation().wheel == 0);
CHECK(input.wheel(3));
input.capture(true);
CHECK(required(input.sample(5)).move_y == 0 && input.take_navigation().x == 0);
CHECK(input.key(Key::up, true) && input.wheel(4));
input.capture(false);
CHECK(required(input.sample(6)).move_y == 0 && input.take_navigation().wheel == 0);
CHECK(input.key(Key::up, true, true));
CHECK(required(input.sample(7)).move_y == 0);
CHECK(input.key(Key::up, false) && input.key(Key::up, true));
CHECK(required(input.sample(8)).move_y == 1000);
input.admit(false);
input.admit(true);
CHECK(required(input.sample(9)).move_y == 0);
CHECK(!input.sample(9) && !input.sample(8));
const auto next = input.sample(10);
CHECK(next && next->sequence == 11);
CHECK(!input.key(static_cast<Key>(255), true));
CHECK(!input.wheel(std::numeric_limits<double>::quiet_NaN()));
CHECK(!input.pointer({1e9, 0}));
CHECK(input.take_navigation().wheel == 0);
InputState exhausted{std::numeric_limits<std::uint64_t>::max()};
const auto failure = exhausted.sample(1);
CHECK(!failure && failure.error() == InputError::exhausted);
CHECK(input.sample(std::numeric_limits<std::uint64_t>::max()));
CHECK(!input.sample(0));
}
} // namespace
void client_controls_tests() {
camera_checks();
input_checks();
}
+98
View File
@@ -10,6 +10,7 @@
#include <string>
#include <vector>
void client_controls_tests();
namespace {
using namespace evo::client;
void check(bool ok, std::source_location at = std::source_location::current()) {
@@ -147,10 +148,107 @@ void lifecycle() {
send(SDL_EVENT_QUIT, 0);
CHECK((*hidden)->step(frame) == Step::closed);
}
Intention required(std::expected<Intention, InputError> result) {
CHECK(result);
return result.value();
}
void native_input() {
const auto frame = fixture();
auto result = Application::open({320, 240, false, "software"});
CHECK(result);
auto app = std::move(result.value());
CHECK(app->poll_events());
const auto id = SDL_GetWindowID(window());
send(SDL_EVENT_WINDOW_FOCUS_GAINED, id);
auto key = [id](SDL_Scancode scancode, bool down, bool repeat = false) {
SDL_Event event{};
event.type = down ? SDL_EVENT_KEY_DOWN : SDL_EVENT_KEY_UP;
event.key.windowID = id;
event.key.scancode = scancode;
event.key.repeat = repeat;
CHECK(SDL_PushEvent(&event));
};
key(SDL_SCANCODE_W, true);
key(SDL_SCANCODE_RIGHT, true);
CHECK(app->poll_events());
const auto first = app->sample_intention(40);
CHECK(first && first->move_y == 1000 && first->sequence == 1 && first->tick == 40);
CHECK(app->take_navigation().x == 1);
key(SDL_SCANCODE_W, false);
CHECK(app->poll_events());
CHECK(required(app->sample_intention(41)).move_y == 0);
key(SDL_SCANCODE_W, true);
send(SDL_EVENT_WINDOW_FOCUS_LOST, id);
send(SDL_EVENT_WINDOW_FOCUS_GAINED, id);
key(SDL_SCANCODE_W, true, true);
CHECK(app->poll_events());
CHECK(required(app->sample_intention(42)).move_y == 0 && app->take_navigation().x == 0);
key(SDL_SCANCODE_W, true);
CHECK(app->poll_events());
app->set_ui_capture(true);
CHECK(required(app->sample_intention(43)).move_y == 0);
key(SDL_SCANCODE_W, true);
CHECK(app->poll_events());
app->set_ui_capture(false);
CHECK(required(app->sample_intention(44)).move_y == 0);
CHECK(app->poll_events());
key(SDL_SCANCODE_TAB, true);
key(SDL_SCANCODE_W, true);
CHECK(app->poll_events());
CHECK(app->ui_captured() && required(app->sample_intention(45)).move_y == 0);
key(SDL_SCANCODE_TAB, true, true);
CHECK(app->poll_events());
CHECK(app->ui_captured());
key(SDL_SCANCODE_TAB, false);
key(SDL_SCANCODE_TAB, true);
key(SDL_SCANCODE_W, true);
CHECK(app->poll_events());
CHECK(!app->ui_captured() && required(app->sample_intention(46)).move_y == 1000);
// A saturated event batch cancels motion until the backlog drains.
for (int i = 0; i < 300; ++i)
key(SDL_SCANCODE_RIGHT, true);
CHECK(app->poll_events());
CHECK(required(app->sample_intention(47)).move_y == 0 && app->take_navigation().x == 0);
CHECK(app->poll_events());
CHECK(required(app->sample_intention(48)).move_y == 0 && app->take_navigation().x == 0);
SDL_Event wheel{};
wheel.type = SDL_EVENT_MOUSE_WHEEL;
wheel.wheel.windowID = id;
wheel.wheel.y = 2;
wheel.wheel.mouse_x = 123;
wheel.wheel.mouse_y = 45;
wheel.wheel.direction = SDL_MOUSEWHEEL_FLIPPED;
CHECK(SDL_PushEvent(&wheel));
CHECK(app->poll_events());
const auto navigation = app->take_navigation();
CHECK(navigation.wheel == -2 && navigation.pointer.x == 123 && navigation.pointer.y == 45);
app->set_ui_capture(true);
CHECK(SDL_PushEvent(&wheel));
CHECK(app->poll_events());
CHECK(app->take_navigation().wheel == 0);
app->set_ui_capture(false);
key(SDL_SCANCODE_W, true);
CHECK(app->poll_events());
key(SDL_SCANCODE_W, true);
send(SDL_EVENT_WINDOW_MINIMIZED, id);
CHECK(app->poll_events());
CHECK(required(app->sample_intention(49)).move_y == 0);
send(SDL_EVENT_WINDOW_RESTORED, id);
CHECK(app->poll_events());
CHECK(required(app->sample_intention(50)).move_y == 0);
app->set_ui_capture(true);
key(SDL_SCANCODE_W, true); // Queued while captured; releasing capture must not replay it.
app->set_ui_capture(false);
CHECK(app->poll_events());
CHECK(required(app->sample_intention(51)).move_y == 0);
CHECK(app->present(frame) == Step::rendered);
}
} // namespace
int main() try {
client_controls_tests();
frame_contract();
lifecycle();
native_input();
return 0;
} catch (const std::exception& e) {
std::fprintf(stderr, "%s: %s\n", e.what(), SDL_GetError());