a86fb1c | plum | pyrossh

git clone https://git.pyrossh.dev/plum

A statically typed, imperative programming language inspired by rust, python

a86fb1c — Peter John 2026-11-04T14:39:29+05:30

Game scenes: methods on types instead of free functions; scene styles doc

Files changed (20) hide show

README.md +11 -15
docs/backlog.md +2 -0
docs/decisions/2026-11-language-and-scene-decisions.md +1 -0
docs/game-scene-styles.md +139 -0
plum-core/src/drive.rs +19 -4
plum-core/tests/drive_test.rs +1 -1
plum-examples/games/functional/game_state_view.plum +9 -8
plum-examples/games/pure/game_pure_scene.plum +26 -27
plum-game/web-test/fixtures/stress_pure_scene.plum +8 -9
plum-game/web-test/fixtures/stress_state_view.plum +5 -5
plum-game/web-test/fixtures/stress_state_view_deep.plum +3 -3
plum-std/game/Color.plum +7 -0
plum-std/game/functional/FunctionalScene.plum +357 -0
plum-std/game/functional/Picture.plum +0 -352
plum-std/game/functional/Ui.plum +3 -3
plum-std/game/pure/Actions.plum +85 -87
plum-std/game/pure/PureScene.plum +486 -134
plum-std/game/pure/SceneInput.plum +57 -57
plum-std/game/pure/SceneTree.plum +0 -350
plum-wasm-codegen/tests/fusion_alloc_test.rs +6 -6

README.md CHANGED Viewed

@@ -851,7 +851,7 @@ What it does:
 - **Fuses a pure producer into its consumer.** A function is a candidate only when it is expression-bodied: bindings plus one tail expression (`= match`, `= if`, `= Ctor(..)`, `= call`); block bodies with early returns are skipped (`--explain-fusion` says `not expression-bodied`). When a candidate is pure (no `Io` reachable, no writes outside its own fresh values) and its result is used once, by a function that is one `match` on that parameter, the call is specialised on the producer's constructors and the intermediate value is never built. `sumL(mapCells(xs))` becomes one loop.
 - **List chains.** `xs.map(f).filter(g).reduce(...)`-style chains on `List` fuse the same way, so the intermediate lists disappear (the reason `List.filter` is written in direct recursive style).
-- **View to draw.** `Picture.draw(view(state))` fuses the scene built by a pure `view` into the draw walk, so the frame's picture tree is not allocated.
+- **View to draw.** `view(state).draw(io)` fuses the scene built by a pure `view` into the draw walk, so the frame's picture tree is not allocated.
 - **Uniqueness to in-place spreads.** `markUnique` proves that a spread source (`T(..x, f: v)`) is not used afterwards and not shared, and marks the construction `unique`: codegen then writes the fields into `x` instead of copying it.
 - **Reuse.** A same-shape rebuild of a value that is dead afterwards (a `match` arm that rebuilds the constructor it matched) reuses the old cell.
@@ -1364,12 +1364,11 @@ The page calls `init` once after the assets are loaded, then `update` and `draw`
 ### Pure scene graph
