mirror of
https://git.undefined-dev.fr/Blendman974/faceclaw.git
synced 2026-11-19 21:03:09 +00:00
<details> <summary>Prompts Used</summary> User: Let's speed up the default speed of the menu animation (ie, what the Normal speed setting corresponds to) by 2x. Opus 5.5: > Menu animations now run twice as fast at Normal speed. The build and typecheck passed; I haven't tried it on the glasses yet. > > I halved the two base durations that every menu animation speed is calculated from: > - **Highlight slide and list scroll:** 240ms → 120ms (`app/ui/menu-highlight-motion.ts:4`) > - **End-of-list bounce:** 320ms → 160ms (`app/ui/menu-scroll-motion.ts:8`) > > This covers menus, lists, and the launcher and Files icon grids. The other speed settings are calculated from these values, so they get twice as fast too: Slow now matches the old Normal, and Very Fast is now 24ms for the slide. The screen fade setting uses the same speed scale but its own duration, so it isn't affected. </details>
110 lines
5.0 KiB
TypeScript
110 lines
5.0 KiB
TypeScript
import { DrawExpression as E, ExprOp } from "../graphics/draw-expression";
|
|
import { menuAnimationDurationMs } from "./menu-animation-pref";
|
|
import { MENU_HIGHLIGHT_DURATION_MS, nextAnimationToken } from "./menu-highlight-motion";
|
|
|
|
/** Longest scroll, in pixels, that animates; longer jumps snap. */
|
|
export const MAX_ANIMATED_SCROLL = 96;
|
|
/** At Normal menu animation speed, like MENU_HIGHLIGHT_DURATION_MS. */
|
|
export const MENU_BOUNCE_DURATION_MS = 160;
|
|
/** Fraction of a bounce spent moving out to the peak; the rest settles back. */
|
|
const BOUNCE_PEAK = 0.35;
|
|
|
|
/**
|
|
* The viewport's content offset moving from `from` to `to`, on the same clock
|
|
* as the highlight. A bounce passes through `peak` on the way (usually past
|
|
* the end of the list, with `to` where it started).
|
|
*/
|
|
export type MenuScrollAnimation = {
|
|
from: number; to: number; peak?: number;
|
|
startedAt: number; token: number; durationMs: number;
|
|
};
|
|
|
|
type Box = { x: number; y: number; width: number; height: number };
|
|
|
|
const clamp01 = (t: number) => Math.max(0, Math.min(1, t));
|
|
const smoothstep = (t: number) => t * t * (3 - 2 * t);
|
|
|
|
/** The offset at timeline fraction t (0..1). Keep in sync with scrollOffsetExpression. */
|
|
export function scrollOffsetAt(animation: MenuScrollAnimation, t: number): number {
|
|
const { from, to, peak } = animation;
|
|
if (peak === undefined) return from + (to - from) * smoothstep(clamp01(t));
|
|
const out = 1 - (1 - clamp01(t / BOUNCE_PEAK)) ** 2;
|
|
const back = smoothstep(clamp01((t - BOUNCE_PEAK) / (1 - BOUNCE_PEAK)));
|
|
return from + (peak - from) * out + (to - peak) * back;
|
|
}
|
|
|
|
/**
|
|
* The offset as a draw expression, on a list timeline that started at
|
|
* `timelineStart` (by default the animation's own start). The easing ops
|
|
* clamp their input, which splits a bounce into its two phases without
|
|
* comparisons: the return term stays 0 until the peak, the outward one stays 1 after.
|
|
*/
|
|
export function scrollOffsetExpression(animation: MenuScrollAnimation, timelineStart = animation.startedAt) {
|
|
const { from, to, peak } = animation;
|
|
const t = () => E.progress(animation.durationMs, animation.startedAt - timelineStart);
|
|
if (peak === undefined) return t().ease().lerp(E.i32(from).toFloat(), E.i32(to).toFloat()).toInt();
|
|
const out = t().mul(E.f32(1 / BOUNCE_PEAK)).ease(ExprOp.EASE_OUT_QUAD);
|
|
const back = t().sub(E.f32(BOUNCE_PEAK)).div(E.f32(1 - BOUNCE_PEAK)).ease();
|
|
return E.i32(from).toFloat()
|
|
.add(E.i32(peak - from).toFloat().mul(out))
|
|
.add(E.i32(to - peak).toFloat().mul(back)).toInt();
|
|
}
|
|
|
|
/**
|
|
* Tracks the painted scroll offset. A change caused by non-wrapping
|
|
* navigation animates; programmatic scrolls, item edits and geometry changes
|
|
* snap. A bounce is requested explicitly, at an end of the list. Either starts
|
|
* from the offset on screen now, so it can interrupt one in flight.
|
|
*/
|
|
export class MenuScrollMotion {
|
|
private previous?: { scroll: number; box: Box };
|
|
private navigated = false;
|
|
private bounceBy = 0;
|
|
private animation?: MenuScrollAnimation;
|
|
|
|
navigate(wrapped: boolean): void {
|
|
this.navigated = !wrapped;
|
|
}
|
|
|
|
/** Overshoot by `offset` pixels (negative past the top) and come back, at the next paint. */
|
|
bounce(offset: number): void {
|
|
this.bounceBy = offset;
|
|
}
|
|
|
|
/** Record this paint's settled offset; returns the animation in flight, if any. */
|
|
paint(scroll: number, box: Box, now: number): MenuScrollAnimation | undefined {
|
|
const previous = this.previous;
|
|
const scrollMs = menuAnimationDurationMs(MENU_HIGHLIGHT_DURATION_MS);
|
|
const sameBox = !!previous && previous.box.x === box.x && previous.box.y === box.y &&
|
|
previous.box.width === box.width && previous.box.height === box.height;
|
|
if (!previous || !sameBox || previous.scroll !== scroll) {
|
|
const from = previous ? this.offsetAt(previous.scroll, now) : scroll;
|
|
const eligible = scrollMs > 0 && sameBox && this.navigated && from !== scroll && Math.abs(scroll - from) <= MAX_ANIMATED_SCROLL;
|
|
this.animation = eligible
|
|
? { from, to: scroll, startedAt: now, token: nextAnimationToken(), durationMs: scrollMs }
|
|
: undefined;
|
|
this.previous = { scroll, box: { ...box } };
|
|
} else if (this.bounceBy && scrollMs > 0) {
|
|
const from = this.offsetAt(scroll, now);
|
|
this.animation = Math.abs(scroll - from) <= MAX_ANIMATED_SCROLL
|
|
? { from, peak: scroll + this.bounceBy, to: scroll, startedAt: now, token: nextAnimationToken(),
|
|
durationMs: menuAnimationDurationMs(MENU_BOUNCE_DURATION_MS) }
|
|
: undefined;
|
|
}
|
|
this.navigated = false;
|
|
this.bounceBy = 0;
|
|
return this.animation && now - this.animation.startedAt < this.animation.durationMs ? this.animation : undefined;
|
|
}
|
|
|
|
/** Cancel an animation in flight, e.g. when it cannot be drawn; the next change snaps from `settled`. */
|
|
cancel(): void {
|
|
this.animation = undefined;
|
|
}
|
|
|
|
private offsetAt(settled: number, now: number): number {
|
|
const animation = this.animation;
|
|
if (!animation) return settled;
|
|
return Math.round(scrollOffsetAt(animation, (now - animation.startedAt) / animation.durationMs));
|
|
}
|
|
}
|