From c5c2baf21bba0fb8f66e7d2ee096818d6bd5a8e0 Mon Sep 17 00:00:00 2001
From: Gabriel Schneider <gbrls@0x4200.cafe>
Date: Mon, 28 Sep 2026 20:31:56 -0300
Subject: Motion flavours differ by design, and drive notice drops and pane
 moves
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The flavours looked alike because Lift, the only motion that read them,
moves a shadow a few pixels: overshoot and wind-up were sub-pixel. By design
now: crisp leaves at full speed and never passes its mark; smooth (the
default) eases in and out in twice crisp's time, a slide arriving in 208 ms
(inside §8.1's 220); bouncy passes its mark by ~30% and settles twice;
playful winds up, passes by ~40%, and stretches and squashes, text included
(the user's choice). Small motions are exaggerated by the flavour's gain.

Motion gains launch, gain, span and norm, and ease(u)/speed(u) for moves of
fixed length. The notice drop follows ease() over its fall (alpha never
behind its position) and stays inside its pane's body past its row. Panel
tracks carry the flavour in Track.motion (the old padding byte; macOS header
name follows); opening and moving slides, zooms and rises follow it over
span x their frames; landed, a pane is exactly its target; closing keeps
its own exit. A pane past its mark never takes a neighbour's click; a
rising one stays in its box.

Tests: each flavour's lift trajectory distinct; flavour character; exact
landing bit for bit; a stretched pane's drawn cells map back; the overshoot
hit rule; the vertical clip at peak; legacy tests pinned to crisp. GUI
golden 18-mid-transition changes (the retuned smooth slide at frame 6).

Shared files: src/animation.zig, src/Presentation.zig, src/Messages.zig,
src/macos.zig, src/config.zig, src/pardes.zig tests, src/ninep/screen.zig
test, docs/effects.md, docs/config.md.
---
 src/gui/gui.zig | 37 +++++++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)

(limited to 'src/gui')

diff --git a/src/gui/gui.zig b/src/gui/gui.zig
index 1a1b1f99..9748d4c0 100644
--- a/src/gui/gui.zig
+++ b/src/gui/gui.zig
@@ -5525,7 +5525,13 @@ fn renderFrame(
             const track_index = groupAt(&groups, layer.viewport.x, layer.viewport.y);
             // A notice floats over the panes, moving with its own.
             const group_index = if (layer.kind == .notice) noticeGroup(&groups, layer) else track_index;
+            const start = cell_next[group_index];
             emitTagLayer(g, instances, &cell_next[group_index], layer, win_w, win_h, groups.items[track_index].track, page, cursors_shown, false);
+            // A notice dropping past its row (a flavour's overshoot) stays
+            // inside its pane's body.
+            if (layer.kind == .notice and layer.slide > 0) if (bodyBottom(surface, layer.id, layout)) |bottom| {
+                for (instances[start..cell_next[group_index]]) |*instance| clipInstance(instance, .{ -1e9, -1e9, 1e9, bottom }, win_w, win_h);
+            };
         }
         for (groups.items[1..][0..groups.tracks], 1..) |group, index| {
             const track = group.track.?;
@@ -5894,6 +5900,14 @@ test "the layer cover is the per-cell layer scan, over a core's layouts and rand
     }
 }
 
+/// The bottom of pane `owner`'s body, in window pixels.
+fn bodyBottom(surface: *const pardes.Surface, owner: u16, layout: CellLayout) ?f32 {
+    for (surface.regionList()) |region| {
+        if (region.kind == .body and region.owner == owner) return @as(f32, @floatFromInt(region.rect.y + region.rect.h)) * layout.h;
+    }
+    return null;
+}
+
 fn tagLayerCellCount(g: *const Gui, layer: *const pardes.Layer) u32 {
     const pixels = @as(u32, layer.viewport.w) * g.cell_w;
     return @min(layer.cols, (pixels + g.tagline_width - 1) / g.tagline_width);
@@ -6306,6 +6320,29 @@ test "every pixel of a grip column is band, button or ring, and the button sits
     pane.file.?.revision = pane.file.?.saved_revision;
 }
 
+test "a rising pane past its mark stays inside its box" {
+    // Bouncy, a vertical rise at its highest overshoot: drawn past its box,
+    // clipped to it.
+    var g: Gui = undefined;
+    g.cell_w = 10;
+    g.cell_h = 20;
+    var track: pardes.animation.Track = .{ .serial = 3, .phase = .opening, .effect = .vertical, .motion = @intFromEnum(pardes.animation.Motion.Flavour.bouncy) + 1, .frame_count = 20, .from = .{ .x = 0, .y = 10, .w = 40, .h = 10 }, .to = .{ .x = 0, .y = 0, .w = 40, .h = 10 } };
+    var peak: u16 = 0;
+    var highest: f32 = 1e9;
+    while (track.frame < track.frames()) : (track.frame += 1) {
+        if (track.presented().y < highest) {
+            highest = track.presented().y;
+            peak = track.frame;
+        }
+    }
+    track.frame = peak;
+    try std.testing.expect(track.presented().y < 0);
+    var instance: CellInstance = std.mem.zeroes(CellInstance);
+    setTransitionFields(&instance, track, fixedCellLayout(&g), 800, 480, 0);
+    try std.testing.expectEqual(@as(f32, 0), instance.clip_y0);
+    try std.testing.expectEqual(@as(f32, 200), instance.clip_y1);
+}
+
 test "small tagline fonts leave no background gutters between adjacent tags" {
     const chrome: pardes.Chrome = .{};
     var g: Gui = undefined;
-- 
cgit v1.3