-The pure scene graph is the same kind of tree as `std/game/imperative/Scene`, but a function never changes a value it was only given: updates take an actor, change it in place when it is proved unique (see [In-place updates](#in-place-updates)) and hand it back, so no `clone()` is needed. `Actor` is a `trait` and `Group`, `Sprite`, `Label`, `Button` and `Stage` are `record`s. The graph is split into four modules: `std/game/pure/Actions` (timed actions such as `forever(rotateBy(...))`), `std/game/pure/PureScene` (the `Actor` trait and its leaves, `group`, `sprite`, `button`, and the draw walk), `std/game/pure/SceneTree` (update, hit testing, paths and event routing) and `std/game/pure/SceneInput` (`Stage`, pointer capture and `UiEvent`). A game imports them by name:
+The pure scene graph is the same kind of tree as `std/game/imperative/Scene`, but a function never changes a value it was only given: updates take a node, change it in place when it is proved unique (see [In-place updates](#in-place-updates)) and hand it back, so no `clone()` is needed. Every node is a `Node` record (a `Transform`, an id, colour, visibility, its running `actions` and a `Kind`: `Group`, `Sprite`, `Label`, `Button` or `Custom(actor)`); game behaviour is an `Actor` trait in a `Custom` node. The graph is three modules: `std/game/pure/Actions` (timed `Action`s such as `Action.forever(Action.rotateBy(..))`), `std/game/pure/PureScene` (`Node` and its methods: `Node.group`/`sprite`/`label`/`button`/`custom`, `update`, `drawTree`, `findHit`, `findPath`, `modify` and `route`) and `std/game/pure/SceneInput` (`Stage`, pointer capture, `Input.poll`). A game imports them by name:
 ```
 import std/game/pure/Actions
 import std/game/pure/PureScene
-import std/game/pure/SceneTree
 import std/game/pure/SceneInput
 ```
@@ -1379,16 +1378,13 @@ A minimal game holds a `Stage` and replaces it each frame:
 record World(mut stage: Stage, mut wasDown: Bool)
 export fun init(io: Io) -> World =
-  spr := PureScene.sprite(2, 0, 100.0, 100.0, 48.0, 48.0)
+  spr := Node.sprite(2, 0, 100.0, 100.0, 48.0, 48.0)
-  spr.actions = Slice(Actions.forever(Actions.rotateBy(1.0, 1.0)))
+  spinning := Node(..spr, actions: Slice(Action.forever(Action.rotateBy(1.0, 1.0))))
-  sp: Actor := spr
-  kids := Slice[Actor]()
-  kids.push(sp)
-  root: Actor := PureScene.group(1, 0.0, 0.0, 800.0, 600.0, kids)
+  root := Node.group(1, 0.0, 0.0, 800.0, 600.0, Slice(spinning))
-  World(stage: SceneInput.stage(root), wasDown: false)
+  World(stage: Stage.create(root), wasDown: false)
 export fun update(io: Io, w: World, dt: Float) =
-  inputs := SceneInput.pollPointer(io, w.wasDown)
+  inputs := Input.poll(io, w.wasDown)
   w.wasDown = io.isMouseDown(0)
   w.stage = w.stage.frame(dt, inputs).intoStage()
@@ -1399,22 +1395,22 @@ export fun draw(io: Io, w: World) =
 - **Immediate mode** ([`game.plum`](plum-examples/games/imperative/game.plum)): one state record and a `draw` that issues the calls every frame. Use it for flat arcade games with a few kinds of thing.
 - **Scene** ([`game_scene.plum`](plum-examples/games/imperative/game_scene.plum)): a retained tree of actors with `mut` fields. Use it when you want objects that change in place and a familiar `act`/`draw` object model.
 - **Pure scene** ([`game_pure_scene.plum`](plum-examples/games/pure/game_pure_scene.plum)): every update takes an actor and hands back an updated one (written in place when uniqueness proves it), pointer clicks arrive as `UiEvent`s, and the rules can be tested without a host. Use it when you want pure updates and tests that run without a game host.
-- **State/view** ([`game_state_view.plum`](plum-examples/games/functional/game_state_view.plum)): the game state is plain data and a `view` turns it into `std/game/functional/Picture`, a recursive picture type drawn by recursive functions. Use it when you want to draw from state instead of keeping a tree of actors.
+- **State/view** ([`game_state_view.plum`](plum-examples/games/functional/game_state_view.plum)): the game state is plain data and a `view` turns it into a `SceneNode` (`std/game/functional/FunctionalScene`), a recursive data type whose methods draw, measure and hit-test it. Use it when you want to draw from state instead of keeping a tree of actors.
 ### Functional scenes (state/view)
-Three scene styles ship, each in its own folder: `std/game/imperative/Scene` (actors with `mut` fields, in `plum-examples/games/imperative`), `std/game/pure/*` (pure-update actors, in `plum-examples/games/pure`) and `std/game/functional/*` (plain state plus a `view`, in `plum-examples/games/functional`); the shared assets and generators are in `plum-examples/games/assets` and `plum-examples/games/tools`. The functional style is a loop of `State -> view -> draw`: the game state is plain data, `view(state)` builds a `SceneNode` (`std/game/functional/Picture`) and `draw` walks it. Nothing is retained between frames.
+Three scene styles ship, each in its own folder: `std/game/imperative/Scene` (actors with `mut` fields, in `plum-examples/games/imperative`), `std/game/pure/*` (pure-update actors, in `plum-examples/games/pure`) and `std/game/functional/*` (plain state plus a `view`, in `plum-examples/games/functional`); the shared assets and generators are in `plum-examples/games/assets` and `plum-examples/games/tools`. The functional style is a loop of `State -> view -> draw`: the game state is plain data, `view(state)` builds a `SceneNode` (`std/game/functional/FunctionalScene`) and `draw` walks it. Nothing is retained between frames.
 The functional game is written in a component style: each kind of thing is a record with an `update(self, ..)` that returns the next value and a `render(self, ..)` that returns its `SceneNode` (`Ship.update`/`Ship.render`, `Orb`, `Mine`, `Star`), and `State.render` composes them. `update` never changes a value it was given.
 - **`Anim`** describes motion as a function of time: `MoveBy`, `RotateBy`, `ScaleTo`, `Delay`, `Seq`, `Par` and `Forever`. `Anim.at(anim, t)` returns an `AnimPose` (dx, dy, rotation, scaleX, scaleY) for any `t`, so a view just applies the pose for `state.clock`.
-- **`Ui`** is pure pointer state. `Picture.hitId(view, x, y)` finds the `Tagged(id, child)` node under the pointer; `Ui.step(ui, input, hit)` returns a `UiStep` with the new `UiState` and the `UiEvent`s raised (`Press`, `Release`, `Click`, `Enter`, `Exit`, with pointer capture). `Ui.button(id, label, x, y, w, h, ui)` builds a tagged button that shows hover and pressed looks.
+- **`Ui`** is pure pointer state. `view.hitId(x, y)` finds the `Tagged(id, child)` node under the pointer; `Ui.step(ui, input, hit)` returns a `UiStep` with the new `UiState` and the `UiEvent`s raised (`Press`, `Release`, `Click`, `Enter`, `Exit`, with pointer capture). `Ui.button(id, label, x, y, w, h, ui)` builds a tagged button that shows hover and pressed looks.
 From [`game_state_view.plum`](plum-examples/games/functional/game_state_view.plum) (a method of `State`): `feed` runs `Ui.step` against the picture the player sees, then hands each event to `update`.
 ```
 fun feed(self, input: UiInput) -> State =
-  r := Ui.step(self.ui, input, Picture.hitId(self.render(), input.x, input.y))
+  r := Ui.step(self.ui, input, self.render().hitId(input.x, input.y))
   r.events.fold(State(..self, ui: r.ui), |s, e| s.update(UiEv(event: e)))
 ```

docs/backlog.md CHANGED Viewed

@@ -38,3 +38,5 @@ Open work, in the order the user queued it, plus smaller items found during buil
 - **Structural deep `==` for records** — user chose deep structural equality (like Rust `#[derive(PartialEq)]`), deferred before implementation; until then `==` on records is identity. (state-view parity T7)
 - **Retire PureScene?** — after the component-style functional game, decide whether `std/game/pure` + `games/pure` stay. (Decision record §4b)
 - **`adder(1)(2)`** (calling a returned closure directly) is not supported. (functional-gaps plan)
+- **Fusion past a closure-spec copy on `Nil` miscompiles** — in `drive.rs` `quiet`, resolving `Nil.fold$c0(..)` to `List.fold$c0` (read-only) lets a value move past it, and codegen then fails with `unknown method 'List.fold$c0'` (5 `closure_spec_test` cases). `typeNameMethodKey` skips `$` copies until this is fixed.
+- **Input model** — one shared `Input` (keys included), `onInput` on actors, optional typed `Msg` events; proposal in [game-scene-styles.md](game-scene-styles.md) section 6. Not started.

docs/decisions/2026-11-language-and-scene-decisions.md CHANGED Viewed

@@ -15,6 +15,7 @@ A record of the design decisions taken in the 2026-11-03/04 sessions, with the r
   - `plum-std/game/imperative/`: the mutable `Scene` (moved 2026-11-04, user).
   - `plum-std/game/pure/`: PureScene, SceneTree, SceneInput, Actions (pure updates, in place via `own` today).
   - `plum-std/game/functional/`: Picture, Anim, Ui (state/view).
+  - **Update 2026-11-04 (user):** `Picture` was renamed `FunctionalScene` and `SceneTree` was merged into `PureScene`; their free functions became methods on `SceneNode`/`Node`/`Action` etc. See [game-scene-styles.md](../game-scene-styles.md).
   - `plum-examples/games/imperative/`, `games/pure/` and `games/functional/` for their example games (the mutable games moved too, 2026-11-04). PureScene is imperative under an ownership discipline (`act(own n)` edits a retained tree in place); only the functional component style is functional. `plum game` finds assets in the nearest parent `assets/` folder.
 - **Examples (user, 2026-11-04):** examples consolidated from 34 files to about 20 topical ones (every test kept), the mutable `game_loop` moved to `games/imperative/`, and the shared game assets moved to `plum-examples/games/assets/`.

docs/game-scene-styles.md ADDED Viewed

@@ -0,0 +1,139 @@
+# Game scene styles
+Plum ships three ways to structure a game's scene. This page compares them, maps them to engines people know, says how far each is from deterministic simulation, and proposes a better input model (section 6, not built yet).
+Decisions behind the styles are in [decisions/2026-11-language-and-scene-decisions.md](decisions/2026-11-language-and-scene-decisions.md).
+## 1. The three styles
+| | Imperative | Pure | Functional |
+|---|---|---|---|
+| Std modules | `std/game/imperative/Scene` | `std/game/pure/PureScene`, `SceneInput`, `Actions` | `std/game/functional/FunctionalScene`, `Ui`, `Anim` |
+| Example | `games/imperative/game_scene.plum` | `games/pure/game_pure_scene.plum` | `games/functional/game_state_view.plum` |
+| Scene tree | Kept across frames, changed in place | Kept across frames, each update returns the next tree (in place when the compiler proves it unique) | Rebuilt from `State` every frame, then thrown away |
+| Where game data lives | In actors (`record Walker(Actor, mut speed: Float)`) | In nodes (`Node` fields, `actions`, `Custom(actor)`) | In your own `State` and per-kind records (`Ship`, `Orb`); the tree holds none |
+| Per-frame entry | `stage.act(dt)`, `stage.draw(io)` | `stage.frame(dt, inputs)`, `stage.draw(io)` | `state.update(msg)`, `state.render().draw(io)` |
+| Behaviour | Override `act`/`draw`/`hit` on the `Actor` trait | `Actor` trait (`act`, `draw`) in a `Custom` node, plus timed `Action`s | Methods on your records; nodes have none |
+| Finding a node | Object references (`same(a, b)`) | By id or path: `root.findPath(id)`, `root.modify(id, f)` | Not needed: change `State`, the next `render()` shows it |
+| Animation | Code in `act` | `Action.forever(Action.rotateBy(..))`, stepped each frame | `Anim.at(anim, t)`, a function of time; nothing is stepped |
+| Children | `Slice` of actors | `Slice[Node]` | `List[SceneNode]` |
+### Main API (after the 2026-11-04 method refactor)
+- **Pure:** `Node.group/sprite/label/button/custom(..)` build nodes. `node.update(dt)`, `node.drawTree(io, m, tint)`, `node.findHit(m, p)`, `node.findPath(id)`, `node.modify(id, f)`, `node.route(path, depth, e)` and `node.onPointer(e)` work on them. `Stage.create(root)`, `stage.frame(dt, inputs)`, `stage.draw(io)` and `Input.poll(io, wasDown)` run a frame. `Action.moveBy/rotateBy/delay/sequence/parallel/forever(..)` and `action.step(pose, dt)` drive animations.
+- **Functional:** `SceneNode` is an enum (`Group`, `Filter`, `Sprite`, `Text`, `RectShape`, `CircleShape`, `LineShape`, `Tagged`). `node.draw(io)`, `node.bounds()`, `node.hitPath(x, y)` and `node.hitId(x, y)` use it. `Transform.matrix()`, `Effect.tint(alpha)` and `Rect` methods are the helpers. `Ui.step(ui, input, hitId)` and `Ui.button(..)` handle UI.
+## 2. Engine analogies
+| Plum style | Closest engine model | Notes |
+|---|---|---|
+| Imperative | **Flame** (Flutter's game engine), libGDX **Scene2D** | `Stage` ~ `FlameGame`, `Actor` ~ `PositionComponent`, `act(dt)` ~ `update(dt)`, `draw` ~ `render(canvas)`, `add`/`remove`/`zIndex` ~ `add`/`remove`/`priority`, `hit` ~ `containsLocalPoint`. The names come from Scene2D; the model is the same as Flame's. |
+| Pure | None directly | An immutable Flame/Scene2D: the same component tree, updated by returning copies. Closest to Redux applied to a scene graph. Flutter never has you update its retained tree; the framework owns it. |
+| Functional | **Elm**, and **Flutter's widget layer** | `render()` ~ `build()`, `SceneNode` ~ immutable widgets. Flutter also keeps an Element tree (diffed, holds local `State`) and a RenderObject tree (layout, paint); Plum has neither. Nothing is retained, so nothing is diffed: every frame is redrawn, and the compiler fuses `render` into `draw` so the tree is never built. There is no local widget state (everything is in `State`), no keys and no constraint layout (positions are absolute). |
+## 3. Pure vs functional
+Both avoid mutation in game logic. The difference is **where the state lives**:
+- In **pure**, the tree *is* the game state. Changing the game means finding a node (`findPath`, `modify`) and returning a new tree. Nodes carry their own behaviour (`Actor`) and animations (`actions`), and pointer input changes nodes (a button's `pressed`/`over`).
+- In **functional**, the tree is a *picture of* the game state. Changing the game means changing `State`; the next `render()` reflects it. Hover and press state lives in `UiState` inside `State`, and buttons are found with `Tagged(id, ..)` + `hitId`.
+Cost: pure updates run in place when the compiler proves uniqueness. Functional describes the whole frame each time, but fusion removes the tree (see `fusion_alloc_test.rs`, `state_view_draw_has_no_scenenode_alloc`).
+## 4. Determinism
+**Goal:** the same seed and the same inputs produce the same game, bit for bit, on every machine. This enables replays, lockstep multiplayer, rollback and desync checks (planned: [backlog](backlog.md), "deterministic sim").
+### Already in place (all three styles)
+- **Seeded randomness.** Every game uses a `Random` value threaded through its state (`Random.seeded(seed)`), never a host call per draw.
+- **Math in Plum.** `Math.sin/cos/sqrt/hypot` are written in Plum (`std/Math.plum`), not imported from the browser, so they don't vary between JS engines.
+- **wasm floats.** wasm `f64` arithmetic is IEEE 754 and gives the same results everywhere (only NaN bit patterns can differ).
+- **Deterministic maps.** `Map` uses a fixed FNV-1a hash, so iteration order depends only on the insert sequence.
+### Still missing (all three styles)
+1. **Fixed timestep.** `plum_bridge.js` passes the real frame time (`dt = (now - last) / 1000`) to `update`. The simulation must instead advance in fixed steps (for example 1/60 s), with the shell accumulating real time and running 0..n steps per frame.
+2. **Recorded seed.** `init` calls `io.randomSeed()`; a replay must record and supply that seed.
+3. **Recorded input.** Keyboard and mouse are read straight from `io` in the game shell (`io.isKeyDown`, `io.mousePos`). Everything the simulation reads from the host must go through one recorded input list per step (see section 6).
+4. **Host values in state.** The functional game stores the screen size (`sw`, `sh`) and gets `Resize` messages; these must be in the input log too, or kept out of the simulation.
+5. **Checksums.** A per-step hash of the simulation state, to detect desyncs.
+### How hard each style is
+1. **Functional: easiest.** All game state is one immutable `State`, and everything that happens arrives as a `Msg` (`Tick`, `Resize`, `Restart`, `UiEv`). A replay is the seed plus the `Msg` list, applied with `State.update` in order. Rollback is keeping an old `State` (nothing changes it). A checksum hashes `State`. Only the `World` shell, which turns keyboard and mouse into messages, touches `io`.
+2. **Pure: moderate.** Updates are pure too, but state is split between the `Stage` tree and the `World` fields, and the tree is updated in place, so a snapshot needs an explicit deep copy. Inputs already arrive as a list per frame (`Input.poll`), which is easy to record.
+3. **Imperative: hardest.** State is a mutable object graph: snapshots and checksums need a deep walk, and any code may read `io`. Replay still works if every step's inputs are recorded and nothing else reads the host.
+**Recommendation:** build deterministic simulation on the functional style first. Its `Msg` stream is already the replay log.
+## 5. Input today
+Each style handles input differently:
+| | Imperative | Pure | Functional |
+|---|---|---|---|
+| Pointer | Game asks `stage.hit(x, y)` and handles the result itself | `Input.poll` -> `stage.frame(dt, inputs)` -> hit path -> `node.route` -> `onPointer` (only `Button` reacts) -> `UiEvent`s | Shell builds a `UiInput` -> `render().hitId(x, y)` -> `Ui.step` -> `UiEvent`s -> `Msg.UiEv` |
+| Keyboard | Read from `io` | Read from `io` in the shell | Read from `io` in the shell, folded into `Tick(dt, ax, ay)` |
+| Event type | none | `UiEvent(id: Int, kind: UiKind)` | its own `UiEvent(id: Int, kind: UiKind)` |
+| Capture (press, drag off, release) | none | yes | yes |
+Problems:
+- **Two event types.** `PureScene` and `Ui` each define `UiKind`/`UiEvent`/pointer kinds with the same meaning.
+- **Untyped events.** Games compare integer ids: `if e.id == Id.Restart && e.kind == Click`. Nothing checks that ids are unique or that the game handles every button.
+- **No input hook for game actors.** In pure, a `Custom` actor has only `act` and `draw`; only the built-in `Button` reacts to the pointer. In imperative, actors have `hit` but no input method.
+- **Keyboard bypasses everything.** It is read directly from `io`, so it is not part of any event stream: there is no focus, and it is not recorded (determinism item 3).
+## 6. Proposal: one input model with `onInput` (not built)
+The sketch `scene_graph.pfl` (repo root, not tracked) designs input for a scene2d-style pure scene:
+```
+trait Actor<Msg> {
+  fn on_input(self: own Self, input: Input) -> (own Self, List<Msg>) = (self, [])
+  fn route(self: own Self, path: Path, input: Input) -> (own Self, List<Msg>)
+}
+class Button<Msg> { .., pressed: Bool, on_click: Msg }
+enum Input { PointerDown(Vec2), PointerUp(Vec2), PointerMove(Vec2), Key(Int) }
+```
+Its ideas:
+- one `Input` type that includes keys;
+- an overridable `on_input` on every actor;
+- bubbling along the hit path, child first and then each parent, with messages flowing back up;
+- **typed messages**: a button carries the game's own `Msg` value, so the game matches on `StartPressed` instead of comparing ids.
+Plum's pure scene already has the path routing (`route` delivers child first, then each ancestor) and adds pointer capture, which the sketch lacks. The rest maps onto Plum in steps, ordered so each one stands alone.
+### Step 1: one shared `Input` type, keys included (no generics)
+- Move pointer and key input into `std/game/Input.plum`, shared by all styles: `enum Input = PointerDown(x, y) | PointerUp(x, y) | PointerMove(x, y) | KeyDown(key: Int) | KeyUp(key: Int)`. `Input.poll(io, prev) -> Slice[Input]` is the only code that reads input from `io`.
+- Define one shared `UiKind`/`UiEvent`, and delete the duplicates in `PureScene` and `Ui`.
+- Games keep held keys in their state (`Keys`, updated from `KeyDown`/`KeyUp`) instead of calling `io.isKeyDown`.
+- **Gain:** one recorded input list per step (determinism item 3), and one vocabulary across styles.
+### Step 2: `onInput` for game actors (no generics)
+- **Pure:** `trait Actor` gains `fun onInput(self, n: Node, e: Input) -> Handled` (default: unchanged node, no events). `route` calls it on `Custom` nodes along the path, like `onPointer` for `Button`. `Handled` gains `consumed: Bool`, so a child can stop the event reaching its parents (like the DOM's `stopPropagation`).
+- **Imperative:** `trait Actor` gains `fun onInput(self, e: Input) -> Bool` (true = consumed), called child first along the hit path. This is Scene2D's `InputListener` and Flame's `TapCallbacks`.
+- **Functional:** no methods on nodes. Instead, interactive nodes are data, as in Elm: `Tagged(id, child)` stays, and `Ui.step` reports events for it.
+- **Keyboard focus:** `UiState`/`Stage` keep a focused id. `KeyDown` goes to the focused node's `onInput` first; unconsumed keys go to the game.
+### Step 3 (optional): typed messages instead of ids (needs generics)
+- **Functional:** `SceneNode[Msg]` gains `OnClick(msg: Msg, child: SceneNode[Msg])` and similar, and `Ui.step` returns `List[Msg]`. The game writes `Ui.button(Restart, "Again", ..)` and `match msg Restart => ..`; no ids, and the compiler checks every message is handled.
+- **Pure:** `Node[Msg]`, `Button(.., onClick: Msg)`, `Actor[Msg]`.
+- **This reopens a decision:** generic `Node[K]`/`Actor[Msg]` was rejected on 2026-11-03 ("Generics can be tried later"), and generic traits are not supported yet. A generic *enum* (`SceneNode[Msg]`) is supported, so the functional style could try it first, but fusion of `render().draw(io)` must be checked on a generic `SceneNode`.
+### Recommendation
+1. Do steps 1 and 2: no language work, shared vocabulary, and they unblock deterministic replay.
+2. Try step 3 on the functional style only, once steps 1 and 2 are in, and keep it if fusion still holds.
+3. Decide whether PureScene stays (backlog: "Retire PureScene?"). If it is retired, step 2's pure half is not needed.
+### Open questions
+- Should pointer events reach a node's parents after a child consumes them (Flame: no, the DOM: yes unless stopped)?
+- Should `onInput` see the event in local coordinates (as `onPointer` does today) or in world coordinates?
+- Do held-key sets belong in `UiState` (shared) or in each game's state?

plum-core/src/drive.rs CHANGED Viewed

@@ -736,7 +736,7 @@ impl Driver {
                     if t.contains('.') {
                         return vec![]; // a method on a constant (`Color.White.withAlpha(..)`)
                     }
-                    // a static method, `Picture.draw(node)`
+                    // a static method, `SceneNode.drawKids(io, kids, ..)`
                     let key = format!("{}.{}", t, c.name);
                     return match self.fns.get(&key) {
                         Some(f) if !f.has_self && rest.len() == f.params.len() => {
@@ -1158,7 +1158,7 @@ impl Driver {
         self.fresh += 1;
         let (names, body) = self.renamed(&c.f, &format!("$k{}", self.fresh))?;
         let Some(Stmt::Match(m)) = body.stmts.first().cloned() else { return None };
-        // An arm may read the matched value again once (`_ => picComposite(effect, ..)`):
+        // An arm may read the matched value again once (`_ => .. effect.tint(alpha)`):
         // the value is then built in that arm instead, so it is still built at most once.
         let again = m.cases.iter().any(|cs| {
             let n = &names[k];
@@ -1718,7 +1718,7 @@ impl Driver {
                 }
             } else {
                 // A just-built value read only as the matched argument of non-mutating
-                // consumers (`picBounds(panel, m)` then `picDraw(panel, ..)`): each consumer
+                // consumers (`panel.boundsWith(m)` then `panel.drawWith(io, ..)`): each consumer
                 // picks its arm on its own copy of the (pure) construction, so none is built.
                 let uses = cntStmts(&rest, &p, true);
                 let last = rest.iter().rposition(|s| cntStmts(std::slice::from_ref(s), &p, true) > 0).unwrap_or(0);
@@ -1852,7 +1852,7 @@ impl Driver {
                 if let AttrKind::Method(c) = &a.attr {
                     let ro = |k: &String| self.pure.contains(k) || self.readOnly.contains(k);
                     let known = match &a.object {
-                        Expr::TypeName(t) if !t.contains('.') => ro(&format!("{}.{}", t, c.name)),
+                        Expr::TypeName(t) if !t.contains('.') => ro(&self.typeNameMethodKey(t, &c.name)),
                         o => {
                             let ks = self.methodKeys(o, &c.name);
                             !ks.is_empty() && ks.iter().all(ro)
@@ -1869,6 +1869,21 @@ impl Driver {
         ok
     }
+    /// The fn key of `T.method(..)`: a static method of type `T`, or, when `T` is a nullary
+    /// variant value (`Identity.matrix()` once a just-built `Identity` is substituted), its
+    /// enum's method with a receiver (`Transform.matrix`). Compiler-made copies (`fold$c0`)
+    /// are left out: moving a value past one on `Nil` miscompiles (open, see docs/backlog.md).
+    fn typeNameMethodKey(&self, t: &str, method: &str) -> String {
+        let own = format!("{t}.{method}");
+        if self.fns.contains_key(&own) {
+            return own;
+        }
+        match self.ctorOwner.get(t) {
+            Some(o) if o != t && !method.contains('$') && self.fns.get(&format!("{o}.{method}")).is_some_and(|f| f.has_self) => format!("{o}.{method}"),
+            _ => own,
+        }
+    }
     fn quietStmt(&self, s: &Stmt) -> bool {
         match s {
             Stmt::Assign(a) if a.targets.iter().any(|t| matches!(t, AssignTarget::Field(..))) => false,

plum-core/tests/drive_test.rs CHANGED Viewed

@@ -424,7 +424,7 @@ fun total(xs: Lst) -> Int = sumL(mapB(xs))
     assert!(notes.iter().any(|n| n.contains("not expression-bodied mapB")), "{notes:?}");
 }
-// F-T23-1: the component game's draw path (`Picture.draw(io, s.render())`) after the `io`
+// F-T23-1: the component game's draw path (`s.render().draw(io)`) after the `io`
 // migration and the component rewrite. Shapes: a consumer with an extra `Io` argument whose
 // method shares its name with a mutating method of another type, and children built by
 // a generic `map`-like producer whose elements call same-named methods of several types.

plum-examples/games/functional/game_state_view.plum CHANGED Viewed

@@ -10,10 +10,10 @@
 # `State` is the same for the whole game: the components, the score, a `Random` and the
 # screen size. `Msg` is what can happen to it (a tick of time, a resize, a restart, a
 # Ui event); `State.update(msg)` is a short sequence of named steps and
-# `State.render()` builds a fresh picture every frame, which `Picture.draw` interprets
+# `State.render()` builds a fresh picture every frame, which `SceneNode.draw` interprets
 # (the compiler fuses the two, so the tree is never built). There is no retained
 # scene: the restart button is a `Ui.button` in the picture; the host turns the mouse
-# into a `UiInput`, finds what is under it with `Picture.hitId` on the picture the
+# into a `UiInput`, finds what is under it with `SceneNode.hitId` on the picture the
 # player is looking at, runs `Ui.step`, and feeds each `UiEvent` to `State.update`.
 # The game-over title and the ship's hurt flash are `Anim`s of time since they began.
 # The `World` record is the host shell: it holds the current `State`, reads the keyboard
@@ -29,7 +29,7 @@ import std/Random
 import std/game/Vec2
 import std/game/Color
 import std/game/Game
-import std/game/functional/Picture
+import std/game/functional/FunctionalScene
 import std/game/functional/Anim
 import std/game/functional/Ui
 import std/Io
@@ -400,7 +400,7 @@ record State(
   # One pointer input: finds what is under it in the current picture, runs the Ui, and
   # feeds each raised event to `update`.
   fun feed(self, input: UiInput) -> State =
-    r := Ui.step(self.ui, input, Picture.hitId(self.render(), input.x, input.y))
+    r := Ui.step(self.ui, input, self.render().hitId(input.x, input.y))
     r.events.fold(State(..self, ui: r.ui), |s, e| s.update(UiEv(event: e)))
   # --- render ---
@@ -442,6 +442,7 @@ record State(
     else
       Cons(head: cell(self.sheet, Rules.ArenaW - 40.0 - Float(i) * 36.0, 12.0, 32.0, 0, 0), tail: self.lifeIcons(i + 1))
+  # `Cons` (not `List(..).append(..)`) so the life icons fuse into the draw walk too.
   fun renderHud(self) -> SceneNode =
     Group(
       transform: Identity,
@@ -478,7 +479,7 @@ record State(
   # True when (x, y) in screen pixels is on the restart button of the picture `render` builds.
   fun onRestart(self, x: Float, y: Float) -> Bool =
-    {Picture.hitId(self.render(), x, y) ?: -1} == Id.Restart
+    {self.render().hitId(x, y) ?: -1} == Id.Restart
 fun pointerKind(down: Bool, wasDown: Bool) -> UiInputKind =
   if down && !wasDown
@@ -553,7 +554,7 @@ export fun update(io: Io, w: World, dt: Float) =
 export fun draw(io: Io, w: World) =
   s := w.state
   io.clear(Color.rgb(0.04, 0.05, 0.1))
-  Picture.draw(io, s.render())
+  s.render().draw(io)
 # --- tests ---
@@ -790,8 +791,8 @@ test "view_is_pure"
   a := countNodes(s.render())
   b := countNodes(s.render())
   assert a == b
-  ba := Picture.bounds(s.render())
+  ba := s.render().bounds()
-  bb := Picture.bounds(s.render())
+  bb := s.render().bounds()
   assert ba.x == bb.x
   assert ba.w == bb.w
   assert s.clock == 0.0

plum-examples/games/pure/game_pure_scene.plum CHANGED Viewed

@@ -9,7 +9,7 @@
 # (std `Group`, `Sprite`, `Label`, `Button` kinds, and `Custom` nodes whose behaviour is a
 # record embedding `Actor`: `Ship`, `Orb`, `Mine`, `Star`, `Panel`):
 # `act` returns the next node, `Stage.frame` returns a new `Stage`, and a change from the
-# rules ("this orb is collected", "show the game-over panel") is a `SceneTree.modify`
+# rules ("this orb is collected", "show the game-over panel") is a `Node.modify`
 # on an actor id that returns a new tree. The `World` record below is the mutable shell the
 # host talks to: it keeps the current `Stage` and the run's state (score, lives, the ship's
 # velocity) and replaces its `stage` every frame. Nothing that a function was given
@@ -27,7 +27,6 @@ import std/game/Affine
 import std/game/Game
 import std/game/pure/Actions
 import std/game/pure/PureScene
-import std/game/pure/SceneTree
 import std/game/pure/SceneInput
 import std/Io
@@ -47,7 +46,7 @@ primitive Rules =
   Size = 48.0
   Half = 24.0
-# Actor ids: unique in the tree, so the rules can find an actor with `SceneTree.modify`.
+# Actor ids: unique in the tree, so the rules can find an actor with `Node.modify`.
 primitive Id =
   Root = 1
   Backdrop = 2
@@ -164,7 +163,7 @@ fun cy(n: Node) -> Float =
 record Panel(Actor) =
   fun create(id: Int, x: Float, y: Float, w: Float, h: Float, c: Color) -> Node =
-    n := PureScene.custom(id, x, y, w, h, Panel())
+    n := Node.custom(id, x, y, w, h, Panel())
     Node(..n, color: c)
   override fun draw(self, io: Io, n: Node, m: Affine, tint: Color) =
@@ -175,7 +174,7 @@ record Panel(Actor) =
 record Ship(Actor, mut clock: Float, tex: Int) =
   fun create(sheet: Int, s: ShipState) -> Node =
-    n := PureScene.custom(Id.Ship, s.x - Rules.Half, s.y - Rules.Half, Rules.Size, Rules.Size, Ship(clock: 0.0, tex: sheet))
+    n := Node.custom(Id.Ship, s.x - Rules.Half, s.y - Rules.Half, Rules.Size, Rules.Size, Ship(clock: 0.0, tex: sheet))
     Node(..n, originX: Rules.Half, originY: Rules.Half)
   override fun act(self, n: Node, dt: Float) -> Node =
@@ -186,7 +185,7 @@ record Ship(Actor, mut clock: Float, tex: Int) =
     c := m.apply(Vec2(x: n.width / 2.0, y: n.height / 2.0))
     io.drawCircle(c.x, c.y, 17.0 * m.scaleX(), Color(r: 0.4, g: 0.8, b: 1.0, a: 0.12 * tint.a))
     frame := Float(frameOf(self.clock, 4, 14.0))
-    pureDrawSprite(io, m, tint, n.width, n.height, self.tex, frame * Rules.Cell, 0.0, Rules.Cell, Rules.Cell)
+    Node.drawSprite(io, m, tint, n.width, n.height, self.tex, frame * Rules.Cell, 0.0, Rules.Cell, Rules.Cell)
 # A glowing orb drifting about. `phase` offsets its animation from the other orbs.
 record Orb(Actor, mut vx: Float, mut vy: Float, phase: Float, mut clock: Float, tex: Int) =
@@ -196,7 +195,7 @@ record Orb(Actor, mut vx: Float, mut vy: Float, phase: Float, mut clock: Float,
   # An orb that carries on an animation `clock`, so a respawn or freeze never jumps a frame.
   fun createAt(sheet: Int, phase: Float, id: Int, at: Motion, clock: Float) -> Node =
-    n := PureScene.custom(id, at.x - Rules.Half, at.y - Rules.Half, Rules.Size, Rules.Size,
+    n := Node.custom(id, at.x - Rules.Half, at.y - Rules.Half, Rules.Size, Rules.Size,
       Orb(vx: at.vx, vy: at.vy, phase: phase, clock: clock, tex: sheet))
     Node(..n, originX: Rules.Half, originY: Rules.Half)
@@ -215,7 +214,7 @@ record Orb(Actor, mut vx: Float, mut vy: Float, phase: Float, mut clock: Float,
     io.drawCircle(c.x, c.y, 17.0 * k, Color(r: 0.6, g: 0.4, b: 0.05, a: 0.5 * tint.a))
     io.blendMode(Blend.Normal)
     frame := Float(frameOf(self.clock + self.phase, 4, 8.0))
-    pureDrawSprite(io, m, tint, n.width, n.height, self.tex, frame * Rules.Cell, Rules.Cell, Rules.Cell, Rules.Cell)
+    Node.drawSprite(io, m, tint, n.width, n.height, self.tex, frame * Rules.Cell, Rules.Cell, Rules.Cell, Rules.Cell)
 # A mine drifting about, turning `spin` radians per second (0 once the game is over).
 record Mine(Actor, mut vx: Float, mut vy: Float, spin: Float, mut clock: Float, tex: Int) =
@@ -224,7 +223,7 @@ record Mine(Actor, mut vx: Float, mut vy: Float, spin: Float, mut clock: Float,
     Mine.createAt(sheet, id, at, spin, 0.0)
   fun createAt(sheet: Int, id: Int, at: Motion, spin: Float, clock: Float) -> Node =
-    n := PureScene.custom(id, at.x - Rules.Half, at.y - Rules.Half, Rules.Size, Rules.Size,
+    n := Node.custom(id, at.x - Rules.Half, at.y - Rules.Half, Rules.Size, Rules.Size,
       Mine(vx: at.vx, vy: at.vy, spin: spin, clock: clock, tex: sheet))
     Node(..n, originX: Rules.Half, originY: Rules.Half)
@@ -237,14 +236,14 @@ record Mine(Actor, mut vx: Float, mut vy: Float, spin: Float, mut clock: Float,
   override fun draw(self, io: Io, n: Node, m: Affine, tint: Color) =
     frame := Float(frameOf(self.clock, 4, 4.0))
-    pureDrawSprite(io, m, tint, n.width, n.height, self.tex, frame * Rules.Cell, 2.0 * Rules.Cell, Rules.Cell, Rules.Cell)
+    Node.drawSprite(io, m, tint, n.width, n.height, self.tex, frame * Rules.Cell, 2.0 * Rules.Cell, Rules.Cell, Rules.Cell)
 # A background star that twinkles.
 record Star(Actor, seed: Float, mut clock: Float) =
   fun create(i: Int) -> Node =
     r := 1.0 + Float(i % 3) * 0.5
-    PureScene.custom(Id.Star + i, Float({i * 7919} % 800) - r, Float({i * 104729} % 600) - r, r * 2.0, r * 2.0,
+    Node.custom(Id.Star + i, Float({i * 7919} % 800) - r, Float({i * 104729} % 600) - r, r * 2.0, r * 2.0,
       Star(seed: Float(i), clock: 0.0))
   override fun act(self, n: Node, dt: Float) -> Node =
@@ -269,11 +268,11 @@ fun nodeAt(a: Node, path: Slice[Int], depth: Int) -> Node =
 # The node with `id` below `root`, searched depth first, borrowed from the tree.
 fun find(root: Node, id: Int) -> Node =
-  path := SceneTree.findPath(root, id) ?: crash "no such actor"
+  path := root.findPath(id) ?: crash "no such actor"
   nodeAt(root, path, 0)
 fun kidsOf(n: Node) -> Slice[Node] =
-  PureScene.childrenOf(n) ?: crash "not a group"
+  n.children() ?: crash "not a group"
 fun setVisible(n: Node, v: Bool) -> Node =
   Node(..n, visible: v)
@@ -302,11 +301,11 @@ fun textOf(n: Node) -> Str =
     _ => ""
 fun hudLabel(id: Int, text: Str, x: Float, y: Float, size: Float, c: Color) -> Node =
-  l := PureScene.label(id, text, x, y, size)
+  l := Node.label(id, text, x, y, size)
   Node(..l, color: c)
 fun icon(sheet: Int, i: Int) -> Node =
-  s := PureScene.sprite(Id.Icon + i, sheet, Rules.ArenaW - 40.0 - Float(i) * 36.0, 12.0, 32.0, 32.0)
+  s := Node.sprite(Id.Icon + i, sheet, Rules.ArenaW - 40.0 - Float(i) * 36.0, 12.0, 32.0, 32.0)
   Node(..s, kind: Sprite(tex: sheet, srcX: 0.0, srcY: 0.0, srcW: Rules.Cell, srcH: Rules.Cell))
 # The whole scene: backdrop, stars, mines, orbs, ship and HUD layers, in drawing order.
@@ -340,14 +339,14 @@ fun buildRoot(spots: Spots, sheet: Int, best: Int) -> Node =
     orbs.push(Orb.create(sheet, Float(i) * 0.1, Id.Orb + i, spots.orbs.at(i)))
   for i := range mineCount(0)
     mines.push(Mine.create(sheet, Id.Mine + i, spots.mines.at(i), 2.0))
-  b0 := PureScene.button(Id.Restart, "Again", sheet, sheet, 340.0, 342.0, 120.0, 44.0)
+  b0 := Node.button(Id.Restart, "Again", sheet, sheet, 340.0, 342.0, 120.0, 44.0)
   btn := Node(..b0, color: Color(r: 0.5, g: 0.8, b: 1.0, a: 0.9), visible: false)
   over := Slice(
     Panel.create(Id.OverlayPanel, 0.0, 230.0, Rules.ArenaW, 170.0, Color(r: 0.0, g: 0.0, b: 0.0, a: 0.6)),
     hudLabel(Id.OverTitle, "Game over", 300.0, 244.0, 48.0, Color.Red),
     hudLabel(Id.OverHint, "Press Enter to play again", 270.0, 300.0, 24.0, Color.White),
     btn)
-  o0 := PureScene.group(Id.Overlay, 0.0, 0.0, 0.0, 0.0, over)
+  o0 := Node.group(Id.Overlay, 0.0, 0.0, 0.0, 0.0, over)
   overlay := Node(..o0, visible: false)
   hud := Slice(
     hudLabel(Id.Score, "Score 0", 16.0, 12.0, 28.0, Color.White),
@@ -357,12 +356,12 @@ fun buildRoot(spots: Spots, sheet: Int, best: Int) -> Node =
   hud.push(overlay)
   layers := Slice(
     Panel.create(Id.Backdrop, 0.0, 0.0, Rules.ArenaW, Rules.ArenaH, Color.rgb(0.07, 0.08, 0.16)),
-    PureScene.group(Id.StarLayer, 0.0, 0.0, 0.0, 0.0, stars),
+    Node.group(Id.StarLayer, 0.0, 0.0, 0.0, 0.0, stars),
-    PureScene.group(Id.MineLayer, 0.0, 0.0, 0.0, 0.0, mines),
+    Node.group(Id.MineLayer, 0.0, 0.0, 0.0, 0.0, mines),
-    PureScene.group(Id.OrbLayer, 0.0, 0.0, 0.0, 0.0, orbs),
+    Node.group(Id.OrbLayer, 0.0, 0.0, 0.0, 0.0, orbs),
     Ship.create(sheet, ship),
-    PureScene.group(Id.Hud, 0.0, 0.0, 0.0, 0.0, hud))
+    Node.group(Id.Hud, 0.0, 0.0, 0.0, 0.0, hud))
-  PureScene.group(Id.Root, 0.0, 0.0, Rules.ArenaW, Rules.ArenaH, layers)
+  Node.group(Id.Root, 0.0, 0.0, Rules.ArenaW, Rules.ArenaH, layers)
 # --- the world ---
@@ -390,13 +389,13 @@ fun newWorld(seed: Int, sheet: Int) -> World =
   spots := startSpots(Random.seeded(seed), ship)
   next := spots.rng
   World(
-    stage: SceneInput.stage(buildRoot(spots, sheet, 0)), ship: ship, rng: next, mines: mineCount(0), score: 0, best: 0,
+    stage: Stage.create(buildRoot(spots, sheet, 0)), ship: ship, rng: next, mines: mineCount(0), score: 0, best: 0,
     lives: Rules.StartLives, over: false, clock: 0.0, wasDown: false, sheet: sheet,
     pickupSound: -1, hitSound: -1, overSound: -1, musicSound: -1)
 fun modifyRoot(st: Stage, id: Int, f: fn(Node) -> Node) -> Stage =
   match st
-    Stage(root, camera, captured) => Stage(root: SceneTree.modify(root, id, f), camera: camera, captured: captured)
+    Stage(root, camera, captured) => Stage(root: root.modify(id, f), camera: camera, captured: captured)
 fun withCamera(st: Stage, camera: Affine) -> Stage =
   match st
@@ -574,7 +573,7 @@ export fun update(io: Io, w: World, dt: Float) =
   if w.over && {io.isKeyPressed(Key.Enter) || io.isKeyPressed(Key.KeyR)}
     restart(w)
     startMusic(io, w)
-  inputs := SceneInput.pollPointer(io, w.wasDown)
+  inputs := Input.poll(io, w.wasDown)
   w.wasDown = io.isMouseDown(0)
   left := io.isKeyDown(Key.Left) || io.isKeyDown(Key.KeyA)
   right := io.isKeyDown(Key.Right) || io.isKeyDown(Key.KeyD)
@@ -664,12 +663,12 @@ test "drifters bounce off the walls"
   assert b.vx == -100.0
   assert b.x == Rules.ArenaW - 10.0
   orb := Orb.create(-1, 0.0, Id.Orb, Motion(x: 795.0, y: 300.0, vx: 100.0, vy: 0.0))
-  moved := SceneTree.update(orb, 0.1)
+  moved := orb.update(0.1)
   assert near(cx(moved), Rules.ArenaW - 10.0)
 test "a mine spins as it drifts"
   mine := Mine.create(-1, Id.Mine, Motion(x: 400.0, y: 300.0, vx: 10.0, vy: 0.0), 2.0)
-  next := SceneTree.update(mine, 0.5)
+  next := mine.update(0.5)
   assert near(next.rotation, 1.0)
   assert near(cx(next), 405.0)

plum-game/web-test/fixtures/stress_pure_scene.plum CHANGED Viewed

@@ -1,7 +1,7 @@
 # The stress scene of stress_scene.plum on the PURE scene graph (std/game/pure/PureScene):
 # 5000 sprites in 50 slowly rotating groups, 500 rects and 200 circles (sprites of a
 # 1x1 white texture), 50 texts with a changing number, drawn through a camera. Every
-# node is a unique value: each frame changes the tree in place with SceneTree.update. Group and
+# node is a unique value: each frame changes the tree in place with Node.update. Group and
 # sprite spin comes from `forever(rotateBy(...))` actions; drifting and counting
 # actors do theirs in `act`.
 module stress_pure_scene
@@ -15,7 +15,6 @@ import std/game/Affine
 import std/game/Game
 import std/game/pure/Actions
 import std/game/pure/PureScene
-import std/game/pure/SceneTree
 import std/game/pure/SceneInput
 import std/Io
@@ -69,21 +68,21 @@ record CountLabel(Actor, n: Int, text: Str) =
 fun drifter(id: Int, tex: Int, c: Color, x: Float, y: Float, w: Float, h: Float, dx: Float, dy: Float) -> Node =
   d := Drifter(tex: tex, dx: dx, dy: dy)
   me: Actor := d
-  n := PureScene.custom(id, x, y, w, h, me)
+  n := Node.custom(id, x, y, w, h, me)
   Node(..n, color: c)
 fun countLabel(id: Int, n: Int, x: Float, y: Float) -> Node =
   l := CountLabel(n: n, text: "n {n}")
   me: Actor := l
-  PureScene.custom(id, x, y, 60.0, 14.0, me)
+  Node.custom(id, x, y, 60.0, 14.0, me)
 fun spinning(rate: Float) -> Slice[Action] =
   acts := Slice[Action]()
-  acts.push(Actions.forever(Actions.rotateBy(rate, 1.0)))
+  acts.push(Action.forever(Action.rotateBy(rate, 1.0)))
   acts
 fun dancer(id: Int, sheet: Int, j: Int, i: Int) -> Node =
-  s := PureScene.sprite(id, sheet, Float({j * j * 13 + j * 37} % 150), Float({j * j * 29 + j * 53} % 170), 16.0, 16.0)
+  s := Node.sprite(id, sheet, Float({j * j * 13 + j * 37} % 150), Float({j * j * 29 + j * 53} % 170), 16.0, 16.0)
   Node(..s, originX: 8.0, originY: 8.0, rotation: Float(i),
     kind: Sprite(tex: sheet, srcX: Float(i % 4 * 16), srcY: 0.0, srcW: 16.0, srcH: 16.0), actions: spinning(1.2))
@@ -95,7 +94,7 @@ fun buildWorld(sheet: Int, white: Int) -> World =
     for j := range per
       i := gi * per + j
       kids.push(dancer(1000 + i, sheet, j, i))
-    g := PureScene.group(100 + gi, Float(gi % 10 * 160), Float(gi / 10 * 180), 150.0, 170.0, kids)
+    g := Node.group(100 + gi, Float(gi % 10 * 160), Float(gi / 10 * 180), 150.0, 170.0, kids)
     root.push(Node(..g, originX: 75.0, originY: 85.0, actions: spinning(0.24)))
   for i := range Counts.Rects
     root.push(drifter(10000 + i, white, hue(i), Float(i * 61 % Counts.WorldW), Float(i * 29 % Counts.WorldH), 12.0, 8.0, 2.0, 0.0))
@@ -103,7 +102,7 @@ fun buildWorld(sheet: Int, white: Int) -> World =
     root.push(drifter(20000 + i, white, hue(i + 3), Float(i * 83 % Counts.WorldW), Float(i * 47 % Counts.WorldH), 12.0, 12.0, 3.0, 1.0))
   for i := range Counts.Texts
     root.push(countLabel(30000 + i, i, Float(i * 30 % Counts.WorldW), Float(i * 17 % Counts.WorldH)))
-  top := PureScene.group(1, 0.0, 0.0, Float(Counts.WorldW), Float(Counts.WorldH), root)
+  top := Node.group(1, 0.0, 0.0, Float(Counts.WorldW), Float(Counts.WorldH), root)
   cam := Affine(a: 0.8, b: 0.0, c: 0.0, d: 0.8, e: 0.0, f: 0.0)
   World(sheet: sheet, stage: Stage(root: top, camera: cam, captured: null))
@@ -131,7 +130,7 @@ test "ten frames of update run"
   w := buildWorld(0, 0)
   for i := range 10
     update(w, 0.016)
-  if k := PureScene.childrenOf(w.stage.root)
+  if k := w.stage.root.children()
     assert k.length() == 50 + 500 + 200 + 50
     assert {k.at(50).x - 20.0}.abs() < 0.000001
   else

plum-game/web-test/fixtures/stress_state_view.plum CHANGED Viewed

@@ -4,14 +4,14 @@
 # `State` is cons `List` lists (each spinner owns the `List` of its 100 dancers);
 # `step` is pure, a structural recursion that returns the next state; `view` is pure
 # and rebuilds the whole SceneNode tree every frame with recursive functions, which
-# `Picture.draw` interprets. Nothing is retained between frames but `State`. The
+# `SceneNode.draw` interprets. Nothing is retained between frames but `State`. The
 # deepest recursion is the 700 drifters; no loops run in step or view.
 #
 # Entity counts: 5000 sprites (50 groups x 100), 500 rects, 200 circles, 50 texts,
 # plus 200 animated sprites (Pulsers, pose = Anim.at(anim, clock - start)) and
 # 20 Ui.button buttons (tagged ids 40000..40019, screen space, outside the camera).
 # `State.ui` is a Ui.UiState fed by mouse input: update turns the mouse into a
-# UiInput, hit-tests the button layer with Picture.hitId, and calls Ui.step.
+# UiInput, hit-tests the button layer with SceneNode.hitId, and calls Ui.step.
 module stress_state_view
 import std/Str
 import std/Int
@@ -21,7 +21,7 @@ import std/List
 import std/game/Vec2
 import std/game/Color
 import std/game/Game
-import std/game/functional/Picture
+import std/game/functional/FunctionalScene
 import std/game/functional/Anim
 import std/game/functional/Ui
 import std/Io
@@ -143,7 +143,7 @@ fun countClicks(es: List[UiEvent]) -> Int = match es
 # Feeds one pointer input through Ui.step against the button layer.
 fun stepUi(s: State, input: UiInput) -> State =
-  hit := Picture.hitId(buttonsView(s.ui), input.x, input.y)
+  hit := buttonsView(s.ui).hitId(input.x, input.y)
   r := Ui.step(s.ui, input, hit)
   State(
     sheet: s.sheet, white: s.white, spinners: s.spinners, drifters: s.drifters, counters: s.counters,
@@ -217,7 +217,7 @@ export fun update(io: Io, w: World, dt: Float) =
 export fun draw(io: Io, w: World) =
   io.clear(Color.rgb(0.05, 0.06, 0.1))
-  Picture.draw(io, view(w.state))
+  view(w.state).draw(io)
 test "ten frames of step run"
   s := newState(0, 0)

plum-game/web-test/fixtures/stress_state_view_deep.plum CHANGED Viewed

@@ -6,7 +6,7 @@
 # `State` is cons `List` lists (each spinner owns the `List` of its 100 dancers);
 # `step` is pure, a structural recursion that returns the next state; `view` is pure
 # and rebuilds the whole SceneNode tree every frame with recursive functions, which
-# `Picture.draw` interprets. Nothing is retained between frames but `State`. The
+# `SceneNode.draw` interprets. Nothing is retained between frames but `State`. The
 # deepest recursion is the 700 drifters; no loops run in step or view.
 module stress_state_view
 import std/Str
@@ -17,7 +17,7 @@ import std/List
 import std/game/Vec2
 import std/game/Color
 import std/game/Game
-import std/game/functional/Picture
+import std/game/functional/FunctionalScene
 import std/Io
 primitive Counts =
@@ -179,7 +179,7 @@ export fun update(w: World, dt: Float) =
 export fun draw(io: Io, w: World) =
   io.clear(Color.rgb(0.05, 0.06, 0.1))
-  Picture.draw(io, view(w.state))
+  view(w.state).draw(io)
 test "ten frames of step run"
   s := newState(0, 0)

plum-std/game/Color.plum CHANGED Viewed

@@ -19,6 +19,10 @@ struct Color(r: Float, g: Float, b: Float, a: Float) =
   fun withAlpha(self, a: Float) -> Color =
     Color(r: self.r, g: self.g, b: self.b, a: a)
+  # Each channel multiplied by `o`'s (a tint applied to this colour).
+  fun times(self, o: Color) -> Color =
+    Color(r: self.r * o.r, g: self.g * o.g, b: self.b * o.b, a: self.a * o.a)
   fun eq(self, o: Color) -> Bool =
     self.r == o.r && self.g == o.g && self.b == o.b && self.a == o.a
@@ -26,6 +30,9 @@ test "Color.rgb is opaque and withAlpha replaces only alpha"
   assert Color.rgb(1.0, 0.5, 0.0) == Color(r: 1.0, g: 0.5, b: 0.0, a: 1.0)
   assert Color.Red.withAlpha(0.25) == Color(r: 1.0, g: 0.0, b: 0.0, a: 0.25)
+test "Color.times multiplies each channel"
+  assert Color(r: 0.5, g: 1.0, b: 0.0, a: 0.5).times(Color(r: 0.5, g: 0.5, b: 1.0, a: 1.0)) == Color(r: 0.25, g: 0.5, b: 0.0, a: 0.5)
 test "Color constants"
   assert Color.White.r == 1.0
   assert Color.Black.a == 1.0

plum-std/game/functional/FunctionalScene.plum ADDED Viewed

@@ -0,0 +1,357 @@
+module std
+import std/Int
+import std/Float
+import std/Str
+import std/Slice
+import std/List
+import std/Math
+import std/game/Vec2
+import std/game/Color
+import std/game/Affine
+import std/game/Game
+import std/Io
+# The functional scene: a `SceneNode` is plain data (shapes, sprites, text, groups
+# with a transform, filters), rebuilt every frame and never mutated. Its methods draw
+# it, measure it and hit-test it by structural recursion, passing the parent matrix
+# and alpha down as arguments. Children are a `List[SceneNode]`; the static
+# `SceneNode` helpers over such a list (`drawKids`, `boundsKids`, ..) do the same walk
+# for each child. `Compose(first, then)` applies `then` first, then `first` (`first`
+# is the outermost).
+enum Transform =
+  | Identity
+  | Translate(dx: Float, dy: Float)
+  | Rotate(radians: Float)
+  | Scale(sx: Float, sy: Float)
+  | Compose(first: Transform, then: Transform)
+  fun matrix(self) -> Affine = match self
+    Identity => Affine.Identity
+    Translate(dx, dy) => Affine(a: 1.0, b: 0.0, c: 0.0, d: 1.0, e: dx, f: dy)
+    Rotate(rad) => Affine(a: Math.cos(rad), b: Math.sin(rad), c: 0.0 - Math.sin(rad), d: Math.cos(rad), e: 0.0, f: 0.0)
+    Scale(sx, sy) => Affine(a: sx, b: 0.0, c: 0.0, d: sy, e: 0.0, f: 0.0)
+    Compose(first, then) => first.matrix().mul(then.matrix())
+# `mode` is a `Blend` constant from std/game/Game.
+enum Effect =
+  | Tint(color: Color)
+  | Alpha(alpha: Float)
+  | BlendFx(mode: Int)
+  # The color a filtered texture is composited with.
+  fun tint(self, alpha: Float) -> Color = match self
+    Tint(color) => color.withAlpha(color.a * alpha)
+    Alpha(a) => Color.White.withAlpha(a * alpha)
+    _ => Color.White.withAlpha(alpha)
+struct Rect(x: Float, y: Float, w: Float, h: Float) =
+  # The bounding box, in the outer space, of the box (x, y, w, h) seen through `m`.
+  fun through(x: Float, y: Float, w: Float, h: Float, m: Affine) -> Rect =
+    p1 := m.apply(Vec2(x: x, y: y))
+    p2 := m.apply(Vec2(x: x + w, y: y))
+    p3 := m.apply(Vec2(x: x, y: y + h))
+    p4 := m.apply(Vec2(x: x + w, y: y + h))
+    x0 := p1.x.min(p2.x).min(p3.x.min(p4.x))
+    x1 := p1.x.max(p2.x).max(p3.x.max(p4.x))
+    y0 := p1.y.min(p2.y).min(p3.y.min(p4.y))
+    y1 := p1.y.max(p2.y).max(p3.y.max(p4.y))
+    Rect(x: x0, y: y0, w: x1 - x0, h: y1 - y0)
+  # The bounding box of a line `thickness` wide seen through `m`.
+  fun throughLine(x1: Float, y1: Float, x2: Float, y2: Float, thickness: Float, m: Affine) -> Rect =
+    lx := x1.min(x2) - thickness / 2.0
+    ly := y1.min(y2) - thickness / 2.0
+    Rect.through(lx, ly, {x1 - x2}.abs() + thickness, {y1 - y2}.abs() + thickness, m)
+  # The smallest box holding `a` (when there is one) and `b`.
+  fun union(a: Rect?, b: Rect) -> Rect =
+    if ra := a
+      x0 := ra.x.min(b.x)
+      y0 := ra.y.min(b.y)
+      x1 := {ra.x + ra.w}.max(b.x + b.w)
+      y1 := {ra.y + ra.h}.max(b.y + b.h)
+      return Rect(x: x0, y: y0, w: x1 - x0, h: y1 - y0)
+    b
+  fun contains(self, px: Float, py: Float) -> Bool =
+    px >= self.x && px <= self.x + self.w && py >= self.y && py <= self.y + self.h
+# A Sprite is a texture region `w` by `h` with its top-left at (x, y).
+# A Filter draws its child into `target`, then composites it with the effect.
+# `target` is a texture the game creates ONCE at load with `textureCreate`; draw
+# creates nothing, so a view does not leak a texture per frame. The size of
+# `target` bounds what the filter can show: child pixels beyond it are cut off.
+# A negative target draws nothing.
+enum SceneNode =
+  | Group(transform: Transform, children: List[SceneNode])
+  | Filter(effect: Effect, child: SceneNode, target: Int)
+  | Sprite(tex: Int, x: Float, y: Float, w: Float, h: Float, srcX: Float, srcY: Float, srcW: Float, srcH: Float, tint: Color)
+  | Text(text: Str, x: Float, y: Float, size: Float, color: Color)
+  | RectShape(x: Float, y: Float, w: Float, h: Float, color: Color)
+  | CircleShape(cx: Float, cy: Float, r: Float, color: Color)
+  | LineShape(x1: Float, y1: Float, x2: Float, y2: Float, thickness: Float, color: Color)
+  | Tagged(id: Int, child: SceneNode)
+  # Draws the scene to the current target.
+  fun draw(self, io: Io) =
+    self.drawWith(io, Affine.Identity, 1.0, 0 - 1)
+  # The bounding box of the scene in its own space (all zero when empty).
+  fun bounds(self) -> Rect =
+    if r := self.boundsWith(Affine.Identity)
+      return r
+    Rect(x: 0.0, y: 0.0, w: 0.0, h: 0.0)
+  # Child indices from the root down to the topmost hit leaf; empty on a miss.
+  fun hitPath(self, x: Float, y: Float) -> Slice[Int] =
+    if p := self.hitWith(x, y)
+      return p
+    Slice[Int]()
+  # The id of the innermost Tagged node under (x, y), or null. Later siblings win.
+  fun hitId(self, x: Float, y: Float) -> Int? =
+    self.hitIdWith(null, x, y)
+  # --- drawing ---
+  # Draws under the parent matrix `m` and alpha into `target` (negative: the screen).
+  fun drawWith(self, io: Io, m: Affine, alpha: Float, target: Int) = match self
+    RectShape(x, y, w, h, color) =>
+      sx := w * m.scaleX()
+      sy := h * m.scaleY()
+      c := m.apply(Vec2(x: x + w / 2.0, y: y + h / 2.0))
+      io.drawRect(c.x - sx / 2.0, c.y - sy / 2.0, sx, sy, color.withAlpha(color.a * alpha))
+    CircleShape(cx, cy, r, ccolor) =>
+      cc := m.apply(Vec2(x: cx, y: cy))
+      io.drawCircle(cc.x, cc.y, r * m.scaleX(), ccolor.withAlpha(ccolor.a * alpha))
+    LineShape(x1, y1, x2, y2, th, lcolor) =>
+      p := m.apply(Vec2(x: x1, y: y1))
+      q := m.apply(Vec2(x: x2, y: y2))
+      io.drawLine(p.x, p.y, q.x, q.y, th * m.scaleX(), lcolor.withAlpha(lcolor.a * alpha))
+    Sprite(tex, sx0, sy0, sw0, sh0, srcX, srcY, srcW, srcH, tint) =>
+      sw := sw0 * m.scaleX()
+      sh := sh0 * m.scaleY()
+      sc := m.apply(Vec2(x: sx0 + sw0 / 2.0, y: sy0 + sh0 / 2.0))
+      io.drawTextureEx(tex, srcX, srcY, srcW, srcH, sc.x - sw / 2.0, sc.y - sh / 2.0, sw, sh, m.rotation(), false, tint.withAlpha(tint.a * alpha))
+    Text(txt, tx, ty, size, tcolor) =>
+      tp := m.apply(Vec2(x: tx, y: ty))
+      io.drawText(txt, tp.x, tp.y, size * m.scaleY(), tcolor.withAlpha(tcolor.a * alpha))
+    Group(tr, kids) => SceneNode.drawKids(io, kids, m.mul(tr.matrix()), alpha, target)
+    Filter(effect, child, tex) => SceneNode.drawFiltered(io, effect, child, tex, m, alpha, target)
+    Tagged(_, child) => child.drawWith(io, m, alpha, target)
+  fun drawKids(io: Io, kids: List[SceneNode], m: Affine, alpha: Float, target: Int) = match kids
+    Nil => 0
+    Cons(head, tail) =>
+      head.drawWith(io, m, alpha, target)
+      SceneNode.drawKids(io, tail, m, alpha, target)
+  fun drawFiltered(io: Io, effect: Effect, child: SceneNode, tex: Int, m: Affine, alpha: Float, target: Int) = match effect
+    BlendFx(mode) =>
+      io.blendMode(mode)
+      child.drawWith(io, m, alpha, target)
+      io.blendMode(Blend.Normal)
+    _ =>
+      if b := child.boundsWith(m)
+        if tex >= 0
+          w := {Int(b.w) + 1}.min(io.textureWidth(tex))
+          h := {Int(b.h) + 1}.min(io.textureHeight(tex))
+          io.renderTarget(tex)
+          io.clear(Color.Transparent)
+          shift := Affine(a: 1.0, b: 0.0, c: 0.0, d: 1.0, e: 0.0 - b.x, f: 0.0 - b.y)
+          child.drawWith(io, shift.mul(m), 1.0, tex)
+          io.renderTarget(target)
+          io.drawTextureEx(tex, 0.0, 0.0, Float(w), Float(h), b.x, b.y, Float(w), Float(h), 0.0, false, effect.tint(alpha))
+  # --- bounds ---
+  # The bounds of the node drawn under `m`, or null when it has no extent.
+  fun boundsWith(self, m: Affine) -> Rect? = match self
+    RectShape(x, y, w, h, _) => Rect.through(x, y, w, h, m)
+    CircleShape(cx, cy, r, _) => Rect.through(cx - r, cy - r, r * 2.0, r * 2.0, m)
+    LineShape(x1, y1, x2, y2, th, _) => Rect.throughLine(x1, y1, x2, y2, th, m)
+    Sprite(_, sx, sy, sw, sh, _, _, _, _, _) => Rect.through(sx, sy, sw, sh, m)
+    Text(txt, tx, ty, size, _) => Rect.through(tx, ty, size * 0.6 * Float(txt.length()), size, m)
+    Group(tr, kids) => SceneNode.boundsKids(kids, m.mul(tr.matrix()), null)
+    Filter(_, child, _) => child.boundsWith(m)
+    Tagged(_, child) => child.boundsWith(m)
+  fun boundsKids(kids: List[SceneNode], m: Affine, acc: Rect?) -> Rect? = match kids
+    Nil => acc
+    Cons(head, tail) =>
+      if cr := head.boundsWith(m)
+        SceneNode.boundsKids(tail, m, Rect.union(acc, cr))
+      else
+        SceneNode.boundsKids(tail, m, acc)
+  # --- hit testing ---
+  # The child indices from the node down to the hit leaf, or null on a miss. A leaf
+  # that is hit is an empty path. (px, py) is in the node's own space.
+  fun hitWith(self, px: Float, py: Float) -> Slice[Int]? = match self
+    RectShape(x, y, w, h, _) => SceneNode.leaf(Rect(x: x, y: y, w: w, h: h).contains(px, py))
+    CircleShape(cx, cy, r, _) => SceneNode.leaf(Math.hypot(px - cx, py - cy) <= r)
+    LineShape(x1, y1, x2, y2, th, _) => SceneNode.leaf(SceneNode.nearLine(x1, y1, x2, y2, th, px, py))
+    Sprite(_, sx, sy, sw, sh, _, _, _, _, _) => SceneNode.leaf(Rect(x: sx, y: sy, w: sw, h: sh).contains(px, py))
+    Text(txt, tx, ty, size, _) => SceneNode.leaf(Rect(x: tx, y: ty, w: size * 0.6 * Float(txt.length()), h: size).contains(px, py))
+    Group(tr, kids) =>
+      if gi := tr.matrix().invert()
+        lp := gi.apply(Vec2(x: px, y: py))
+        SceneNode.hitKids(kids, 0, lp.x, lp.y)
+      else
+        null
+    Filter(_, child, _) =>
+      if fp := child.hitWith(px, py)
+        SceneNode.prepend(0, fp)
+      else
+        null
+    Tagged(_, child) =>
+      if tp := child.hitWith(px, py)
+        SceneNode.prepend(0, tp)
+      else
+        null
+  # Tries the later children first (they are drawn on top); `i` is the index of
+  # `kids`' head. The first hit found from the back wins.
+  fun hitKids(kids: List[SceneNode], i: Int, px: Float, py: Float) -> Slice[Int]? = match kids
+    Nil => null
+    Cons(head, tail) =>
+      if later := SceneNode.hitKids(tail, i + 1, px, py)
+        later
+      else
+        if sub := head.hitWith(px, py)
+          SceneNode.prepend(i, sub)
+        else
+          null
+  # The id of the innermost Tagged node whose subtree is hit at (px, py), or null.
+  # `outer` is the id of the nearest enclosing tag (null at the root).
+  fun hitIdWith(self, outer: Int?, px: Float, py: Float) -> Int? = match self
+    Group(tr, kids) =>
+      if gi := tr.matrix().invert()
+        lp := gi.apply(Vec2(x: px, y: py))
+        SceneNode.hitIdKids(kids, outer, lp.x, lp.y)
+      else
+        null
+    Filter(_, child, _) => child.hitIdWith(outer, px, py)
+    Tagged(id, child) => child.hitIdWith(id, px, py)
+    _ =>
+      if self.hitWith(px, py) != null
+        outer
+      else
+        null
+  # Later siblings are drawn on top, so they are tried first.
+  fun hitIdKids(kids: List[SceneNode], outer: Int?, px: Float, py: Float) -> Int? = match kids
+    Nil => null
+    Cons(head, tail) =>
+      if later := SceneNode.hitIdKids(tail, outer, px, py)
+        later
+      else
+        head.hitIdWith(outer, px, py)
+  fun leaf(hit: Bool) -> Slice[Int]? =
+    if hit
+      return Slice[Int]()
+    null
+  # `i` followed by the path `sub`.
+  fun prepend(i: Int, sub: Slice[Int]) -> Slice[Int] =
+    path := Slice(i)
+    for j := range sub.length()
+      path.push(sub.at(j))
+    path
+  fun nearLine(x1: Float, y1: Float, x2: Float, y2: Float, thickness: Float, px: Float, py: Float) -> Bool =
+    dx := x2 - x1
+    dy := y2 - y1
+    len2 := dx * dx + dy * dy
+    t := if len2 == 0.0 then 0.0 else {{px - x1} * dx + {py - y1} * dy} / len2
+    tc := t.max(0.0).min(1.0)
+    qx := x1 + dx * tc
+    qy := y1 + dy * tc
+    Math.hypot(px - qx, py - qy) <= thickness.max(1.0) / 2.0
+fun picNear(a: Float, b: Float) -> Bool =
+  {a - b}.abs() < 1e-6
+fun picRect(x: Float, y: Float, w: Float, h: Float, c: Color) -> SceneNode =
+  RectShape(x: x, y: y, w: w, h: h, color: c)
+test "bounds_translate_scale"
+  g := Group(transform: Compose(first: Translate(dx: 5.0, dy: 5.0), then: Scale(sx: 2.0, sy: 2.0)), children: Cons(head: picRect(0.0, 0.0, 10.0, 10.0, Color.Red), tail: Nil))
+  r := g.bounds()
+  assert picNear(r.x, 5.0)
+  assert picNear(r.y, 5.0)
+  assert picNear(r.w, 20.0)
+  assert picNear(r.h, 20.0)
+test "bounds_rotate_quarter"
+  g := Group(transform: Rotate(radians: 1.5707963267948966), children: Cons(head: picRect(0.0, 0.0, 10.0, 4.0, Color.Red), tail: Nil))
+  r := g.bounds()
+  assert picNear(r.x, 0.0 - 4.0)
+  assert picNear(r.y, 0.0)
+  assert picNear(r.w, 4.0)
+  assert picNear(r.h, 10.0)
+test "hit_path_nested"
+  inner := Group(transform: Translate(dx: 10.0, dy: 0.0), children: Cons(head: picRect(0.0, 0.0, 10.0, 10.0, Color.Blue), tail: Nil))
+  g := Group(transform: Identity, children: Cons(head: picRect(0.0, 0.0, 10.0, 10.0, Color.Red), tail: Cons(head: inner, tail: Nil)))
+  p := g.hitPath(15.0, 5.0)
+  assert p.length() == 2
+  assert p.at(0) == 1
+  assert p.at(1) == 0
+  q := g.hitPath(5.0, 5.0)
+  assert q.length() == 1
+  assert q.at(0) == 0
+test "hit_path_last_child_wins"
+  g := Group(transform: Identity, children: Cons(head: picRect(0.0, 0.0, 10.0, 10.0, Color.Red), tail: Cons(head: picRect(0.0, 0.0, 10.0, 10.0, Color.Blue), tail: Nil)))
+  p := g.hitPath(5.0, 5.0)
+  assert p.length() == 1
+  assert p.at(0) == 1
+test "hit_miss_empty"
+  g := Group(transform: Identity, children: Cons(head: picRect(0.0, 0.0, 10.0, 10.0, Color.Red), tail: Nil))
+  assert g.hitPath(50.0, 50.0).length() == 0
+test "filter_bounds_is_child_bounds"
+  g := Filter(effect: Alpha(alpha: 0.5), child: picRect(1.0, 2.0, 10.0, 4.0, Color.Red), target: 0 - 1)
+  r := g.bounds()
+  assert picNear(r.x, 1.0)
+  assert picNear(r.y, 2.0)
+  assert picNear(r.w, 10.0)
+  assert picNear(r.h, 4.0)
+test "tagged_bounds_and_path"
+  g := Group(transform: Identity, children: Cons(head: Tagged(id: 7, child: picRect(1.0, 2.0, 10.0, 4.0, Color.Red)), tail: Nil))
+  r := g.bounds()
+  assert picNear(r.x, 1.0)
+  assert picNear(r.w, 10.0)
+  p := g.hitPath(5.0, 3.0)
+  assert p.length() == 2
+  assert p.at(0) == 0
+  assert p.at(1) == 0
+test "hit_id_innermost_and_topmost"
+  inner := Tagged(id: 2, child: picRect(0.0, 0.0, 10.0, 10.0, Color.Blue))
+  outer := Tagged(id: 1, child: Group(transform: Identity, children: Cons(head: picRect(0.0, 0.0, 20.0, 20.0, Color.Red), tail: Cons(head: inner, tail: Nil))))
+  top := Tagged(id: 3, child: picRect(15.0, 15.0, 10.0, 10.0, Color.Red))
+  g := Group(transform: Translate(dx: 1.0, dy: 0.0), children: Cons(head: outer, tail: Cons(head: top, tail: Nil)))
+  a := g.hitId(6.0, 5.0)
+  if va := a
+    assert va == 2
+  else
+    assert false
+  b := g.hitId(19.0, 5.0)
+  if vb := b
+    assert vb == 1
+  else
+    assert false
+  c := g.hitId(17.0, 17.0)
+  if vc := c
+    assert vc == 3
+  else
+    assert false
+  assert g.hitId(100.0, 100.0) == null

plum-std/game/functional/Picture.plum DELETED Viewed

@@ -1,352 +0,0 @@
-module std
-import std/Int
-import std/Float
-import std/Str
-import std/Slice
-import std/List
-import std/Math
-import std/game/Vec2
-import std/game/Color
-import std/game/Affine
-import std/game/Game
-import std/Io
-# A recursive picture: a SceneNode is plain data (shapes, sprites, text, groups
-# with a transform, filters) and `Picture` is a set of structurally recursive
-# functions that draw it, measure it and hit-test it. Children are a recursive
-# `List[SceneNode]` list, so every operation recurses over SceneNode and List[SceneNode], passing
-# the parent matrix and alpha down as arguments. Nothing here mutates the picture.
-# `Compose(first, then)` applies `then` first, then `first` (`first` is the outermost).
-enum Transform =
-  | Identity
-  | Translate(dx: Float, dy: Float)
-  | Rotate(radians: Float)
-  | Scale(sx: Float, sy: Float)
-  | Compose(first: Transform, then: Transform)
-# `mode` is a `Blend` constant from std/game/Game.
-enum Effect =
-  | Tint(color: Color)
-  | Alpha(alpha: Float)
-  | BlendFx(mode: Int)
-# A Sprite is a texture region `w` by `h` with its top-left at (x, y).
-# A Filter draws its child into `target`, then composites it with the effect.
-# `target` is a texture the game creates ONCE at load with `textureCreate`; draw
-# creates nothing, so a view does not leak a texture per frame. The size of
-# `target` bounds what the filter can show: child pixels beyond it are cut off.
-# A negative target draws nothing.
-enum SceneNode =
-  | Group(transform: Transform, children: List[SceneNode])
-  | Filter(effect: Effect, child: SceneNode, target: Int)
-  | Sprite(tex: Int, x: Float, y: Float, w: Float, h: Float, srcX: Float, srcY: Float, srcW: Float, srcH: Float, tint: Color)
-  | Text(text: Str, x: Float, y: Float, size: Float, color: Color)
-  | RectShape(x: Float, y: Float, w: Float, h: Float, color: Color)
-  | CircleShape(cx: Float, cy: Float, r: Float, color: Color)
-  | LineShape(x1: Float, y1: Float, x2: Float, y2: Float, thickness: Float, color: Color)
-  | Tagged(id: Int, child: SceneNode)
-struct Rect(x: Float, y: Float, w: Float, h: Float)
-fun picMatrix(t: Transform) -> Affine = match t
-  Identity => Affine.Identity
-  Translate(dx, dy) => Affine(a: 1.0, b: 0.0, c: 0.0, d: 1.0, e: dx, f: dy)
-  Rotate(rad) => Affine(a: Math.cos(rad), b: Math.sin(rad), c: 0.0 - Math.sin(rad), d: Math.cos(rad), e: 0.0, f: 0.0)
-  Scale(sx, sy) => Affine(a: sx, b: 0.0, c: 0.0, d: sy, e: 0.0, f: 0.0)
-  Compose(first, then) => picMatrix(first).mul(picMatrix(then))
-# The bounding box, in the outer space, of the box (x, y, w, h) seen through `m`.
-fun picBox(x: Float, y: Float, w: Float, h: Float, m: Affine) -> Rect =
-  p1 := m.apply(Vec2(x: x, y: y))
-  p2 := m.apply(Vec2(x: x + w, y: y))
-  p3 := m.apply(Vec2(x: x, y: y + h))
-  p4 := m.apply(Vec2(x: x + w, y: y + h))
-  x0 := p1.x.min(p2.x).min(p3.x.min(p4.x))
-  x1 := p1.x.max(p2.x).max(p3.x.max(p4.x))
-  y0 := p1.y.min(p2.y).min(p3.y.min(p4.y))
-  y1 := p1.y.max(p2.y).max(p3.y.max(p4.y))
-  Rect(x: x0, y: y0, w: x1 - x0, h: y1 - y0)
-fun picUnion(a: Rect?, b: Rect) -> Rect =
-  if ra := a
-    x0 := ra.x.min(b.x)
-    y0 := ra.y.min(b.y)
-    x1 := {ra.x + ra.w}.max(b.x + b.w)
-    y1 := {ra.y + ra.h}.max(b.y + b.h)
-    return Rect(x: x0, y: y0, w: x1 - x0, h: y1 - y0)
-  b
-fun picBoxLine(x1: Float, y1: Float, x2: Float, y2: Float, thickness: Float, m: Affine) -> Rect =
-  lx := x1.min(x2) - thickness / 2.0
-  ly := y1.min(y2) - thickness / 2.0
-  picBox(lx, ly, {x1 - x2}.abs() + thickness, {y1 - y2}.abs() + thickness, m)
-# The bounds of `node` drawn under `m`, or null when it has no extent.
-fun picBounds(node: SceneNode, m: Affine) -> Rect? = match node
-  RectShape(x, y, w, h, _) => picBox(x, y, w, h, m)
-  CircleShape(cx, cy, r, _) => picBox(cx - r, cy - r, r * 2.0, r * 2.0, m)
-  LineShape(x1, y1, x2, y2, th, _) => picBoxLine(x1, y1, x2, y2, th, m)
-  Sprite(_, sx, sy, sw, sh, _, _, _, _, _) => picBox(sx, sy, sw, sh, m)
-  Text(txt, tx, ty, size, _) => picBox(tx, ty, size * 0.6 * Float(txt.length()), size, m)
-  Group(tr, kids) => picBoundsKids(kids, m.mul(picMatrix(tr)), null)
-  Filter(_, child, _) => picBounds(child, m)
-  Tagged(_, child) => picBounds(child, m)
-fun picBoundsKids(kids: List[SceneNode], m: Affine, acc: Rect?) -> Rect? = match kids
-  Nil => acc
-  Cons(head, tail) =>
-    if cr := picBounds(head, m)
-      picBoundsKids(tail, m, picUnion(acc, cr))
-    else
-      picBoundsKids(tail, m, acc)
-fun picInBox(x: Float, y: Float, w: Float, h: Float, px: Float, py: Float) -> Bool =
-  px >= x && px <= x + w && py >= y && py <= y + h
-fun picNearLine(x1: Float, y1: Float, x2: Float, y2: Float, thickness: Float, px: Float, py: Float) -> Bool =
-  dx := x2 - x1
-  dy := y2 - y1
-  len2 := dx * dx + dy * dy
-  t := if len2 == 0.0 then 0.0 else {{px - x1} * dx + {py - y1} * dy} / len2
-  tc := t.max(0.0).min(1.0)
-  qx := x1 + dx * tc
-  qy := y1 + dy * tc
-  Math.hypot(px - qx, py - qy) <= thickness.max(1.0) / 2.0
-fun picLeaf(hit: Bool) -> Slice[Int]? =
-  if hit
-    return Slice[Int]()
-  null
-# `i` followed by the path `sub`.
-fun picPrepend(i: Int, sub: Slice[Int]) -> Slice[Int] =
-  path := Slice(i)
-  for j := range sub.length()
-    path.push(sub.at(j))
-  path
-# The child indices from `node` down to the hit leaf, or null on a miss. A leaf
-# that is hit is an empty path. (px, py) is in `node`'s own space.
-fun picHit(node: SceneNode, px: Float, py: Float) -> Slice[Int]? = match node
-  RectShape(x, y, w, h, _) => picLeaf(picInBox(x, y, w, h, px, py))
-  CircleShape(cx, cy, r, _) => picLeaf(Math.hypot(px - cx, py - cy) <= r)
-  LineShape(x1, y1, x2, y2, th, _) => picLeaf(picNearLine(x1, y1, x2, y2, th, px, py))
-  Sprite(_, sx, sy, sw, sh, _, _, _, _, _) => picLeaf(picInBox(sx, sy, sw, sh, px, py))
-  Text(txt, tx, ty, size, _) => picLeaf(picInBox(tx, ty, size * 0.6 * Float(txt.length()), size, px, py))
-  Group(tr, kids) =>
-    if gi := picMatrix(tr).invert()
-      lp := gi.apply(Vec2(x: px, y: py))
-      picHitKids(kids, 0, lp.x, lp.y)
-    else
-      null
-  Filter(_, child, _) =>
-    if fp := picHit(child, px, py)
-      picPrepend(0, fp)
-    else
-      null
-  Tagged(_, child) =>
-    if tp := picHit(child, px, py)
-      picPrepend(0, tp)
-    else
-      null
-# The id of the innermost Tagged node whose subtree is hit at (px, py), or null.
-# `outer` is the id of the nearest enclosing tag (null at the root).
-fun picHitId(node: SceneNode, outer: Int?, px: Float, py: Float) -> Int? = match node
-  Group(tr, kids) =>
-    if gi := picMatrix(tr).invert()
-      lp := gi.apply(Vec2(x: px, y: py))
-      picHitIdKids(kids, outer, lp.x, lp.y)
-    else
-      null
-  Filter(_, child, _) => picHitId(child, outer, px, py)
-  Tagged(id, child) => picHitId(child, id, px, py)
-  _ =>
-    if picHit(node, px, py) != null
-      outer
-    else
-      null
-# Later siblings are drawn on top, so they are tried first.
-fun picHitIdKids(kids: List[SceneNode], outer: Int?, px: Float, py: Float) -> Int? = match kids
-  Nil => null
-  Cons(head, tail) =>
-    if later := picHitIdKids(tail, outer, px, py)
-      later
-    else
-      picHitId(head, outer, px, py)
-# Tries the later children first (they are drawn on top); `i` is the index of
-# `kids`' head. The first hit found from the back wins.
-fun picHitKids(kids: List[SceneNode], i: Int, px: Float, py: Float) -> Slice[Int]? = match kids
-  Nil => null
-  Cons(head, tail) =>
-    if later := picHitKids(tail, i + 1, px, py)
-      later
-    else
-      if sub := picHit(head, px, py)
-        picPrepend(i, sub)
-      else
-        null
-fun picDraw(io: Io, node: SceneNode, m: Affine, alpha: Float, target: Int) = match node
-  RectShape(x, y, w, h, color) =>
-    sx := w * m.scaleX()
-    sy := h * m.scaleY()
-    c := m.apply(Vec2(x: x + w / 2.0, y: y + h / 2.0))
-    io.drawRect(c.x - sx / 2.0, c.y - sy / 2.0, sx, sy, color.withAlpha(color.a * alpha))
-  CircleShape(cx, cy, r, ccolor) =>
-    cc := m.apply(Vec2(x: cx, y: cy))
-    io.drawCircle(cc.x, cc.y, r * m.scaleX(), ccolor.withAlpha(ccolor.a * alpha))
-  LineShape(x1, y1, x2, y2, th, lcolor) =>
-    p := m.apply(Vec2(x: x1, y: y1))
-    q := m.apply(Vec2(x: x2, y: y2))
-    io.drawLine(p.x, p.y, q.x, q.y, th * m.scaleX(), lcolor.withAlpha(lcolor.a * alpha))
-  Sprite(tex, sx0, sy0, sw0, sh0, srcX, srcY, srcW, srcH, tint) =>
-    sw := sw0 * m.scaleX()
-    sh := sh0 * m.scaleY()
-    sc := m.apply(Vec2(x: sx0 + sw0 / 2.0, y: sy0 + sh0 / 2.0))
-    io.drawTextureEx(tex, srcX, srcY, srcW, srcH, sc.x - sw / 2.0, sc.y - sh / 2.0, sw, sh, m.rotation(), false, tint.withAlpha(tint.a * alpha))
-  Text(txt, tx, ty, size, tcolor) =>
-    tp := m.apply(Vec2(x: tx, y: ty))
-    io.drawText(txt, tp.x, tp.y, size * m.scaleY(), tcolor.withAlpha(tcolor.a * alpha))
-  Group(tr, kids) => picDrawKids(io, kids, m.mul(picMatrix(tr)), alpha, target)
-  Filter(effect, child, tex) => picFilter(io, effect, child, tex, m, alpha, target)
-  Tagged(_, child) => picDraw(io, child, m, alpha, target)
-fun picDrawKids(io: Io, kids: List[SceneNode], m: Affine, alpha: Float, target: Int) = match kids
-  Nil => 0
-  Cons(head, tail) =>
-    picDraw(io, head, m, alpha, target)
-    picDrawKids(io, tail, m, alpha, target)
-fun picFilter(io: Io, effect: Effect, child: SceneNode, tex: Int, m: Affine, alpha: Float, target: Int) = match effect
-  BlendFx(mode) =>
-    io.blendMode(mode)
-    picDraw(io, child, m, alpha, target)
-    io.blendMode(Blend.Normal)
-  _ =>
-    if b := picBounds(child, m)
-      if tex >= 0
-        w := {Int(b.w) + 1}.min(io.textureWidth(tex))
-        h := {Int(b.h) + 1}.min(io.textureHeight(tex))
-        io.renderTarget(tex)
-        io.clear(Color.Transparent)
-        shift := Affine(a: 1.0, b: 0.0, c: 0.0, d: 1.0, e: 0.0 - b.x, f: 0.0 - b.y)
-        picDraw(io, child, shift.mul(m), 1.0, tex)
-        io.renderTarget(target)
-        picComposite(io, effect, tex, b, alpha, w, h)
-fun picTint(e: Effect, alpha: Float) -> Color = match e
-  Tint(color) => color.withAlpha(color.a * alpha)
-  Alpha(a) => Color.White.withAlpha(a * alpha)
-  _ => Color.White.withAlpha(alpha)
-fun picComposite(io: Io, e: Effect, tex: Int, b: Rect, alpha: Float, w: Int, h: Int) =
-  io.drawTextureEx(tex, 0.0, 0.0, Float(w), Float(h), b.x, b.y, Float(w), Float(h), 0.0, false, picTint(e, alpha))
-primitive Picture =
-  # Draws the picture to the current target, recursing with the parent matrix and alpha.
-  fun draw(io: Io, node: SceneNode) =
-    picDraw(io, node, Affine.Identity, 1.0, 0 - 1)
-  # The bounding box of the picture in its own space (all zero when empty).
-  fun bounds(node: SceneNode) -> Rect =
-    if r := picBounds(node, Affine.Identity)
-      return r
-    Rect(x: 0.0, y: 0.0, w: 0.0, h: 0.0)
-  # Child indices from the root down to the topmost hit leaf; empty on a miss.
-  fun hitPath(node: SceneNode, x: Float, y: Float) -> Slice[Int] =
-    if p := picHit(node, x, y)
-      return p
-    Slice[Int]()
-  # The id of the innermost Tagged node under (x, y), or null. Later siblings win.
-  fun hitId(node: SceneNode, x: Float, y: Float) -> Int? =
-    picHitId(node, null, x, y)
-fun picNear(a: Float, b: Float) -> Bool =
-  {a - b}.abs() < 1e-6
-fun picRect(x: Float, y: Float, w: Float, h: Float, c: Color) -> SceneNode =
-  RectShape(x: x, y: y, w: w, h: h, color: c)
-test "bounds_translate_scale"
-  g := Group(transform: Compose(first: Translate(dx: 5.0, dy: 5.0), then: Scale(sx: 2.0, sy: 2.0)), children: Cons(head: picRect(0.0, 0.0, 10.0, 10.0, Color.Red), tail: Nil))
-  r := Picture.bounds(g)
-  assert picNear(r.x, 5.0)
-  assert picNear(r.y, 5.0)
-  assert picNear(r.w, 20.0)
-  assert picNear(r.h, 20.0)
-test "bounds_rotate_quarter"
-  g := Group(transform: Rotate(radians: 1.5707963267948966), children: Cons(head: picRect(0.0, 0.0, 10.0, 4.0, Color.Red), tail: Nil))
-  r := Picture.bounds(g)
-  assert picNear(r.x, 0.0 - 4.0)
-  assert picNear(r.y, 0.0)
-  assert picNear(r.w, 4.0)
-  assert picNear(r.h, 10.0)
-test "hit_path_nested"
-  inner := Group(transform: Translate(dx: 10.0, dy: 0.0), children: Cons(head: picRect(0.0, 0.0, 10.0, 10.0, Color.Blue), tail: Nil))
-  g := Group(transform: Identity, children: Cons(head: picRect(0.0, 0.0, 10.0, 10.0, Color.Red), tail: Cons(head: inner, tail: Nil)))
-  p := Picture.hitPath(g, 15.0, 5.0)
-  assert p.length() == 2
-  assert p.at(0) == 1
-  assert p.at(1) == 0
-  q := Picture.hitPath(g, 5.0, 5.0)
-  assert q.length() == 1
-  assert q.at(0) == 0
-test "hit_path_last_child_wins"
-  g := Group(transform: Identity, children: Cons(head: picRect(0.0, 0.0, 10.0, 10.0, Color.Red), tail: Cons(head: picRect(0.0, 0.0, 10.0, 10.0, Color.Blue), tail: Nil)))
-  p := Picture.hitPath(g, 5.0, 5.0)
-  assert p.length() == 1
-  assert p.at(0) == 1
-test "hit_miss_empty"
-  g := Group(transform: Identity, children: Cons(head: picRect(0.0, 0.0, 10.0, 10.0, Color.Red), tail: Nil))
-  assert Picture.hitPath(g, 50.0, 50.0).length() == 0
-test "filter_bounds_is_child_bounds"
-  g := Filter(effect: Alpha(alpha: 0.5), child: picRect(1.0, 2.0, 10.0, 4.0, Color.Red), target: 0 - 1)
-  r := Picture.bounds(g)
-  assert picNear(r.x, 1.0)
-  assert picNear(r.y, 2.0)
-  assert picNear(r.w, 10.0)
-  assert picNear(r.h, 4.0)
-test "tagged_bounds_and_path"
-  g := Group(transform: Identity, children: Cons(head: Tagged(id: 7, child: picRect(1.0, 2.0, 10.0, 4.0, Color.Red)), tail: Nil))
-  r := Picture.bounds(g)
-  assert picNear(r.x, 1.0)
-  assert picNear(r.w, 10.0)
-  p := Picture.hitPath(g, 5.0, 3.0)
-  assert p.length() == 2
-  assert p.at(0) == 0
-  assert p.at(1) == 0
-test "hit_id_innermost_and_topmost"
-  inner := Tagged(id: 2, child: picRect(0.0, 0.0, 10.0, 10.0, Color.Blue))
-  outer := Tagged(id: 1, child: Group(transform: Identity, children: Cons(head: picRect(0.0, 0.0, 20.0, 20.0, Color.Red), tail: Cons(head: inner, tail: Nil))))
-  top := Tagged(id: 3, child: picRect(15.0, 15.0, 10.0, 10.0, Color.Red))
-  g := Group(transform: Translate(dx: 1.0, dy: 0.0), children: Cons(head: outer, tail: Cons(head: top, tail: Nil)))
-  a := Picture.hitId(g, 6.0, 5.0)
-  if va := a
-    assert va == 2
-  else
-    assert false
-  b := Picture.hitId(g, 19.0, 5.0)
-  if vb := b
-    assert vb == 1
-  else
-    assert false
-  c := Picture.hitId(g, 17.0, 17.0)
-  if vc := c
-    assert vc == 3
-  else
-    assert false
-  assert Picture.hitId(g, 100.0, 100.0) == null

plum-std/game/functional/Ui.plum CHANGED Viewed

@@ -5,10 +5,10 @@ import std/Str
 import std/Slice
 import std/List
 import std/game/Color
-import std/game/functional/Picture
+import std/game/functional/FunctionalScene
 # A pure UI layer for the functional scene style. `Ui.step` takes the previous
-# UiState, one pointer input and the id under the pointer (from Picture.hitId on
+# UiState, one pointer input and the id under the pointer (from SceneNode.hitId on
 # the current view) and returns the new state plus the UiEvents it raised. Same
 # button rules as PureScene: Down captures the pressed id; while captured only
 # that id gets Enter/Exit; Up releases (Click only when still over it).
@@ -204,7 +204,7 @@ test "button_visual_reflects_state"
   assert uiButtonColor(idle).eq(uiIdleColor())
   assert uiButtonColor(hov).eq(uiHoverColor())
   assert uiButtonColor(prs).eq(uiPressedColor())
-  if hid := Picture.hitId(idle, 20.0, 30.0)
+  if hid := idle.hitId(20.0, 30.0)
     assert hid == 3
   else
     assert false

plum-std/game/pure/Actions.plum CHANGED Viewed

@@ -3,7 +3,7 @@ import std/Slice
 import std/Int
 import std/Float
-# scene2d-style actions as plain data plus a step function. `Actions.stepAction`
+# scene2d-style actions as plain data plus a step method. `Action.step`
 # steps an action IN PLACE on its own record (a running action allocates nothing:
 # the result is a struct, flattened into multi-value returns) and reports the new
 # pose, the part of `dt` it did not use and whether it finished. `stepAll` drops
@@ -17,25 +17,7 @@ struct Pose(x: Float, y: Float, rotation: Float, scaleX: Float, scaleY: Float)
 # One action. `elapsed` and `current` (the running lap of a `Forever`, null
 # before it starts) are the mutable state; `kind` is the immutable description.
 # A `Forever`'s `template` is the pristine action restarted each lap.
-record Action(mut elapsed: Float, mut current: Action?, kind: ActionKind)
+record Action(mut elapsed: Float, mut current: Action?, kind: ActionKind) =
-enum ActionKind =
-  | MoveBy(dx: Float, dy: Float, duration: Float)
-  | RotateBy(radians: Float, duration: Float)
-  | Delay(duration: Float)
-  | Sequence(steps: Slice[Action])
-  | Parallel(steps: Slice[Action])
-  | Forever(template: Action)
-# How much of a timed action one step covers. A zero-length action finishes at
-# once and applies all of itself (no 0/0).
-struct Tick(used: Float, frac: Float, done: Bool)
-# The result of one step: the pose, the unused part of dt (0 while running) and
-# whether the action(s) finished. For `stepAll`, `done` means none are left.
-struct Step(pose: Pose, spare: Float, done: Bool)
-primitive Actions =
   fun moveBy(dx: Float, dy: Float, secs: Float) -> Action =
     Action(elapsed: 0.0, current: null, kind: MoveBy(dx: dx, dy: dy, duration: secs))
@@ -52,76 +34,70 @@ primitive Actions =
     Action(elapsed: 0.0, current: null, kind: Parallel(steps: steps))
   fun forever(a: Action) -> Action =
-    Action(elapsed: 0.0, current: a, kind: Forever(template: Actions.fresh(a)))
+    Action(elapsed: 0.0, current: a, kind: Forever(template: a.fresh()))
-  # An unstarted copy of `a` (elapsed 0, all steps present).
+  # An unstarted copy (elapsed 0, all steps present).
-  fun fresh(a: Action) -> Action =
+  fun fresh(self) -> Action =
-    match a.kind
+    match self.kind
-      MoveBy(dx, dy, duration) => Actions.moveBy(dx, dy, duration)
+      MoveBy(dx, dy, duration) => Action.moveBy(dx, dy, duration)
-      RotateBy(radians, duration) => Actions.rotateBy(radians, duration)
+      RotateBy(radians, duration) => Action.rotateBy(radians, duration)
-      Delay(duration) => Actions.delay(duration)
+      Delay(duration) => Action.delay(duration)
       Sequence(steps) =>
         out := Slice[Action]()
         for i := range steps.length()
-          out.push(Actions.fresh(steps.at(i)))
+          out.push(steps.at(i).fresh())
-        Actions.sequence(out)
+        Action.sequence(out)
       Parallel(steps) =>
         out := Slice[Action]()
         for i := range steps.length()
-          out.push(Actions.fresh(steps.at(i)))
+          out.push(steps.at(i).fresh())
-        Actions.parallel(out)
+        Action.parallel(out)
-      Forever(template) =>
-        Action(elapsed: 0.0, current: Actions.fresh(template), kind: Forever(template: template))
+      Forever(template) => Action(elapsed: 0.0, current: template.fresh(), kind: Forever(template: template))
-  fun tick(duration: Float, elapsed: Float, dt: Float) -> Tick =
-    if duration <= 0.0
-      return Tick(used: 0.0, frac: 1.0, done: true)
-    used := dt.min(duration - elapsed)
-    Tick(used: used, frac: used / duration, done: elapsed + used >= duration)
+  # Steps this action by `dt` in place, from pose `p`.
-  fun stepAction(p: Pose, a: Action, dt: Float) -> Step =
+  fun step(self, p: Pose, dt: Float) -> Step =
+    a := self
     match a.kind
       MoveBy(dx, dy, duration) =>
-        k := Actions.tick(duration, a.elapsed, dt)
+        k := Tick.of(duration, a.elapsed, dt)
         a.elapsed = a.elapsed + k.used
         q := Pose(x: p.x + dx * k.frac, y: p.y + dy * k.frac, rotation: p.rotation, scaleX: p.scaleX, scaleY: p.scaleY)
         Step(pose: q, spare: if k.done then dt - k.used else 0.0, done: k.done)
       RotateBy(radians, duration) =>
-        k := Actions.tick(duration, a.elapsed, dt)
+        k := Tick.of(duration, a.elapsed, dt)
         a.elapsed = a.elapsed + k.used
         q := Pose(x: p.x, y: p.y, rotation: p.rotation + radians * k.frac, scaleX: p.scaleX, scaleY: p.scaleY)
         Step(pose: q, spare: if k.done then dt - k.used else 0.0, done: k.done)
       Delay(duration) =>
-        k := Actions.tick(duration, a.elapsed, dt)
+        k := Tick.of(duration, a.elapsed, dt)
         a.elapsed = a.elapsed + k.used
         Step(pose: p, spare: if k.done then dt - k.used else 0.0, done: k.done)
       Sequence(steps) =>
         if steps.length() == 0
           return Step(pose: p, spare: dt, done: true)
-        s := Actions.stepAction(p, steps.at(0), dt)
+        s := steps.at(0).step(p, dt)
         if !s.done
           return Step(pose: s.pose, spare: 0.0, done: false)
         # The rest starts in this same frame with the time left over; the list
         # is one shorter on every call, so this terminates.
         steps.removeAt(0)
-        Actions.stepAction(s.pose, a, s.spare)
+        a.step(s.pose, s.spare)
-      Parallel(steps) =>
-        Actions.stepAll(p, steps, dt)
+      Parallel(steps) => Action.stepAll(p, steps, dt)
       Forever(template) =>
         # Restarts at most once per step, with the spare time, so a zero-length
         # template cannot spin forever inside one step.
         if a.current == null
-          a.current = Actions.fresh(template)
+          a.current = template.fresh()
         lap := template
         if c := a.current
           lap = c
-        s := Actions.stepAction(p, lap, dt)
+        s := lap.step(p, dt)
         if !s.done
           return Step(pose: s.pose, spare: 0.0, done: false)
-        next := Actions.fresh(template)
+        next := template.fresh()
-        r := Actions.stepAction(s.pose, next, s.spare)
+        r := next.step(s.pose, s.spare)
         if r.done
-          a.current = Actions.fresh(template)
+          a.current = template.fresh()
         else
           a.current = next
         Step(pose: r.pose, spare: 0.0, done: false)
@@ -134,7 +110,7 @@ primitive Actions =
     spare := dt
     w := 0
     for i := range acts.length()
-      s := Actions.stepAction(pose, acts.at(i), dt)
+      s := acts.at(i).step(pose, dt)
       pose = s.pose
       if !s.done
         if w != i
@@ -148,6 +124,28 @@ primitive Actions =
       spare = 0.0
     Step(pose: pose, spare: spare, done: w == 0)
+enum ActionKind =
+  | MoveBy(dx: Float, dy: Float, duration: Float)
+  | RotateBy(radians: Float, duration: Float)
+  | Delay(duration: Float)
+  | Sequence(steps: Slice[Action])
+  | Parallel(steps: Slice[Action])
+  | Forever(template: Action)
+# How much of a timed action one step covers. A zero-length action finishes at
+# once and applies all of itself (no 0/0).
+struct Tick(used: Float, frac: Float, done: Bool) =
+  # One step of `dt` on an action `duration` long that has run for `elapsed`.
+  fun of(duration: Float, elapsed: Float, dt: Float) -> Tick =
+    if duration <= 0.0
+      return Tick(used: 0.0, frac: 1.0, done: true)
+    used := dt.min(duration - elapsed)
+    Tick(used: used, frac: used / duration, done: elapsed + used >= duration)
+# The result of one step: the pose, the unused part of dt (0 while running) and
+# whether the action(s) finished. For `stepAll`, `done` means none are left.
+struct Step(pose: Pose, spare: Float, done: Bool)
 fun actNear(a: Float, b: Float) -> Bool =
   {a - b}.abs() < 0.000001
@@ -177,7 +175,7 @@ fun goldAdv(r0: GoldRun, n: Int, dt: Float) -> GoldRun =
   r := r0
   for i := range n
     if !r.done
-      s := Actions.stepAction(r.p, r.a, dt)
+      s := r.a.step(r.p, dt)
       r = GoldRun(..r, p: s.pose, spare: s.spare, done: s.done)
   r
@@ -192,7 +190,7 @@ fun goldWant(r: GoldRun, x: Float, y: Float, rotation: Float, spare: Float, done
   assert r.done == done
 fun goldMove() =
-  r := goldRun(Actions.moveBy(10.0, 5.0, 1.0))
+  r := goldRun(Action.moveBy(10.0, 5.0, 1.0))
   r = goldAdv(r, 1, 0.016)
   goldWant(r, 0.16, 0.08, 0.0, 0.0, false)
   r = goldAdv(r, 29, 0.016)
@@ -203,7 +201,7 @@ fun goldMove() =
   goldWant(r, 10.0, 5.0, 0.0, 0.008, true)
 fun goldRotate() =
-  r := goldRun(Actions.rotateBy(2.0, 0.5))
+  r := goldRun(Action.rotateBy(2.0, 0.5))
   r = goldAdv(r, 10, 0.016)
   goldWant(r, 0.0, 0.0, 0.64, 0.0, false)
   r = goldAdv(r, 21, 0.016)
@@ -212,14 +210,14 @@ fun goldRotate() =
   goldWant(r, 0.0, 0.0, 2.0, 0.012, true)
 fun goldDelay() =
-  r := goldRun(Actions.delay(0.1))
+  r := goldRun(Action.delay(0.1))
   r = goldAdv(r, 6, 0.016)
   goldWant(r, 0.0, 0.0, 0.0, 0.0, false)
   r = goldAdv(r, 1, 0.016)
   goldWant(r, 0.0, 0.0, 0.0, 0.012, true)
 fun goldSequence() =
-  r := goldRun(Actions.sequence(Slice(Actions.moveBy(10.0, 0.0, 0.2), Actions.delay(0.1), Actions.rotateBy(1.0, 0.2))))
+  r := goldRun(Action.sequence(Slice(Action.moveBy(10.0, 0.0, 0.2), Action.delay(0.1), Action.rotateBy(1.0, 0.2))))
   r = goldAdv(r, 12, 0.016)
   goldWant(r, 9.6, 0.0, 0.0, 0.0, false)
   r = goldAdv(r, 1, 0.016)
@@ -236,7 +234,7 @@ fun goldSequence() =
   goldWant(r, 10.0, 0.0, 1.0, 0.012, true)
 fun goldParallel() =
-  r := goldRun(Actions.parallel(Slice(Actions.moveBy(10.0, 0.0, 0.3), Actions.rotateBy(1.0, 0.1), Actions.delay(0.2))))
+  r := goldRun(Action.parallel(Slice(Action.moveBy(10.0, 0.0, 0.3), Action.rotateBy(1.0, 0.1), Action.delay(0.2))))
   r = goldAdv(r, 5, 0.016)
   goldWant(r, 2.666667, 0.0, 0.8, 0.0, false)
   r = goldAdv(r, 2, 0.016)
@@ -249,7 +247,7 @@ fun goldParallel() =
   goldWant(r, 10.0, 0.0, 1.0, 0.004, true)
 fun goldForever() =
-  r := goldRun(Actions.forever(Actions.sequence(Slice(Actions.moveBy(1.0, 0.0, 0.1), Actions.delay(0.05)))))
+  r := goldRun(Action.forever(Action.sequence(Slice(Action.moveBy(1.0, 0.0, 0.1), Action.delay(0.05)))))
   r = goldAdv(r, 9, 0.016)
   goldWant(r, 1.0, 0.0, 0.0, 0.0, false)
   r = goldAdv(r, 91, 0.016)
@@ -258,9 +256,9 @@ fun goldForever() =
   goldWant(r, 107.0, 0.0, 0.0, 0.0, false)
 fun goldNested() =
-  inner := Actions.parallel(Slice(Actions.moveBy(4.0, 0.0, 0.1), Actions.delay(0.2)))
+  inner := Action.parallel(Slice(Action.moveBy(4.0, 0.0, 0.1), Action.delay(0.2)))
-  loop := Actions.forever(Actions.parallel(Slice(Actions.rotateBy(1.0, 0.1), Actions.moveBy(0.0, 1.0, 0.3))))
+  loop := Action.forever(Action.parallel(Slice(Action.rotateBy(1.0, 0.1), Action.moveBy(0.0, 1.0, 0.3))))
-  r := goldRun(Actions.sequence(Slice(inner, loop)))
+  r := goldRun(Action.sequence(Slice(inner, loop)))
   r = goldAdv(r, 6, 0.016)
   goldWant(r, 3.84, 0.0, 0.0, 0.0, false)
   r = goldAdv(r, 7, 0.016)
@@ -271,7 +269,7 @@ fun goldNested() =
   goldWant(r, 4.0, 11.76, 12.0, 0.0, false)
 fun goldLargeDt() =
-  r := goldRun(Actions.sequence(Slice(Actions.moveBy(1.0, 0.0, 0.1), Actions.moveBy(0.0, 1.0, 0.1), Actions.rotateBy(1.0, 0.1), Actions.delay(0.1))))
+  r := goldRun(Action.sequence(Slice(Action.moveBy(1.0, 0.0, 0.1), Action.moveBy(0.0, 1.0, 0.1), Action.rotateBy(1.0, 0.1), Action.delay(0.1))))
   r = goldAdv(r, 1, 0.25)
   goldWant(r, 1.0, 1.0, 0.5, 0.0, false)
   r = goldAdv(r, 1, 0.05)
@@ -280,7 +278,7 @@ fun goldLargeDt() =
   goldWant(r, 1.0, 1.0, 1.0, 0.4, true)
 fun goldLargeDtParallel() =
-  r := goldRun(Actions.parallel(Slice(Actions.moveBy(2.0, 0.0, 0.1), Actions.sequence(Slice(Actions.delay(0.1), Actions.rotateBy(1.0, 0.1))), Actions.delay(0.3))))
+  r := goldRun(Action.parallel(Slice(Action.moveBy(2.0, 0.0, 0.1), Action.sequence(Slice(Action.delay(0.1), Action.rotateBy(1.0, 0.1))), Action.delay(0.3))))
   r = goldAdv(r, 1, 0.15)
   goldWant(r, 2.0, 0.0, 0.5, 0.0, false)
   r = goldAdv(r, 1, 0.1)
@@ -289,7 +287,7 @@ fun goldLargeDtParallel() =
   goldWant(r, 2.0, 0.0, 1.0, 0.35, true)
 fun goldLargeDtForever() =
-  r := goldRun(Actions.forever(Actions.sequence(Slice(Actions.moveBy(1.0, 0.0, 0.1), Actions.rotateBy(1.0, 0.1)))))
+  r := goldRun(Action.forever(Action.sequence(Slice(Action.moveBy(1.0, 0.0, 0.1), Action.rotateBy(1.0, 0.1)))))
   r = goldAdv(r, 1, 0.25)
   goldWant(r, 1.5, 0.0, 1.0, 0.0, false)
   r = goldAdv(r, 1, 0.5)
@@ -298,15 +296,15 @@ fun goldLargeDtForever() =
   goldWant(r, 3.16, 0.0, 3.0, 0.0, false)
 test "stepAll moves partway and keeps the action"
-  acts := Slice(Actions.moveBy(10.0, 0.0, 1.0))
+  acts := Slice(Action.moveBy(10.0, 0.0, 1.0))
-  r := Actions.stepAll(actPose0(), acts, 0.5)
+  r := Action.stepAll(actPose0(), acts, 0.5)
   assert actNear(r.pose.x, 5.0)
   assert acts.length() == 1
   assert actNear(r.spare, 0.0)
 test "stepAll finishes every action and reports no spare"
-  acts := Slice(Actions.moveBy(10.0, 0.0, 1.0), Actions.rotateBy(1.0, 0.5))
+  acts := Slice(Action.moveBy(10.0, 0.0, 1.0), Action.rotateBy(1.0, 0.5))
-  r := Actions.stepAll(actPose0(), acts, 1.0)
+  r := Action.stepAll(actPose0(), acts, 1.0)
   assert actNear(r.pose.x, 10.0)
   assert actNear(r.pose.rotation, 1.0)
   assert acts.length() == 0
@@ -314,29 +312,29 @@ test "stepAll finishes every action and reports no spare"
 test "stepAll with no actions is a no-op"
   acts := Slice[Action]()
-  r := Actions.stepAll(actPose0(), acts, 0.016)
+  r := Action.stepAll(actPose0(), acts, 0.016)
   assert acts.length() == 0
   assert actNear(r.spare, 0.016)
   assert actNear(r.pose.x, 0.0)
 test "zero_length_move_applies_at_once"
-  r := Actions.stepAction(actPose0(), Actions.moveBy(10.0, 0.0, 0.0), 0.016)
+  r := Action.moveBy(10.0, 0.0, 0.0).step(actPose0(), 0.016)
   assert actNear(r.pose.x, 10.0)
   assert r.done
   assert actNear(r.spare, 0.016)
 test "forever_rotate_no_drift"
-  a := Actions.forever(Actions.rotateBy(1.0, 1.0))
+  a := Action.forever(Action.rotateBy(1.0, 1.0))
   p := actPose0()
   for i := range 625
-    r := Actions.stepAction(p, a, 0.016)
+    r := a.step(p, 0.016)
     p = r.pose
     assert !r.done
   assert actNear(p.rotation, 10.0)
 test "sequence_spills_spare_time"
-  a := Actions.sequence(Slice(Actions.moveBy(10.0, 0.0, 0.5), Actions.moveBy(0.0, 10.0, 0.5)))
+  a := Action.sequence(Slice(Action.moveBy(10.0, 0.0, 0.5), Action.moveBy(0.0, 10.0, 0.5)))
-  r := Actions.stepAction(actPose0(), a, 0.75)
+  r := a.step(actPose0(), 0.75)
   assert actNear(r.pose.x, 10.0)
   assert actNear(r.pose.y, 5.0)
   assert actNear(r.spare, 0.0)
@@ -344,30 +342,30 @@ test "sequence_spills_spare_time"
   assert actSeqLen(a) == 1
 test "empty_sequence_finishes_with_full_spare"
-  r := Actions.stepAction(actPose0(), Actions.sequence(Slice[Action]()), 0.3)
+  r := Action.sequence(Slice[Action]()).step(actPose0(), 0.3)
   assert r.done
   assert actNear(r.spare, 0.3)
 test "parallel_spare_is_min_of_finished"
-  r := Actions.stepAction(actPose0(), Actions.parallel(Slice(Actions.delay(0.2), Actions.delay(0.5))), 1.0)
+  r := Action.parallel(Slice(Action.delay(0.2), Action.delay(0.5))).step(actPose0(), 1.0)
   assert r.done
   assert actNear(r.spare, 0.5)
 test "forever_zero_length_template_terminates"
-  r := Actions.stepAction(actPose0(), Actions.forever(Actions.delay(0.0)), 1.0)
+  r := Action.forever(Action.delay(0.0)).step(actPose0(), 1.0)
   assert !r.done
 test "forever of a nested sequence keeps looping"
-  a := Actions.forever(Actions.sequence(Slice(Actions.moveBy(1.0, 0.0, 0.1), Actions.delay(0.1))))
+  a := Action.forever(Action.sequence(Slice(Action.moveBy(1.0, 0.0, 0.1), Action.delay(0.1))))
   p := actPose0()
   for i := range 100
-    r := Actions.stepAction(p, a, 0.05)
+    r := a.step(p, 0.05)
     p = r.pose
   assert actNear(p.x, 25.0)
 test "step_moves_the_action_in_place"
-  a := Actions.moveBy(10.0, 0.0, 1.0)
+  a := Action.moveBy(10.0, 0.0, 1.0)
-  r := Actions.stepAction(actPose0(), a, 0.5)
+  r := a.step(actPose0(), 0.5)
   assert actNear(r.pose.x, 5.0)
   assert actElapsed(a) == 0.5
@@ -375,12 +373,12 @@ test "step_moves_the_action_in_place"
 # elapsed moves, no replacement lists or actions), and the slice keeps its length.
 # The wasm of this path has no struct.new (checked with wasm-tools print).
 test "step_all_no_alloc_steady_state"
-  m := Actions.moveBy(100.0, 0.0, 100.0)
+  m := Action.moveBy(100.0, 0.0, 100.0)
-  r := Actions.rotateBy(1.0, 100.0)
+  r := Action.rotateBy(1.0, 100.0)
   acts := Slice(m, r)
   p := actPose0()
   for i := range 10
-    s := Actions.stepAll(p, acts, 0.5)
+    s := Action.stepAll(p, acts, 0.5)
     p = s.pose
     assert !s.done
   assert acts.length() == 2

plum-std/game/pure/PureScene.plum CHANGED Viewed

@@ -14,9 +14,9 @@ import std/game/pure/Actions
 # A pure scene graph: a node is a record (`Node`) holding a `Transform` and
 # an `enum Kind`. Group, Sprite, Label and Button are built in; games add their
 # own behaviour with `Custom(actor: Actor)`, a behaviour-only trait their records
-# embed (like Rust's `Box<dyn Actor>`). `onPointer` takes the node, changes it in
+# embed (like Rust's `Box<dyn Actor>`). A node is a unique value: `update`,
+# `onPointer`, `modify` and `route` take it, change it in place and hand it back;
-# place and hands it back; readers borrow. Only `drawTree` talks to the host,
+# readers borrow. Only `drawTree` talks to the host, through `std/game/Game`.
-# through `std/game/Game`. Actions and tree-wide updates live in std/game/pure/SceneTree.
 enum Touchable =
   | Enabled
@@ -53,9 +53,13 @@ record Transform(x: Float, y: Float, width: Float, height: Float, originX: Float
     mc := 0.0 - sn * self.scaleY
     md := cs * self.scaleY
     Affine(
-      a: ma, b: mb, c: mc, d: md,
+      a: ma,
+      b: mb,
+      c: mc,
+      d: md,
       e: self.x + self.originX - {ma * self.originX + mc * self.originY},
-      f: self.y + self.originY - {mb * self.originX + md * self.originY})
+      f: self.y + self.originY - {mb * self.originX + md * self.originY}
+    )
   # Whether `p`, in the node's own coordinates, is inside its box.
   fun contains(self, p: Vec2) -> Bool =
@@ -63,101 +67,207 @@ record Transform(x: Float, y: Float, width: Float, height: Float, originX: Float
 record Node(
   Transform(x, y, width, height, originX, originY, scaleX, scaleY, rotation),
+  id: Int,
+  color: Color,
+  visible: Bool,
+  touchable: Touchable,
-  id: Int, color: Color, visible: Bool, touchable: Touchable, actions: Slice[Action], kind: Kind)
+  actions: Slice[Action],
+  kind: Kind
+) =
-enum Kind =
+  # --- building ---
-  | Group(children: Slice[Node])
-  | Sprite(tex: Int, srcX: Float, srcY: Float, srcW: Float, srcH: Float)
-  | Label(text: Str, size: Float)
-  | Button(text: Str, upTex: Int, downTex: Int, pressed: Bool, over: Bool)
-  | Custom(actor: Actor)
+  fun group(id: Int, x: Float, y: Float, w: Float, h: Float, children: Slice[Node]) -> Node =
-# Game behaviour for a `Custom` node. The defaults do nothing.
+    Node.make(id, x, y, w, h, Enabled, Group(children: children))
-trait Actor =
-  # The node after `dt` seconds of this actor's behaviour; the default is itself.
-  fun act(self, n: Node, dt: Float) -> Node = n
+  fun sprite(id: Int, tex: Int, x: Float, y: Float, w: Float, h: Float) -> Node =
+    Node.make(id, x, y, w, h, Enabled, Sprite(tex: tex, srcX: 0.0, srcY: 0.0, srcW: 0.0, srcH: 0.0))
-  # Paints the node at its stage transform `m` with the combined `tint`.
-  fun draw(self, io: Io, n: Node, m: Affine, tint: Color) =
+  fun label(id: Int, text: Str, x: Float, y: Float, size: Float) -> Node =
-    return
+    Node.make(id, x, y, size * 0.6 * Float(text.length()), size, Disabled, Label(text: text, size: size))
-# The node after handling an event, and the events it raised.
+  fun button(id: Int, text: Str, upTex: Int, downTex: Int, x: Float, y: Float, w: Float, h: Float) -> Node =
-record Handled(node: Node, events: Slice[UiEvent]) =
+    Node.make(id, x, y, w, h, Enabled, Button(text: text, upTex: upTex, downTex: downTex, pressed: false, over: false))
+  fun custom(id: Int, x: Float, y: Float, w: Float, h: Float, actor: Actor) -> Node =
-  # The node, moved out; read `events` first, they stay behind.
+    Node.make(id, x, y, w, h, Disabled, Custom(actor: actor))
-  fun intoNode(self) -> Node =
+  fun make(id: Int, x: Float, y: Float, w: Float, h: Float, touchable: Touchable, kind: Kind) -> Node =
+    Node(
+      x: x,
+      y: y,
+      width: w,
-    match self
+      height: h,
+      originX: 0.0,
+      originY: 0.0,
+      scaleX: 1.0,
+      scaleY: 1.0,
+      rotation: 0.0,
+      id: id,
+      color: Color.White,
+      visible: true,
-      Handled(n, _) => n
+      touchable: touchable,
+      actions: Slice[Action](),
+      kind: kind
+    )
+  # --- reading ---
-fun pureDrawSprite(io: Io, m: Affine, tint: Color, w: Float, h: Float, tex: Int, srcX: Float, srcY: Float, srcW: Float, srcH: Float) =
-  sx := w * m.scaleX()
-  sy := h * m.scaleY()
-  c := m.apply(Vec2(x: w / 2.0, y: h / 2.0))
-  io.drawTextureEx(tex, srcX, srcY, srcW, srcH, c.x - sx / 2.0, c.y - sy / 2.0, sx, sy, m.rotation(), false, tint)
-fun pureDrawText(io: Io, m: Affine, tint: Color, s: Str, size: Float) =
-  p := m.apply(Vec2(x: 0.0, y: 0.0))
-  io.drawText(s, p.x, p.y, size * m.scaleY(), tint)
-fun pureMulColor(a: Color, b: Color) -> Color =
-  Color(r: a.r * b.r, g: a.g * b.g, b: a.b * b.b, a: a.a * b.a)
-fun pureDrawButton(io: Io, n: Node, m: Affine, tint: Color, text: Str, upTex: Int, downTex: Int, pressed: Bool, over: Bool) =
-  t := upTex
-  if pressed && over
-    t = downTex
-  pureDrawSprite(io, m, tint, n.width, n.height, t, 0.0, 0.0, 0.0, 0.0)
-  size := n.height * 0.5
-  ox := {n.width - size * 0.6 * Float(text.length())} / 2.0
-  oy := {n.height - size} / 2.0
-  pureDrawText(io, m.mul(Affine(a: 1.0, b: 0.0, c: 0.0, d: 1.0, e: ox, f: oy)), tint, text, size)
-fun pureNode(id: Int, x: Float, y: Float, w: Float, h: Float, touchable: Touchable, kind: Kind) -> Node =
-  Node(
-    x: x, y: y, width: w, height: h, originX: 0.0, originY: 0.0,
-    scaleX: 1.0, scaleY: 1.0, rotation: 0.0,
-    id: id, color: Color.White, visible: true, touchable: touchable,
-    actions: Slice[Action](), kind: kind)
-primitive PureScene =
-  # The node's transform into its parent's coordinates.
-  fun localMatrix(n: Node) -> Affine =
-    n.localMatrix()
+  # The children of a group, or null for anything else.
+  fun children(self) -> Slice[Node]? =
+    match self.kind
+      Group(children) => children
+      _ => null
+  # The actor of a Custom node, or null for anything else.
+  fun actor(self) -> Actor? =
+    match self.kind
+      Custom(actor) => actor
+      _ => null
+  # Whether `p`, in the node's own coordinates, is on it.
+  fun hit(self, p: Vec2) -> Bool =
+    self.touchable == Enabled && self.contains(p)
+  # The path (child indexes from this node) to the topmost actor under `p`, which
+  # is in the coordinates of the parent; `parent` is that parent's stage matrix.
+  fun findHit(self, parent: Affine, p: Vec2) -> Slice[Int]? =
+    if !self.visible || self.touchable == Disabled
+      return null
+    m := parent * self.localMatrix()
+    inv := m.invert()
+    if inv == null
+      return null
+    lp := Vec2(x: 0.0, y: 0.0)
+    if q := inv
+      lp = q.apply(p)
+    match self.kind
+      Group(ks) =>
+        i := ks.length() - 1
+        while i >= 0
+          sub := ks.at(i).findHit(m, p)
+          if s := sub
+            return Node.prepend(i, s)
+          i = i - 1
+      _ => 0
+    if self.hit(lp)
+      return Slice[Int]()
+    null
+  # The id of the actor at `path` below this node, or -1 if the path leads nowhere.
+  fun idAt(self, path: Slice[Int], depth: Int) -> Int =
+    if depth >= path.length()
+      return self.id
+    match self.kind
+      Group(ks) =>
+        i := path.at(depth)
+        if i >= 0 && i < ks.length()
+          return ks.at(i).idAt(path, depth + 1)
+      _ => 0
+    -1
+  # The path to the first actor with `id`, depth first; null if none.
+  fun findPath(self, id: Int) -> Slice[Int]? =
+    if self.id == id
+      return Slice[Int]()
+    match self.kind
+      Group(ks) =>
+        for i := range ks.length()
+          sub := ks.at(i).findPath(id)
+          if s := sub
+            return Node.prepend(i, s)
+      _ => 0
+    null
+  # `i` followed by the path `rest`.
+  fun prepend(i: Int, rest: Slice[Int]) -> Slice[Int] =
+    out := Slice(i)
+    for j := range rest.length()
+      out.push(rest.at(j))
+    out
+  # --- drawing ---
   # Draws the node and its children given the parent's matrix and tint.
-  fun drawTree(io: Io, n: Node, parent: Affine, tint: Color) =
+  fun drawTree(self, io: Io, parent: Affine, tint: Color) =
-    if !n.visible
+    if !self.visible
       return
-    m := parent * n.localMatrix()
+    m := parent * self.localMatrix()
-    t := pureMulColor(tint, n.color)
+    t := tint.times(self.color)
-    match n.kind
+    match self.kind
       Group(children) =>
         for i := range children.length()
-          PureScene.drawTree(io, children.at(i), m, t)
+          children.at(i).drawTree(io, m, t)
+      Sprite(tex, srcX, srcY, srcW, srcH) => Node.drawSprite(io, m, t, self.width, self.height, tex, srcX, srcY, srcW, srcH)
+      Label(text, size) => Node.drawText(io, m, t, text, size)
+      Button(text, upTex, downTex, pressed, over) => Node.drawButton(io, self, m, t, text, upTex, downTex, pressed, over)
+      Custom(actor) => actor.draw(io, self, m, t)
+  fun drawSprite(io: Io, m: Affine, tint: Color, w: Float, h: Float, tex: Int, srcX: Float, srcY: Float, srcW: Float, srcH: Float) =
+    sx := w * m.scaleX()
+    sy := h * m.scaleY()
+    c := m.apply(Vec2(x: w / 2.0, y: h / 2.0))
+    io.drawTextureEx(tex, srcX, srcY, srcW, srcH, c.x - sx / 2.0, c.y - sy / 2.0, sx, sy, m.rotation(), false, tint)
+  fun drawText(io: Io, m: Affine, tint: Color, s: Str, size: Float) =
+    p := m.apply(Vec2(x: 0.0, y: 0.0))
-      Sprite(tex, srcX, srcY, srcW, srcH) =>
+    io.drawText(s, p.x, p.y, size * m.scaleY(), tint)
+  fun drawButton(io: Io, n: Node, m: Affine, tint: Color, text: Str, upTex: Int, downTex: Int, pressed: Bool, over: Bool) =
+    t := upTex
+    if pressed && over
+      t = downTex
-        pureDrawSprite(io, m, t, n.width, n.height, tex, srcX, srcY, srcW, srcH)
+    Node.drawSprite(io, m, tint, n.width, n.height, t, 0.0, 0.0, 0.0, 0.0)
+    size := n.height * 0.5
+    ox := {n.width - size * 0.6 * Float(text.length())} / 2.0
-      Label(text, size) =>
+    oy := {n.height - size} / 2.0
-        pureDrawText(io, m, t, text, size)
-      Button(text, upTex, downTex, pressed, over) =>
-        pureDrawButton(io, n, m, t, text, upTex, downTex, pressed, over)
+    Node.drawText(io, m.mul(Affine(a: 1.0, b: 0.0, c: 0.0, d: 1.0, e: ox, f: oy)), tint, text, size)
-      Custom(actor) =>
+  # --- updating ---
-        actor.draw(io, n, m, t)
-  # The children of a group, or null for anything else.
+  # A Custom node's actor acts on it; every other node is itself.
-  fun childrenOf(n: Node) -> Slice[Node]? =
+  fun acted(self, dt: Float) -> Node =
+    if actor := self.actor()
+      return actor.act(self, dt)
+    self
+  # The node after `dt` seconds: a Custom actor's own `act`, then its actions on its pose,
+  # then every child. The tree is changed in place and handed back.
+  fun update(self, dt: Float) -> Node =
+    b := self.acted(dt)
+    r := Action.stepAll(Pose(x: b.x, y: b.y, rotation: b.rotation, scaleX: b.scaleX, scaleY: b.scaleY), b.actions, dt)
+    b = Node(..b, x: r.pose.x, y: r.pose.y, rotation: r.pose.rotation, scaleX: r.pose.scaleX, scaleY: r.pose.scaleY)
-    match n.kind
+    match b.kind
-      Group(children) => children
+      Group(ks) =>
+        _ := ks.mapInPlace(|k| k.update(dt))
-      _ => null
+      _ => 0
+    b
+  # The tree where the first actor with `id` is replaced by `f` of it.
+  fun modify(self, id: Int, f: fn(Node) -> Node) -> Node =
+    path := self.findPath(id)
+    if p := path
+      return self.modifyAt(p, 0, f)
+    self
+  fun modifyAt(self, path: Slice[Int], depth: Int, f: fn(Node) -> Node) -> Node =
+    if depth >= path.length()
+      return f(self)
+    match self.kind
+      Group(ks) =>
+        i := path.at(depth)
+        if i >= 0 && i < ks.length()
+          c := ks.takeAt(i)
+          ks.putAt(i, c.modifyAt(path, depth + 1, f))
+      _ => 0
+    self
-  # Whether `p`, in the node's own coordinates, is on it.
-  fun hit(n: Node, p: Vec2) -> Bool =
+  # --- input ---
-    n.touchable == Enabled && n.contains(p)
   # Handles a pointer event and returns the new node with the events it raised.
   # Only a Button reacts.
-  fun onPointer(n: Node, e: Pointer) -> Handled =
+  fun onPointer(self, e: Pointer) -> Handled =
+    n := self
     ev := Slice[UiEvent]()
     match n.kind
       Button(text, upTex, downTex, wasPressed, wasOver) =>
@@ -184,20 +294,58 @@ primitive PureScene =
       _ => 0
     Handled(node: n, events: ev)
+  # Delivers `e` (in the coordinates of the parent) along `path`: the child on
+  # the path first, then this node. A path that runs out reaches the deepest
+  # actor it can.
+  fun route(self, path: Slice[Int], depth: Int, e: Pointer) -> Handled =
+    events := Slice[UiEvent]()
+    r := self.routeInto(path, depth, e, events)
+    Handled(node: r, events: events)
+  # `route`, appending the raised events to `events` and returning the node.
-  fun group(id: Int, x: Float, y: Float, w: Float, h: Float, children: Slice[Node]) -> Node =
+  fun routeInto(self, path: Slice[Int], depth: Int, e: Pointer, events: Slice[UiEvent]) -> Node =
+    lp := Vec2(x: e.x, y: e.y)
+    inv := self.localMatrix().invert()
+    if q := inv
+      lp = q.apply(lp)
+    local := Pointer(kind: e.kind, x: lp.x, y: lp.y, over: e.over)
+    if depth < path.length()
+      match self.kind
+        Group(ks) =>
+          i := path.at(depth)
+          if i >= 0 && i < ks.length()
+            c := ks.takeAt(i)
-    pureNode(id, x, y, w, h, Enabled, Group(children: children))
+            ks.putAt(i, c.routeInto(path, depth + 1, local, events))
+        _ => 0
+    h := self.onPointer(local)
+    for j := range h.events.length()
+      events.push(h.events.at(j))
+    h.intoNode()
+enum Kind =
+  | Group(children: Slice[Node])
-  fun sprite(id: Int, tex: Int, x: Float, y: Float, w: Float, h: Float) -> Node =
+  | Sprite(tex: Int, srcX: Float, srcY: Float, srcW: Float, srcH: Float)
+  | Label(text: Str, size: Float)
-    pureNode(id, x, y, w, h, Enabled, Sprite(tex: tex, srcX: 0.0, srcY: 0.0, srcW: 0.0, srcH: 0.0))
+  | Button(text: Str, upTex: Int, downTex: Int, pressed: Bool, over: Bool)
+  | Custom(actor: Actor)
-  fun label(id: Int, text: Str, x: Float, y: Float, size: Float) -> Node =
+# Game behaviour for a `Custom` node. The defaults do nothing.
-    pureNode(id, x, y, size * 0.6 * Float(text.length()), size, Disabled, Label(text: text, size: size))
+trait Actor =
-  fun button(id: Int, text: Str, upTex: Int, downTex: Int, x: Float, y: Float, w: Float, h: Float) -> Node =
+  # The node after `dt` seconds of this actor's behaviour; the default is itself.
-    pureNode(id, x, y, w, h, Enabled, Button(text: text, upTex: upTex, downTex: downTex, pressed: false, over: false))
+  fun act(self, n: Node, dt: Float) -> Node = n
-  fun custom(id: Int, x: Float, y: Float, w: Float, h: Float, actor: Actor) -> Node =
+  # Paints the node at its stage transform `m` with the combined `tint`.
-    pureNode(id, x, y, w, h, Disabled, Custom(actor: actor))
+  fun draw(self, io: Io, n: Node, m: Affine, tint: Color) =
+    return
+# The node after handling an event, and the events it raised.
+record Handled(node: Node, events: Slice[UiEvent]) =
+  # The node, moved out; read `events` first, they stay behind.
+  fun intoNode(self) -> Node =
+    match self
+      Handled(n, _) => n
 fun psKinds(h: Handled) -> Slice[UiKind] =
   out := Slice[UiKind]()
@@ -227,28 +375,128 @@ record Beacon(Actor, mut draws: Int) =
   override fun draw(self, io: Io, n: Node, m: Affine, tint: Color) =
     self.draws = self.draws + 1
+fun ttFixture() -> Node =
+  inner := Slice(Node.sprite(4, 0, 0.0, 0.0, 5.0, 5.0))
+  kids := Slice(Node.sprite(2, 0, 0.0, 0.0, 10.0, 10.0), Node.group(3, 20.0, 0.0, 10.0, 10.0, inner))
+  root := Node.group(1, 0.0, 0.0, 100.0, 100.0, kids)
+  me: Node := root
+  me
-fun psActorOf(n: Node) -> Actor? = match n.kind
+fun ttNoPath(r: Slice[Int]?) -> Bool =
-  Custom(a) => a
-  _ => null
+  r == null
+fun ttPathEq(r: Slice[Int]?, want: Slice[Int]) -> Bool =
+  if p := r
+    if p.length() != want.length()
+      return false
+    for i := range p.length()
+      if p.at(i) != want.at(i)
+        return false
+    return true
+  false
+fun ttInts(a: Int, b: Int) -> Slice[Int] =
+  out := Slice(a, b)
+  out
+fun ttAt(x: Float, y: Float) -> Vec2 =
+  Vec2(x: x, y: y)
+fun ttMovingTree() -> Node =
+  s := Node.sprite(2, 0, 0.0, 0.0, 10.0, 10.0)
+  s2 := Node(..s, actions: Slice(Action.moveBy(10.0, 0.0, 1.0)))
+  kids := Slice(s2)
+  root := Node.group(1, 0.0, 0.0, 100.0, 100.0, kids)
+  me: Node := root
+  me
+fun ttFirstKidX(a: Node) -> Float =
+  match a.kind
+    Group(k) =>
+      return k.at(0).x
+    _ => 0
+  0.0 - 1.0
+fun ttFirstKidActions(a: Node) -> Int =
+  match a.kind
+    Group(k) =>
+      return k.at(0).actions.length()
+    _ => 0
+  0 - 1
+fun ttSetTouch(t: Node, id: Int, tc: Touchable) -> Node =
+  t.modify(id, |a| ttSetTouchOf(a, tc))
+fun ttSetTouchOf(a: Node, tc: Touchable) -> Node =
+  Node(..a, touchable: tc)
+fun ttSetScaleX(a: Node) -> Node =
+  Node(..a, scaleX: 0.0)
+fun ttSetX9(a: Node) -> Node =
+  Node(..a, x: 9.0)
+fun ttKidX(a: Node, i: Int) -> Float =
+  match a.kind
+    Group(k) =>
+      return k.at(i).x
+    _ => 0
+  0.0 - 1.0
+fun ttButtonRoot() -> Node =
+  kids := Slice(Node.button(5, "Go", 0, 1, 10.0, 10.0, 100.0, 40.0))
+  root := Node.group(1, 0.0, 0.0, 800.0, 600.0, kids)
+  me: Node := root
+  me
+fun ttZero() -> Slice[Int] =
+  out := Slice(0)
+  out
+# Five actions on one sprite: the 1st, 3rd and 5th finish in the first 0.1s step,
+# the 2nd (MoveBy) and 4th (RotateBy) keep running.
+fun ttCompactTree() -> Node =
+  s := Node.sprite(2, 0, 0.0, 0.0, 10.0, 10.0)
+  s2 := Node(..s, actions: Slice(Action.moveBy(1.0, 0.0, 0.1), Action.moveBy(0.0, 10.0, 10.0), Action.rotateBy(1.0, 0.1), Action.rotateBy(2.0, 10.0), Action.delay(0.1)))
+  kids := Slice(s2)
+  root := Node.group(1, 0.0, 0.0, 100.0, 100.0, kids)
+  me: Node := root
+  me
+fun ttKid(a: Node) -> Node =
+  match a.kind
+    Group(k) =>
+      return k.at(0)
+    _ => 0
+  none: Node := Node.sprite(0, 0, 0.0, 0.0, 0.0, 0.0)
+  none
+# 1 MoveBy, 2 RotateBy, 3 Delay, 0 anything else.
+fun ttActKind(a: Action) -> Int =
+  match a.kind
+    MoveBy(_, _, _) => 1
+    RotateBy(_, _) => 2
+    Delay(_) => 3
+    _ => 0
+# Adds 1.0 to its node's x on every act.
+record TtStepper(Actor, ticks: Int) =
-fun psActed(n: Node, dt: Float) -> Node =
+  override fun act(self, n: Node, dt: Float) -> Node =
-  if a := psActorOf(n)
-    return a.act(n, dt)
+    Node(..n, x: n.x + 1.0)
-  n
 test "local_matrix_translates"
-  s := PureScene.sprite(1, 0, 10.0, 0.0, 2.0, 2.0)
+  s := Node.sprite(1, 0, 10.0, 0.0, 2.0, 2.0)
-  p := PureScene.localMatrix(s).apply(Vec2(x: 0.0, y: 0.0))
+  p := s.localMatrix().apply(Vec2(x: 0.0, y: 0.0))
   assert {p.x - 10.0}.abs() < 1e-6
   assert {p.y}.abs() < 1e-6
 test "button_click_needs_press_and_over"
-  b := PureScene.button(7, "go", 1, 2, 0.0, 0.0, 10.0, 10.0)
+  b := Node.button(7, "go", 1, 2, 0.0, 0.0, 10.0, 10.0)
-  h1 := PureScene.onPointer(b, psOverPtr(Down, true))
+  h1 := b.onPointer(psOverPtr(Down, true))
   ks := psKinds(h1)
   n1 := h1.events.length()
   id1 := h1.events.at(0).id
-  h2 := PureScene.onPointer(h1.intoNode(), psOverPtr(Up, true))
+  h2 := h1.intoNode().onPointer(psOverPtr(Up, true))
   ks.push(h2.events.at(0).kind)
   ks.push(h2.events.at(1).kind)
   assert n1 == 1
@@ -260,69 +508,173 @@ test "button_click_needs_press_and_over"
   assert h2.events.at(1).id == 7
 test "button_release_elsewhere_no_click"
-  b := PureScene.button(7, "go", 1, 2, 0.0, 0.0, 10.0, 10.0)
+  b := Node.button(7, "go", 1, 2, 0.0, 0.0, 10.0, 10.0)
-  h1 := PureScene.onPointer(b, psOverPtr(Down, true))
+  h1 := b.onPointer(psOverPtr(Down, true))
-  h2 := PureScene.onPointer(h1.intoNode(), psOverPtr(Up, false))
+  h2 := h1.intoNode().onPointer(psOverPtr(Up, false))
   assert h2.events.length() == 1
   assert h2.events.at(0).kind == Release
   assert !psIsPressed(h2.intoNode())
 test "button_drag_off_and_back_one_click"
-  b := PureScene.button(7, "go", 1, 2, 0.0, 0.0, 10.0, 10.0)
+  b := Node.button(7, "go", 1, 2, 0.0, 0.0, 10.0, 10.0)
-  a1 := PureScene.onPointer(b, psOverPtr(Down, true)).intoNode()
+  a1 := b.onPointer(psOverPtr(Down, true)).intoNode()
-  h2 := PureScene.onPointer(a1, psOverPtr(Move, false))
+  h2 := a1.onPointer(psOverPtr(Move, false))
   c2 := psClicks(h2)
-  h3 := PureScene.onPointer(h2.intoNode(), psOverPtr(Move, true))
+  h3 := h2.intoNode().onPointer(psOverPtr(Move, true))
   c3 := psClicks(h3)
-  h4 := PureScene.onPointer(h3.intoNode(), psOverPtr(Up, true))
+  h4 := h3.intoNode().onPointer(psOverPtr(Up, true))
   assert c2 + c3 + psClicks(h4) == 1
 test "on_pointer_hands_back_changed_actor"
-  b := PureScene.button(7, "go", 1, 2, 0.0, 0.0, 10.0, 10.0)
+  b := Node.button(7, "go", 1, 2, 0.0, 0.0, 10.0, 10.0)
-  h := PureScene.onPointer(b, psOverPtr(Down, true))
+  h := b.onPointer(psOverPtr(Down, true))
   assert psIsPressed(h.intoNode())
 test "custom_actor_act_and_draw_dispatch"
   beacon := Beacon(draws: 0)
-  n := PureScene.custom(7, 2.0, 0.0, 8.0, 8.0, beacon)
+  n := Node.custom(7, 2.0, 0.0, 8.0, 8.0, beacon)
-  PureScene.drawTree(io, n, Affine.Identity, Color.White)
+  n.drawTree(io, Affine.Identity, Color.White)
   assert beacon.draws == 1
-  moved := psActed(n, 0.016)
+  moved := n.acted(0.016)
   assert moved.x == 3.0
 test "draw_tree_nested_groups_reaches_custom"
   beacon := Beacon(draws: 0)
-  inner := PureScene.group(2, 0.0, 0.0, 10.0, 10.0, Slice(PureScene.custom(3, 1.0, 1.0, 4.0, 4.0, beacon)))
+  inner := Node.group(2, 0.0, 0.0, 10.0, 10.0, Slice(Node.custom(3, 1.0, 1.0, 4.0, 4.0, beacon)))
-  root := PureScene.group(1, 0.0, 0.0, 10.0, 10.0, Slice(inner))
+  root := Node.group(1, 0.0, 0.0, 10.0, 10.0, Slice(inner))
-  PureScene.drawTree(io, root, Affine.Identity, Color.White)
+  root.drawTree(io, Affine.Identity, Color.White)
   assert beacon.draws == 1
 test "hit_box_and_children_of"
-  s := PureScene.sprite(1, 0, 0.0, 0.0, 10.0, 10.0)
+  s := Node.sprite(1, 0, 0.0, 0.0, 10.0, 10.0)
-  assert PureScene.hit(s, Vec2(x: 5.0, y: 5.0))
+  assert s.hit(Vec2(x: 5.0, y: 5.0))
-  assert !PureScene.hit(s, Vec2(x: 11.0, y: 5.0))
+  assert !s.hit(Vec2(x: 11.0, y: 5.0))
-  assert PureScene.childrenOf(s) == null
+  assert s.children() == null
-  assert PureScene.childrenOf(PureScene.group(2, 0.0, 0.0, 1.0, 1.0, Slice(s))) != null
+  assert Node.group(2, 0.0, 0.0, 1.0, 1.0, Slice(s)).children() != null
 test "button_move_raises_enter_then_exit"
-  b := PureScene.button(7, "go", 1, 2, 0.0, 0.0, 10.0, 10.0)
+  b := Node.button(7, "go", 1, 2, 0.0, 0.0, 10.0, 10.0)
-  h1 := PureScene.onPointer(b, psOverPtr(Move, true))
+  h1 := b.onPointer(psOverPtr(Move, true))
   assert h1.events.length() == 1
   assert h1.events.at(0).kind == Enter
-  h2 := PureScene.onPointer(h1.intoNode(), psOverPtr(Move, false))
+  h2 := h1.intoNode().onPointer(psOverPtr(Move, false))
   assert h2.events.length() == 1
   assert h2.events.at(0).kind == Exit
   assert !psIsPressed(h2.intoNode())
 test "on_pointer_non_button_raises_nothing"
-  s := PureScene.sprite(1, 0, 0.0, 0.0, 10.0, 10.0)
+  s := Node.sprite(1, 0, 0.0, 0.0, 10.0, 10.0)
-  h := PureScene.onPointer(s, psOverPtr(Down, true))
+  h := s.onPointer(psOverPtr(Down, true))
   assert h.events.length() == 0
   assert h.intoNode().id == 1
 test "draw_tree_skips_invisible_custom"
   beacon := Beacon(draws: 0)
-  n := PureScene.custom(7, 0.0, 0.0, 8.0, 8.0, beacon)
+  n := Node.custom(7, 0.0, 0.0, 8.0, 8.0, beacon)
   n2 := Node(..n, visible: false)
-  PureScene.drawTree(io, n2, Affine.Identity, Color.White)
+  n2.drawTree(io, Affine.Identity, Color.White)
   assert beacon.draws == 0
+test "find_hit_nested"
+  r := ttFixture().findHit(Affine.Identity, ttAt(21.0, 1.0))
+  assert ttPathEq(r, ttInts(1, 0))
+test "find_hit_miss"
+  assert ttNoPath(ttFixture().findHit(Affine.Identity, ttAt(200.0, 200.0)))
+test "id_at_paths"
+  t := ttFixture()
+  assert t.idAt(ttInts(1, 0), 0) == 4
+  five := Slice(5)
+  assert t.idAt(five, 0) == -1
+  assert t.idAt(Slice[Int](), 0) == 1
+test "find_path_ids"
+  t := ttFixture()
+  assert ttPathEq(t.findPath(4), ttInts(1, 0))
+  assert ttNoPath(t.findPath(99))
+test "update_runs_actions_and_children"
+  n := ttMovingTree().update(0.5)
+  assert {ttFirstKidX(n) - 5.0}.abs() < 1e-6
+  assert ttFirstKidActions(n) == 1
+test "update_changes_tree_in_place"
+  t := ttMovingTree()
+  n := t.update(0.5)
+  assert ttFirstKidX(n) == 5.0
+  assert ttFirstKidActions(n) == 1
+test "disabled_group_hides_subtree"
+  t := ttSetTouch(ttFixture(), 3, Disabled)
+  r := t.findHit(Affine.Identity, ttAt(21.0, 1.0))
+  assert ttPathEq(r, Slice[Int]())
+test "children_only_group_not_hit_itself"
+  t := ttSetTouch(ttFixture(), 3, ChildrenOnly)
+  r := t.findHit(Affine.Identity, ttAt(28.0, 8.0))
+  assert ttPathEq(r, Slice[Int]())
+test "scale_zero_not_hit"
+  t := ttFixture().modify(2, |a| ttSetScaleX(a))
+  r := t.findHit(Affine.Identity, ttAt(1.0, 1.0))
+  assert ttPathEq(r, Slice[Int]())
+test "topmost_child_wins"
+  kids := Slice(Node.sprite(2, 0, 0.0, 0.0, 10.0, 10.0), Node.sprite(3, 0, 0.0, 0.0, 10.0, 10.0))
+  root := Node.group(1, 0.0, 0.0, 100.0, 100.0, kids)
+  me: Node := root
+  r := me.findHit(Affine.Identity, ttAt(1.0, 1.0))
+  want := Slice(1)
+  assert ttPathEq(r, want)
+test "modify_changes_first_match_only"
+  kids := Slice(Node.sprite(7, 0, 0.0, 0.0, 10.0, 10.0), Node.sprite(7, 0, 0.0, 0.0, 10.0, 10.0))
+  root := Node.group(1, 0.0, 0.0, 100.0, 100.0, kids)
+  me: Node := root
+  n := me.modify(7, |a| ttSetX9(a))
+  assert ttKidX(n, 0) == 9.0
+  assert ttKidX(n, 1) == 0.0
+test "route_child_first_then_group"
+  g := ttButtonRoot()
+  h1 := g.route(ttZero(), 0, Pointer(kind: Down, x: 20.0, y: 20.0, over: true))
+  n1 := h1.events.length()
+  k1 := h1.events.at(0).kind
+  h2 := h1.intoNode().route(ttZero(), 0, Pointer(kind: Up, x: 20.0, y: 20.0, over: true))
+  assert n1 == 1
+  assert k1 == Press
+  assert h2.events.length() == 2
+  assert h2.events.at(0).kind == Release
+  assert h2.events.at(1).kind == Click
+  assert h2.events.at(1).id == 5
+test "stale_path_reaches_group_only"
+  nine := Slice(9)
+  h := ttButtonRoot().route(nine, 0, Pointer(kind: Down, x: 20.0, y: 20.0, over: true))
+  assert h.events.length() == 0
+test "compaction_keeps_order"
+  n := ttCompactTree().update(0.1)
+  acts := ttKid(n).actions
+  assert acts.length() == 2
+  assert ttActKind(acts.at(0)) == 1
+  assert ttActKind(acts.at(1)) == 2
+  assert {ttKid(n).x - 1.0}.abs() < 1e-6
+  assert {ttKid(n).y - 0.1}.abs() < 1e-6
+  assert {ttKid(n).rotation - 1.02}.abs() < 1e-6
+  # The next step advances the right survivors: MoveBy 0.1 -> 0.6, RotateBy 0.1 -> 0.6.
+  m := n.update(0.5)
+  acts2 := ttKid(m).actions
+  assert acts2.length() == 2
+  assert ttActKind(acts2.at(0)) == 1
+  assert ttActKind(acts2.at(1)) == 2
+  assert actElapsed(acts2.at(0)) == 0.6
+  assert {ttKid(m).y - 0.6}.abs() < 1e-6
+  assert {ttKid(m).rotation - 1.12}.abs() < 1e-6
+  assert {ttKid(m).x - 1.0}.abs() < 1e-6
+test "update_runs_custom_actor_act"
+  c := Node.custom(9, 1.0, 0.0, 4.0, 4.0, TtStepper(ticks: 0))
+  n := Node.group(1, 0.0, 0.0, 10.0, 10.0, Slice(c)).update(0.016)
+  assert ttFirstKidX(n) == 2.0

plum-std/game/pure/SceneInput.plum CHANGED Viewed

@@ -10,7 +10,6 @@ import std/game/Affine
 import std/game/Game
 import std/game/pure/Actions
 import std/game/pure/PureScene
-import std/game/pure/SceneTree
 # The root of a pure scene tree, its camera and pointer capture. A Stage is an
 # unique value: `input` and `frame` take it, change it in place and hand it back
@@ -25,9 +24,33 @@ enum InputKind =
   | PointerMove
 # A pointer input in screen coordinates.
-record Input(kind: InputKind, x: Float, y: Float)
+record Input(kind: InputKind, x: Float, y: Float) =
+  # This frame's pointer inputs from the host mouse: a press, a release, or a
+  # move. `wasDown` is whether the button was down last frame.
+  fun poll(io: Io, wasDown: Bool) -> Slice[Input] =
+    m := io.mousePos()
+    down := io.isMouseDown(0)
+    out := Slice[Input]()
+    if down && !wasDown
+      out.push(Input(kind: PointerDown, x: m.x, y: m.y))
+    else if !down && wasDown
+      out.push(Input(kind: PointerUp, x: m.x, y: m.y))
+    else
+      out.push(Input(kind: PointerMove, x: m.x, y: m.y))
+    out
-record Capture(path: Slice[Int], id: Int)
+record Capture(path: Slice[Int], id: Int) =
+  # Whether the captured path is `p` or leads into it (the pointer is over the actor).
+  fun within(self, p: Slice[Int]) -> Bool =
+    a := self.path
+    if a.length() > p.length()
+      return false
+    for i := range a.length()
+      if a.at(i) != p.at(i)
+        return false
+    true
 record StageHandled(stage: Stage, events: Slice[UiEvent]) =
@@ -38,6 +61,10 @@ record StageHandled(stage: Stage, events: Slice[UiEvent]) =
 record Stage(root: Node, camera: Affine, captured: Capture?) =
+  # A stage over `root` with no camera transform and nothing captured.
+  fun create(root: Node) -> Stage =
+    Stage(root: root, camera: Affine.Identity, captured: null)
   # Handles one input: routes it, returns the new stage and the events raised.
   fun input(self, e: Input) -> StageHandled =
     none := Slice[UiEvent]()
@@ -47,21 +74,21 @@ record Stage(root: Node, camera: Affine, captured: Capture?) =
     world := Vec2(x: e.x, y: e.y)
     if q := inv
       world = q.apply(world)
-    hit := SceneTree.findHit(self.root, Affine.Identity, world)
+    hit := self.root.findHit(Affine.Identity, world)
     # A capture is valid only while its path still leads to its actor.
     cap: Capture? := null
     if c := self.captured
-      if SceneTree.idAt(self.root, c.path, 0) == c.id
+      if self.root.idAt(c.path, 0) == c.id
         cap = c
     if e.kind == PointerDown
       if p := hit
-        id := SceneTree.idAt(self.root, p, 0)
+        id := self.root.idAt(p, 0)
         return self.deliver(p, Pointer(kind: Down, x: world.x, y: world.y, over: true), Capture(path: p, id: id))
       return StageHandled(stage: self.withCapture(null), events: none)
     if c := cap
       over := false
       if p := hit
-        over = inputIsPrefix(c.path, p)
+        over = c.within(p)
       if e.kind == PointerUp
         return self.deliver(c.path, Pointer(kind: Up, x: world.x, y: world.y, over: over), null)
       return self.deliver(c.path, Pointer(kind: Move, x: world.x, y: world.y, over: over), c)
@@ -78,7 +105,7 @@ record Stage(root: Node, camera: Affine, captured: Capture?) =
     events := Slice[UiEvent]()
     match self
       Stage(root, camera, _) =>
-        r := SceneTree.routeInto(root, path, 0, p, events)
+        r := root.routeInto(path, 0, p, events)
         StageHandled(stage: Stage(root: r, camera: camera, captured: c), events: events)
   # Handles the inputs in order, then advances the tree by `dt`.
@@ -91,52 +118,25 @@ record Stage(root: Node, camera: Affine, captured: Capture?) =
         out.push(h.events.at(j))
       cur = h.intoStage()
     match cur
-      Stage(root, camera, captured) =>
-        StageHandled(stage: Stage(root: SceneTree.update(root, dt), camera: camera, captured: captured), events: out)
+      Stage(root, camera, captured) => StageHandled(stage: Stage(root: root.update(dt), camera: camera, captured: captured), events: out)
   # Paints the tree through the camera.
   fun draw(self, io: Io) =
-    PureScene.drawTree(io, self.root, self.camera, Color.White)
+    self.root.drawTree(io, self.camera, Color.White)
-fun inputIsPrefix(a: Slice[Int], b: Slice[Int]) -> Bool =
-  if a.length() > b.length()
-    return false
-  for i := range a.length()
-    if a.at(i) != b.at(i)
-      return false
-  true
-primitive SceneInput =
-  fun stage(root: Node) -> Stage =
-    Stage(root: root, camera: Affine.Identity, captured: null)
-  # This frame's pointer inputs from the host mouse: a press, a release, or a
-  # move. `wasDown` is whether the button was down last frame.
-  fun pollPointer(io: Io, wasDown: Bool) -> Slice[Input] =
-    m := io.mousePos()
-    down := io.isMouseDown(0)
-    out := Slice[Input]()
-    if down && !wasDown
-      out.push(Input(kind: PointerDown, x: m.x, y: m.y))
-    else if !down && wasDown
-      out.push(Input(kind: PointerUp, x: m.x, y: m.y))
-    else
-      out.push(Input(kind: PointerMove, x: m.x, y: m.y))
-    out
 fun inBtnTree() -> Node =
-  b: Node := PureScene.button(5, "Go", 0, 1, 10.0, 10.0, 100.0, 40.0)
+  b: Node := Node.button(5, "Go", 0, 1, 10.0, 10.0, 100.0, 40.0)
   kids := Slice(b)
-  g: Node := PureScene.group(1, 0.0, 0.0, 800.0, 600.0, kids)
+  g: Node := Node.group(1, 0.0, 0.0, 800.0, 600.0, kids)
   g
 fun inBtnPressed(s: Stage) -> Bool =
-  if k := PureScene.childrenOf(s.root)
+  if k := s.root.children()
     return psIsPressed(k.at(0))
   false
 fun inBtnOver(s: Stage) -> Bool =
-  if k := PureScene.childrenOf(s.root)
+  if k := s.root.children()
     return inOverOf(k.at(0))
   false
@@ -162,15 +162,15 @@ fun inClicks(events: Slice[UiEvent]) -> Int =
   n
 fun inXformTree() -> Node =
-  b: Node := PureScene.button(5, "Go", 0, 1, 10.0, 10.0, 100.0, 40.0)
+  b: Node := Node.button(5, "Go", 0, 1, 10.0, 10.0, 100.0, 40.0)
   kids := Slice(b)
-  g := PureScene.group(1, 100.0, 0.0, 800.0, 600.0, kids)
+  g := Node.group(1, 100.0, 0.0, 800.0, 600.0, kids)
   g2 := Node(..g, rotation: 1.5707963267948966, scaleX: 2.0, scaleY: 2.0)
   me: Node := g2
   me
 test "press_sets_capture"
-  h := SceneInput.stage(inBtnTree()).input(inDown(20.0, 20.0))
+  h := Stage.create(inBtnTree()).input(inDown(20.0, 20.0))
   assert h.events.length() == 1
   assert h.events.at(0).kind == Press
   assert h.events.at(0).id == 5
@@ -180,7 +180,7 @@ test "press_sets_capture"
     assert false
 test "release_elsewhere_no_click"
-  h1 := SceneInput.stage(inBtnTree()).input(inDown(20.0, 20.0))
+  h1 := Stage.create(inBtnTree()).input(inDown(20.0, 20.0))
   h2 := h1.intoStage().input(inUp(500.0, 500.0))
   assert h2.events.length() == 1
   assert h2.events.at(0).kind == Release
@@ -189,7 +189,7 @@ test "release_elsewhere_no_click"
   assert !inBtnPressed(h2.stage)
 test "drag_off_and_back_one_click"
-  h1 := SceneInput.stage(inBtnTree()).input(inDown(20.0, 20.0))
+  h1 := Stage.create(inBtnTree()).input(inDown(20.0, 20.0))
   c1 := inClicks(h1.events)
   h2 := h1.intoStage().input(inMove(500.0, 500.0))
   c2 := inClicks(h2.events)
@@ -199,15 +199,15 @@ test "drag_off_and_back_one_click"
   assert c1 + c2 + c3 + inClicks(h4.events) == 1
 test "stale_capture_dropped"
-  h1 := SceneInput.stage(inBtnTree()).input(inDown(20.0, 20.0))
+  h1 := Stage.create(inBtnTree()).input(inDown(20.0, 20.0))
-  empty: Node := PureScene.group(1, 0.0, 0.0, 800.0, 600.0, Slice[Node]())
+  empty: Node := Node.group(1, 0.0, 0.0, 800.0, 600.0, Slice[Node]())
   swapped := Stage(root: empty, camera: h1.stage.camera, captured: h1.stage.captured)
   h2 := swapped.input(inUp(20.0, 20.0))
   assert h2.events.length() == 0
   assert h2.stage.captured == null
 test "hover_without_press_routes_move"
-  h := SceneInput.stage(inBtnTree()).input(inMove(20.0, 20.0))
+  h := Stage.create(inBtnTree()).input(inMove(20.0, 20.0))
   assert inBtnOver(h.stage)
   assert h.stage.captured == null
@@ -220,20 +220,20 @@ test "camera_maps_screen_to_world"
   assert h.events.at(0).id == 5
 test "frame_handles_inputs_then_updates"
-  spr := PureScene.sprite(6, 0, 300.0, 300.0, 10.0, 10.0)
+  spr := Node.sprite(6, 0, 300.0, 300.0, 10.0, 10.0)
-  acts := Slice(Actions.moveBy(10.0, 0.0, 1.0))
+  acts := Slice(Action.moveBy(10.0, 0.0, 1.0))
   spr2 := Node(..spr, actions: acts)
-  b: Node := PureScene.button(5, "Go", 0, 1, 10.0, 10.0, 100.0, 40.0)
+  b: Node := Node.button(5, "Go", 0, 1, 10.0, 10.0, 100.0, 40.0)
   sp: Node := spr2
   kids := Slice(b, sp)
-  root: Node := PureScene.group(1, 0.0, 0.0, 800.0, 600.0, kids)
+  root: Node := Node.group(1, 0.0, 0.0, 800.0, 600.0, kids)
   ins := Slice(inDown(20.0, 20.0), inUp(20.0, 20.0))
-  h := SceneInput.stage(root).frame(0.5, ins)
+  h := Stage.create(root).frame(0.5, ins)
   assert h.events.length() == 3
   assert h.events.at(0).kind == Press
   assert h.events.at(1).kind == Release
   assert h.events.at(2).kind == Click
-  if k := PureScene.childrenOf(h.stage.root)
+  if k := h.stage.root.children()
     assert {k.at(1).x - 305.0}.abs() < 0.000001
   else
     assert false
@@ -241,7 +241,7 @@ test "frame_handles_inputs_then_updates"
 test "hit_and_route_agree_for_rotated_scaled_group"
   # local (20,20) in the button's parent maps to world (100 - 2*20, 2*20) = (60,40)
   t := inXformTree()
-  hit := SceneTree.findHit(t, Affine.Identity, Vec2(x: 60.0, y: 40.0))
+  hit := t.findHit(Affine.Identity, Vec2(x: 60.0, y: 40.0))
   assert hit != null
   h := Stage(root: t, camera: Affine.Identity, captured: null).input(Input(kind: PointerDown, x: 60.0, y: 40.0))
   assert h.events.length() == 1
@@ -250,6 +250,6 @@ test "hit_and_route_agree_for_rotated_scaled_group"
   assert miss.events.length() == 0
 test "input_changes_stage_in_place"
-  h := SceneInput.stage(inBtnTree()).input(Input(kind: PointerDown, x: 20.0, y: 20.0))
+  h := Stage.create(inBtnTree()).input(Input(kind: PointerDown, x: 20.0, y: 20.0))
   assert h.stage.captured != null
   assert inBtnPressed(h.stage)

plum-std/game/pure/SceneTree.plum DELETED Viewed

@@ -1,350 +0,0 @@
-module std
-import std/Int
-import std/Float
-import std/Slice
-import std/Str
-import std/game/Vec2
-import std/game/Affine
-import std/game/pure/Actions
-import std/game/pure/PureScene
-fun treeActorOf(n: Node) -> Actor? =
-  match n.kind
-    Custom(actor) => actor
-    _ => null
-fun treePrepend(i: Int, rest: Slice[Int]) -> Slice[Int] =
-  out := Slice(i)
-  for j := range rest.length()
-    out.push(rest.at(j))
-  out
-primitive SceneTree =
-  # A Custom node's actor acts on it; every other node is itself.
-  fun act(n: Node, dt: Float) -> Node =
-    if actor := treeActorOf(n)
-      return actor.act(n, dt)
-    n
-  # The node after `dt` seconds: a Custom actor's own `act`, then its actions on its pose,
-  # then every child. The tree is changed in place and handed back.
-  fun update(a: Node, dt: Float) -> Node =
-    b := SceneTree.act(a, dt)
-    r := Actions.stepAll(Pose(x: b.x, y: b.y, rotation: b.rotation, scaleX: b.scaleX, scaleY: b.scaleY), b.actions, dt)
-    b = Node(..b, x: r.pose.x, y: r.pose.y, rotation: r.pose.rotation, scaleX: r.pose.scaleX, scaleY: r.pose.scaleY)
-    match b.kind
-      Group(ks) =>
-        _ := ks.mapInPlace(|k| SceneTree.update(k, dt))
-      _ => 0
-    b
-  # The path (child indexes from `a`) to the topmost actor under `p`, which is
-  # in the coordinates of `a`'s parent; `parent` is that parent's stage matrix.
-  fun findHit(a: Node, parent: Affine, p: Vec2) -> Slice[Int]? =
-    if !a.visible || a.touchable == Disabled
-      return null
-    m := parent * PureScene.localMatrix(a)
-    inv := m.invert()
-    if inv == null
-      return null
-    lp := Vec2(x: 0.0, y: 0.0)
-    if q := inv
-      lp = q.apply(p)
-    match a.kind
-      Group(ks) =>
-        i := ks.length() - 1
-        while i >= 0
-          sub := SceneTree.findHit(ks.at(i), m, p)
-          if s := sub
-            return treePrepend(i, s)
-          i = i - 1
-      _ => 0
-    if PureScene.hit(a, lp)
-      return Slice[Int]()
-    null
-  # The id of the actor at `path` below `a`, or -1 if the path leads nowhere.
-  fun idAt(a: Node, path: Slice[Int], depth: Int) -> Int =
-    if depth >= path.length()
-      return a.id
-    match a.kind
-      Group(ks) =>
-        i := path.at(depth)
-        if i >= 0 && i < ks.length()
-          return SceneTree.idAt(ks.at(i), path, depth + 1)
-      _ => 0
-    -1
-  # The path to the first actor with `id`, depth first; null if none.
-  fun findPath(a: Node, id: Int) -> Slice[Int]? =
-    if a.id == id
-      return Slice[Int]()
-    match a.kind
-      Group(ks) =>
-        for i := range ks.length()
-          sub := SceneTree.findPath(ks.at(i), id)
-          if s := sub
-            return treePrepend(i, s)
-      _ => 0
-    null
-  # The tree where the first actor with `id` is replaced by `f` of it.
-  fun modify(a: Node, id: Int, f: fn(Node) -> Node) -> Node =
-    path := SceneTree.findPath(a, id)
-    if p := path
-      return SceneTree.modifyAt(a, p, 0, f)
-    a
-  fun modifyAt(a: Node, path: Slice[Int], depth: Int, f: fn(Node) -> Node) -> Node =
-    if depth >= path.length()
-      return f(a)
-    match a.kind
-      Group(ks) =>
-        i := path.at(depth)
-        if i >= 0 && i < ks.length()
-          c := ks.takeAt(i)
-          ks.putAt(i, SceneTree.modifyAt(c, path, depth + 1, f))
-      _ => 0
-    a
-  # Delivers `e` (in the coordinates of `a`'s parent) along `path`: the child on
-  # the path first, then `a` itself. A path that runs out reaches the deepest
-  # actor it can.
-  fun route(a: Node, path: Slice[Int], depth: Int, e: Pointer) -> Handled =
-    events := Slice[UiEvent]()
-    r := SceneTree.routeInto(a, path, depth, e, events)
-    Handled(node: r, events: events)
-  # `route`, appending the raised events to `events` and returning the actor.
-  fun routeInto(a: Node, path: Slice[Int], depth: Int, e: Pointer, events: Slice[UiEvent]) -> Node =
-    lp := Vec2(x: e.x, y: e.y)
-    inv := PureScene.localMatrix(a).invert()
-    if q := inv
-      lp = q.apply(lp)
-    local := Pointer(kind: e.kind, x: lp.x, y: lp.y, over: e.over)
-    if depth < path.length()
-      match a.kind
-        Group(ks) =>
-          i := path.at(depth)
-          if i >= 0 && i < ks.length()
-            c := ks.takeAt(i)
-            ks.putAt(i, SceneTree.routeInto(c, path, depth + 1, local, events))
-        _ => 0
-    h := PureScene.onPointer(a, local)
-    for j := range h.events.length()
-      events.push(h.events.at(j))
-    h.intoNode()
-fun ttFixture() -> Node =
-  inner := Slice(PureScene.sprite(4, 0, 0.0, 0.0, 5.0, 5.0))
-  kids := Slice(PureScene.sprite(2, 0, 0.0, 0.0, 10.0, 10.0), PureScene.group(3, 20.0, 0.0, 10.0, 10.0, inner))
-  root := PureScene.group(1, 0.0, 0.0, 100.0, 100.0, kids)
-  me: Node := root
-  me
-fun ttNoPath(r: Slice[Int]?) -> Bool =
-  r == null
-fun ttPathEq(r: Slice[Int]?, want: Slice[Int]) -> Bool =
-  if p := r
-    if p.length() != want.length()
-      return false
-    for i := range p.length()
-      if p.at(i) != want.at(i)
-        return false
-    return true
-  false
-fun ttInts(a: Int, b: Int) -> Slice[Int] =
-  out := Slice(a, b)
-  out
-fun ttAt(x: Float, y: Float) -> Vec2 =
-  Vec2(x: x, y: y)
-fun ttMovingTree() -> Node =
-  s := PureScene.sprite(2, 0, 0.0, 0.0, 10.0, 10.0)
-  s2 := Node(..s, actions: Slice(Actions.moveBy(10.0, 0.0, 1.0)))
-  kids := Slice(s2)
-  root := PureScene.group(1, 0.0, 0.0, 100.0, 100.0, kids)
-  me: Node := root
-  me
-fun ttFirstKidX(a: Node) -> Float =
-  match a.kind
-    Group(k) =>
-      return k.at(0).x
-    _ => 0
-  0.0 - 1.0
-fun ttFirstKidActions(a: Node) -> Int =
-  match a.kind
-    Group(k) =>
-      return k.at(0).actions.length()
-    _ => 0
-  0 - 1
-fun ttSetTouch(t: Node, id: Int, tc: Touchable) -> Node =
-  SceneTree.modify(t, id, |a| ttSetTouchOf(a, tc))
-fun ttSetTouchOf(a: Node, tc: Touchable) -> Node =
-  Node(..a, touchable: tc)
-fun ttSetScaleX(a: Node) -> Node =
-  Node(..a, scaleX: 0.0)
-fun ttSetX9(a: Node) -> Node =
-  Node(..a, x: 9.0)
-fun ttKidX(a: Node, i: Int) -> Float =
-  match a.kind
-    Group(k) =>
-      return k.at(i).x
-    _ => 0
-  0.0 - 1.0
-fun ttButtonRoot() -> Node =
-  kids := Slice(PureScene.button(5, "Go", 0, 1, 10.0, 10.0, 100.0, 40.0))
-  root := PureScene.group(1, 0.0, 0.0, 800.0, 600.0, kids)
-  me: Node := root
-  me
-fun ttZero() -> Slice[Int] =
-  out := Slice(0)
-  out
-# Five actions on one sprite: the 1st, 3rd and 5th finish in the first 0.1s step,
-# the 2nd (MoveBy) and 4th (RotateBy) keep running.
-fun ttCompactTree() -> Node =
-  s := PureScene.sprite(2, 0, 0.0, 0.0, 10.0, 10.0)
-  s2 := Node(..s, actions: Slice(Actions.moveBy(1.0, 0.0, 0.1), Actions.moveBy(0.0, 10.0, 10.0), Actions.rotateBy(1.0, 0.1), Actions.rotateBy(2.0, 10.0), Actions.delay(0.1)))
-  kids := Slice(s2)
-  root := PureScene.group(1, 0.0, 0.0, 100.0, 100.0, kids)
-  me: Node := root
-  me
-fun ttKid(a: Node) -> Node =
-  match a.kind
-    Group(k) =>
-      return k.at(0)
-    _ => 0
-  none: Node := PureScene.sprite(0, 0, 0.0, 0.0, 0.0, 0.0)
-  none
-# 1 MoveBy, 2 RotateBy, 3 Delay, 0 anything else.
-fun ttActKind(a: Action) -> Int =
-  match a.kind
-    MoveBy(_, _, _) => 1
-    RotateBy(_, _) => 2
-    Delay(_) => 3
-    _ => 0
-# Adds 1.0 to its node's x on every act.
-record TtStepper(Actor, ticks: Int) =
-  override fun act(self, n: Node, dt: Float) -> Node =
-    Node(..n, x: n.x + 1.0)
-test "find_hit_nested"
-  r := SceneTree.findHit(ttFixture(), Affine.Identity, ttAt(21.0, 1.0))
-  assert ttPathEq(r, ttInts(1, 0))
-test "find_hit_miss"
-  assert ttNoPath(SceneTree.findHit(ttFixture(), Affine.Identity, ttAt(200.0, 200.0)))
-test "id_at_paths"
-  t := ttFixture()
-  assert SceneTree.idAt(t, ttInts(1, 0), 0) == 4
-  five := Slice(5)
-  assert SceneTree.idAt(t, five, 0) == -1
-  assert SceneTree.idAt(t, Slice[Int](), 0) == 1
-test "find_path_ids"
-  t := ttFixture()
-  assert ttPathEq(SceneTree.findPath(t, 4), ttInts(1, 0))
-  assert ttNoPath(SceneTree.findPath(t, 99))
-test "update_runs_actions_and_children"
-  n := SceneTree.update(ttMovingTree(), 0.5)
-  assert {ttFirstKidX(n) - 5.0}.abs() < 1e-6
-  assert ttFirstKidActions(n) == 1
-test "update_changes_tree_in_place"
-  t := ttMovingTree()
-  n := SceneTree.update(t, 0.5)
-  assert ttFirstKidX(n) == 5.0
-  assert ttFirstKidActions(n) == 1
-test "disabled_group_hides_subtree"
-  t := ttSetTouch(ttFixture(), 3, Disabled)
-  r := SceneTree.findHit(t, Affine.Identity, ttAt(21.0, 1.0))
-  assert ttPathEq(r, Slice[Int]())
-test "children_only_group_not_hit_itself"
-  t := ttSetTouch(ttFixture(), 3, ChildrenOnly)
-  r := SceneTree.findHit(t, Affine.Identity, ttAt(28.0, 8.0))
-  assert ttPathEq(r, Slice[Int]())
-test "scale_zero_not_hit"
-  t := SceneTree.modify(ttFixture(), 2, |a| ttSetScaleX(a))
-  r := SceneTree.findHit(t, Affine.Identity, ttAt(1.0, 1.0))
-  assert ttPathEq(r, Slice[Int]())
-test "topmost_child_wins"
-  kids := Slice(PureScene.sprite(2, 0, 0.0, 0.0, 10.0, 10.0), PureScene.sprite(3, 0, 0.0, 0.0, 10.0, 10.0))
-  root := PureScene.group(1, 0.0, 0.0, 100.0, 100.0, kids)
-  me: Node := root
-  r := SceneTree.findHit(me, Affine.Identity, ttAt(1.0, 1.0))
-  want := Slice(1)
-  assert ttPathEq(r, want)
-test "modify_changes_first_match_only"
-  kids := Slice(PureScene.sprite(7, 0, 0.0, 0.0, 10.0, 10.0), PureScene.sprite(7, 0, 0.0, 0.0, 10.0, 10.0))
-  root := PureScene.group(1, 0.0, 0.0, 100.0, 100.0, kids)
-  me: Node := root
-  n := SceneTree.modify(me, 7, |a| ttSetX9(a))
-  assert ttKidX(n, 0) == 9.0
-  assert ttKidX(n, 1) == 0.0
-test "route_child_first_then_group"
-  g := ttButtonRoot()
-  h1 := SceneTree.route(g, ttZero(), 0, Pointer(kind: Down, x: 20.0, y: 20.0, over: true))
-  n1 := h1.events.length()
-  k1 := h1.events.at(0).kind
-  h2 := SceneTree.route(h1.intoNode(), ttZero(), 0, Pointer(kind: Up, x: 20.0, y: 20.0, over: true))
-  assert n1 == 1
-  assert k1 == Press
-  assert h2.events.length() == 2
-  assert h2.events.at(0).kind == Release
-  assert h2.events.at(1).kind == Click
-  assert h2.events.at(1).id == 5
-test "stale_path_reaches_group_only"
-  nine := Slice(9)
-  h := SceneTree.route(ttButtonRoot(), nine, 0, Pointer(kind: Down, x: 20.0, y: 20.0, over: true))
-  assert h.events.length() == 0
-test "compaction_keeps_order"
-  n := SceneTree.update(ttCompactTree(), 0.1)
-  acts := ttKid(n).actions
-  assert acts.length() == 2
-  assert ttActKind(acts.at(0)) == 1
-  assert ttActKind(acts.at(1)) == 2
-  assert {ttKid(n).x - 1.0}.abs() < 1e-6
-  assert {ttKid(n).y - 0.1}.abs() < 1e-6
-  assert {ttKid(n).rotation - 1.02}.abs() < 1e-6
-  # The next step advances the right survivors: MoveBy 0.1 -> 0.6, RotateBy 0.1 -> 0.6.
-  m := SceneTree.update(n, 0.5)
-  acts2 := ttKid(m).actions
-  assert acts2.length() == 2
-  assert ttActKind(acts2.at(0)) == 1
-  assert ttActKind(acts2.at(1)) == 2
-  assert actElapsed(acts2.at(0)) == 0.6
-  assert {ttKid(m).y - 0.6}.abs() < 1e-6
-  assert {ttKid(m).rotation - 1.12}.abs() < 1e-6
-  assert {ttKid(m).x - 1.0}.abs() < 1e-6
-test "update_runs_custom_actor_act"
-  c := PureScene.custom(9, 1.0, 0.0, 4.0, 4.0, TtStepper(ticks: 0))
-  n := SceneTree.update(PureScene.group(1, 0.0, 0.0, 10.0, 10.0, Slice(c)), 0.016)
-  assert ttFirstKidX(n) == 2.0

plum-wasm-codegen/tests/fusion_alloc_test.rs CHANGED Viewed

@@ -219,8 +219,8 @@ fn list_pipeline_loop_has_no_cons_alloc() {
     assert_eq!(a, expected(100));
 }
-/// `Picture.draw(io, s.render())` in the functional component game fuses so no
+/// `s.render().draw(io)` in the functional component game fuses so no
-/// SceneNode / Transform / List cell is built per frame: `picDraw` / `picDrawKids` fuse
+/// SceneNode / Transform / List cell is built per frame: `SceneNode.drawWith` / `drawKids` fuse
 /// with `State.render`, its `renderShip` / `renderHud` / `renderOverlay` parts and the
 /// `List.map(|o| o.render(..))` children (each `render` resolved by its receiver type).
 #[test]
@@ -230,12 +230,12 @@ fn state_view_draw_has_no_scenenode_alloc() {
     say(format!("state_view: fusion notes {ns:?}"));
     let w = compile(&g, true);
     let fns = functions(&w);
-    // Fused fns: every `picDraw$..` / `picDrawKids$..` (`picDraw$render$0`, `picDrawKids$map$c5$0`, ..).
+    // Fused fns: every `drawWith$..` / `drawKids$..` (`drawWith$render$0`, `drawKids$map$c5$0`, ..).
-    let isFused = |n: &str| n.starts_with("picDraw$") || n.starts_with("picDrawKids$");
+    let isFused = |n: &str| n.starts_with("drawWith$") || n.starts_with("drawKids$");
     let fused: Vec<&FnInfo> = fns.iter().filter(|f| isFused(&f.name)).collect();
     let names: Vec<&str> = fused.iter().map(|f| f.name.as_str()).collect();
     say(format!("state_view: fused fns {names:?}"));
-    assert!(names.contains(&"picDraw$render$0"), "draw(render(s)) did not fuse; notes: {ns:?}");
+    assert!(names.contains(&"drawWith$render$0"), "draw(render(s)) did not fuse; notes: {ns:?}");
     // Every part of the picture is fused in: no fused fn still calls a part's builder.
     let parts = ["State.render", "State.renderShip", "State.renderHud", "State.renderOverlay", "Orb.render", "Mine.render", "Star.render", "Ship.render", "State.lifeIcons", "List[Orb].map", "List[Mine].map", "List[Star].map"];
     for f in &fused {
@@ -249,7 +249,7 @@ fn state_view_draw_has_no_scenenode_alloc() {
     }
     // struct types are unnamed in the wasm name section, so assert no `struct.new` at all,
     // except (a) the game-over panel `renderPanel`, whose button subtree is a genuinely
-    // shared result (`picBounds`, then `picDraw`), and (b) the constant Anim trees the ship
+    // shared result (`boundsWith`, then `drawWith`), and (b) the constant Anim trees the ship
     // and the title rebuild per frame (`Anim.at` on a just-built Anim is not one match).
     let exempt = |f: &FnInfo| f.name.contains("renderPanel") || f.name.contains("renderTitle") || f.calls.iter().any(|c| c == "Anim.at");
     let mut exemptAllocs = 0;