Carry a box in a move slot, not a translation

A slot now holds the box its contents are placed within, in the coordinates
of the slot it names, and `prelude.wgsl` composes the chain with `within`
instead of adding a delta. A translation is the special case where the box
has its parent's relative extent, so every caller passes
`UiRegion::FULL.offset(delta)` and nothing changes on screen yet: 42 tests
pass and `tabs` at 1920x1200 is byte-identical.

`Moves::resolve` takes the region to compose rather than returning a sum, so
the CPU walk is the same operation the shader performs.

Measured against the translate slot on the same binary with
`tests/chain_cost.rs`, 200k instances: +0.6% at depth 1, +0.5% at 2, +0.8% at
4, then +9.6% at 8 and +32.2% at 64. Free at the depth opt-in slots produce,
which is the next commit; the per-level cost was always the dependent load
rather than the arithmetic.

The identity is `UiRegion::FULL` rather than zero, which `MoveOffset`'s
comment says beside the `Zeroable` that `Pod` requires: a zeroed entry is a
box of no extent and collapses its subtree to a point.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

core/src/render/data.rs

@@ -65,13 +65,16 @@ impl MoveIdx {
     }
 }
 
-/// One link of the chain a primitive's position is resolved through: a
-/// translation in physical pixels, and the slot it is relative to. Moving a
-/// subtree writes its own slot and nothing else.
+/// One link of the chain a primitive's position is resolved through: the box
+/// its contents are placed within, given in the coordinates of the slot it
+/// names. Moving or resizing a subtree writes its own slot and nothing else.
+///
+/// The identity is `UiRegion::FULL`, not zero: a zeroed entry is a box of no
+/// extent, which collapses everything under it to a point.
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
 pub struct MoveOffset {
-    pub delta: Vec2,
+    pub region: UiRegion,
     pub parent: MoveIdx,
 }
 
@@ -81,7 +84,7 @@ unsafe impl bytemuck::Zeroable for MoveOffset {}
 impl MoveOffset {
     pub fn root(parent: MoveIdx) -> Self {
         Self {
-            delta: Vec2::ZERO,
+            region: UiRegion::FULL,
             parent,
         }
     }

core/src/render/shader/prelude.wgsl

@@ -21,28 +21,45 @@ struct Mask {
 }
 
 struct MoveOffset {
-    delta: vec2<f32>,
+    x: UiSpan,
+    y: UiSpan,
     parent: u32,
 }
 
+struct Region {
+    x: UiSpan,
+    y: UiSpan,
+}
+
 const MOVE_NONE: u32 = 4294967295u;
 // Keep in step with `iris_core::CHAIN_LIMIT`. It bounds a malformed cycle
 // rather than any real tree, and the CPU walk uses the same number so both
 // resolve a deep one the same way.
 const CHAIN_LIMIT: u32 = 64u;
 
-fn resolve_move(idx: u32) -> vec2<f32> {
-    var total = vec2<f32>(0.0, 0.0);
+fn scalar_within(s: UiScalar, p: UiSpan) -> UiScalar {
+    return UiScalar(
+        mix(p.start.rel, p.end.rel, s.rel),
+        s.abs + mix(p.start.abs, p.end.abs, s.rel),
+    );
+}
+
+fn span_within(s: UiSpan, p: UiSpan) -> UiSpan {
+    return UiSpan(scalar_within(s.start, p), scalar_within(s.end, p));
+}
+
+fn resolve_move(idx: u32, local: Region) -> Region {
+    var r = local;
     var at = idx;
     for (var step = 0u; step < CHAIN_LIMIT; step++) {
         if at == MOVE_NONE {
             break;
         }
         let entry = move_offsets[at];
-        total += entry.delta;
+        r = Region(span_within(r.x, entry.x), span_within(r.y, entry.y));
         at = entry.parent;
     }
-    return total;
+    return r;
 }
 
 struct UiSpan {
@@ -81,14 +98,18 @@ fn vs_main(
 ) -> VertexOutput {
     var out: VertexOutput;
 
-    let top_left_rel = vec2(in.x_start.x, in.y_start.x);
-    let top_left_abs = vec2(in.x_start.y, in.y_start.y);
-    let bot_right_rel = vec2(in.x_end.x, in.y_end.x);
-    let bot_right_abs = vec2(in.x_end.y, in.y_end.y);
+    let local = Region(
+        UiSpan(UiScalar(in.x_start.x, in.x_start.y), UiScalar(in.x_end.x, in.x_end.y)),
+        UiSpan(UiScalar(in.y_start.x, in.y_start.y), UiScalar(in.y_end.x, in.y_end.y)),
+    );
+    let r = resolve_move(in.move_idx, local);
+    let top_left_rel = vec2(r.x.start.rel, r.y.start.rel);
+    let top_left_abs = vec2(r.x.start.abs, r.y.start.abs);
+    let bot_right_rel = vec2(r.x.end.rel, r.y.end.rel);
+    let bot_right_abs = vec2(r.x.end.abs, r.y.end.abs);
 
-    let moved = resolve_move(in.move_idx);
-    let top_left = floor(top_left_rel * window.dim) + floor(top_left_abs + moved);
-    let bot_right = floor(bot_right_rel * window.dim) + floor(bot_right_abs + moved);
+    let top_left = floor(top_left_rel * window.dim) + floor(top_left_abs);
+    let bot_right = floor(bot_right_rel * window.dim) + floor(bot_right_abs);
     let size = bot_right - top_left;
 
     let uv = vec2<f32>(
@@ -111,16 +132,16 @@ fn masked(in: VertexOutput, color: vec4<f32>) -> vec4<f32> {
         return color;
     }
     let mask = masks[in.mask_idx];
-    let tl = vec2(mask.x.start.rel, mask.y.start.rel);
-    let tl_abs = vec2(mask.x.start.abs, mask.y.start.abs);
-    let br = vec2(mask.x.end.rel, mask.y.end.rel);
-    let br_abs = vec2(mask.x.end.abs, mask.y.end.abs);
-
     // Its own chain, not the drawn primitive's, so a stationary viewport
     // clips content that moves inside it.
-    let moved = resolve_move(mask.move_idx);
-    let top_left = floor(tl * window.dim) + floor(tl_abs + moved);
-    let bot_right = floor(br * window.dim) + floor(br_abs + moved);
+    let m = resolve_move(mask.move_idx, Region(mask.x, mask.y));
+    let tl = vec2(m.x.start.rel, m.y.start.rel);
+    let tl_abs = vec2(m.x.start.abs, m.y.start.abs);
+    let br = vec2(m.x.end.rel, m.y.end.rel);
+    let br_abs = vec2(m.x.end.abs, m.y.end.abs);
+
+    let top_left = floor(tl * window.dim) + floor(tl_abs);
+    let bot_right = floor(br * window.dim) + floor(br_abs);
     let pos = in.clip_position.xy;
     if pos.x < top_left.x || pos.x > bot_right.x || pos.y < top_left.y || pos.y > bot_right.y {
         return color * 0.0;