Shorten the startup intro to a quick facet snap

Desktop startup is usually ready well before the kaleidoscope finished, so
the intro took 2.3 s regardless. The six facets now spin in and lock in
0.44 s, then the fly-through follows in 0.54 s (about 1 s in all). Shards
circle the mark only if startup is still going.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Elijah 2026-11-13 20:08:56 -07:00
parent 940fe0a6b6
commit 6775d29249
2 changed files with 48 additions and 90 deletions

View file

@ -2,11 +2,11 @@ import { useEffect, useRef } from 'react';
import { useSettings } from '../app/settings'; import { useSettings } from '../app/settings';
/** /**
* The cold-start brand sequence: a kaleidoscope. A mirrored field of shards * The cold-start brand sequence, kept short because desktop startup is quick:
* turns and gathers into the mark's six facets; if startup is still going, * the mark's six facets spin in from a loose ring and snap together with a
* small shards keep circling the mark. Once startup is ready the camera flies * ring pulse. If startup is still going, small shards circle the mark. Once
* through the mark's open centre, revealing the app drawn beneath (which * startup is ready the camera flies through the mark's open centre, revealing
* settles from a slight zoom, `html.splash-arrival`). * the app drawn beneath (which settles from a slight zoom, `html.splash-arrival`).
*/ */
type Point = { x: number; y: number }; type Point = { x: number; y: number };
@ -51,7 +51,7 @@ const rad = (deg: number) => (deg * Math.PI) / 180;
const PALETTE = ['#C3E8D3', '#71B9B0', '#3D7C7B', '#D0A977', '#E9D8AE', '#EEF2DD']; const PALETTE = ['#C3E8D3', '#71B9B0', '#3D7C7B', '#D0A977', '#E9D8AE', '#EEF2DD'];
// The brand mark's facets, centred on its 64-unit viewport, each with the // The brand mark's facets, centred on its 64-unit viewport, each with the
// angle of its hexagon edge's outward normal and its centroid. // outward normal of its hexagon edge and its centroid.
const FACETS = [ const FACETS = [
[33, 4, 55.5, 17, 42.5, 24.5, 33, 19], [33, 4, 55.5, 17, 42.5, 24.5, 33, 19],
[56.5, 19, 56.5, 45, 43.5, 37.5, 43.5, 26.5], [56.5, 19, 56.5, 45, 43.5, 37.5, 43.5, 26.5],
@ -63,48 +63,46 @@ const FACETS = [
const points: Point[] = []; const points: Point[] = [];
for (let k = 0; k < pts.length; k += 2) points.push({ x: pts[k] - 32, y: pts[k + 1] - 32 }); for (let k = 0; k < pts.length; k += 2) points.push({ x: pts[k] - 32, y: pts[k + 1] - 32 });
const centroid = { x: points.reduce((s, p) => s + p.x, 0) / 4, y: points.reduce((s, p) => s + p.y, 0) / 4 }; const centroid = { x: points.reduce((s, p) => s + p.x, 0) / 4, y: points.reduce((s, p) => s + p.y, 0) / 4 };
return { points, centroid, color: PALETTE[i], angle: rad(-60 + 60 * i) }; const angle = rad(-60 + 60 * i);
return { points, centroid, color: PALETTE[i], normal: { x: Math.cos(angle), y: Math.sin(angle) } };
}); });
type Facet = (typeof FACETS)[number]; type Facet = (typeof FACETS)[number];
// Loose shards around each facet: angle offset from the facet's normal, starting
// radius (px), size, palette offset and how far they tumble on the way in.
const SHARDS = [
{ angle: 20, radius: 170, scale: 0.42, color: 2, spin: 1.2 },
{ angle: -20, radius: 170, scale: 0.42, color: 4, spin: -1.2 },
{ angle: 36, radius: 320, scale: 0.3, color: 3, spin: 2.1 },
{ angle: -36, radius: 320, scale: 0.3, color: 1, spin: -2.1 },
{ angle: 8, radius: 420, scale: 0.2, color: 5, spin: 3 },
{ angle: -8, radius: 420, scale: 0.2, color: 5, spin: -3 },
];
// The inner hexagon traced by the facets' inner edges: the aperture the exit flies through. // The inner hexagon traced by the facets' inner edges: the aperture the exit flies through.
const INNER_RADIUS = 13.6; const INNER_RADIUS = 13.6;
const MARK_BOX = 140; const MARK_BOX = 140;
// Timeline (ms): the mark has formed at INTRO_END; the sequence then idles until startup is ready. // Timeline (ms): the last facet locks at INTRO_END; the sequence then idles until startup is ready.
const INTRO_END = 1700; const FACET_STAGGER = 18;
const EXIT_MS = 640; const FACET_MS = 350;
// The mark is larger than the old lockup, so it zooms less to end the flight at the same size. const INTRO_END = FACET_STAGGER * 5 + FACET_MS;
// Still waiting at this point: shards start circling and a sheen crosses the mark.
const IDLE_START = 1100;
// Keep in step with the `splash-arrival` animation in app.css.
const EXIT_MS = 540;
const FLIGHT_ZOOM = 30; const FLIGHT_ZOOM = 30;
const INK = '#090a0c'; const INK = '#090a0c';
const SEA_GLASS = [113, 185, 176]; const SEA_GLASS = [113, 185, 176];
const LIGHT = [238, 242, 221];
const rgba = (c: number[], a: number) => `rgba(${c[0]}, ${c[1]}, ${c[2]}, ${Math.max(0, a)})`; const rgba = (c: number[], a: number) => `rgba(${c[0]}, ${c[1]}, ${c[2]}, ${Math.max(0, a)})`;
/** A facet turned `rot` about the mark centre, shrunk and spun about its own centroid, then offset. */ /**
function facetPath(ctx: CanvasRenderingContext2D, f: Facet, o: Point, unit: number, rot: number, scale: number, spin: number, offset: Point) { * Facet `f` around mark centre `o`, `unit` px per grid unit: pushed `out` along its
* normal, shrunk and spun about its own centroid, then turned `rot` about the mark centre.
*/
function facetPath(ctx: CanvasRenderingContext2D, f: Facet, o: Point, unit: number, out = 0, scale = 1, spin = 0, rot = 0) {
const cr = Math.cos(rot); const cr = Math.cos(rot);
const sr = Math.sin(rot); const sr = Math.sin(rot);
const cs = Math.cos(spin); const cs = Math.cos(spin);
const ss = Math.sin(spin); const ss = Math.sin(spin);
const cx = f.centroid.x + f.normal.x * out;
const cy = f.centroid.y + f.normal.y * out;
f.points.forEach((p, i) => { f.points.forEach((p, i) => {
const rx = p.x - f.centroid.x; const rx = p.x + f.normal.x * out - cx;
const ry = p.y - f.centroid.y; const ry = p.y + f.normal.y * out - cy;
const x = f.centroid.x + (rx * cs - ry * ss) * scale; const x = cx + (rx * cs - ry * ss) * scale;
const y = f.centroid.y + (rx * ss + ry * cs) * scale; const y = cy + (rx * ss + ry * cs) * scale;
const px = o.x + (x * cr - y * sr) * unit + offset.x; const px = o.x + (x * cr - y * sr) * unit;
const py = o.y + (x * sr + y * cr) * unit + offset.y; const py = o.y + (x * sr + y * cr) * unit;
if (i === 0) ctx.moveTo(px, py); if (i === 0) ctx.moveTo(px, py);
else ctx.lineTo(px, py); else ctx.lineTo(px, py);
}); });
@ -142,9 +140,6 @@ function draw(ctx: CanvasRenderingContext2D, w: number, h: number, time: number,
ctx.clearRect(0, 0, w, h); ctx.clearRect(0, 0, w, h);
const zoom = q > 0 ? Math.exp(Math.log(FLIGHT_ZOOM) * Flight(q)) : 1; const zoom = q > 0 ? Math.exp(Math.log(FLIGHT_ZOOM) * Flight(q)) : 1;
const unit = (MARK_BOX / 64) * zoom; const unit = (MARK_BOX / 64) * zoom;
const gather = Emphasized(phase(time, 0, 1450));
// The whole field turns a little less than half a revolution as it gathers.
const field = rad(-150) * (1 - Emphasized(phase(time, 0, 1550)));
// The surface: ink everywhere, with the aperture's centre cut away on exit. // The surface: ink everywhere, with the aperture's centre cut away on exit.
const hole = InOut(phase(q, 0.12, 0.5)); const hole = InOut(phase(q, 0.12, 0.5));
@ -163,25 +158,7 @@ function draw(ctx: CanvasRenderingContext2D, w: number, h: number, time: number,
ctx.globalAlpha = 1; ctx.globalAlpha = 1;
} }
// The kaleidoscope's mirror lines, turning with the field. const bloom = 0.09 * InOut(phase(time, 0, 260)) * (1 - Standard(phase(time, 420, 1100)));
const lines = InOut(phase(time, 0, 450)) * (1 - Standard(phase(time, 1100, 1700)));
if (lines > 0) {
ctx.lineWidth = 1;
for (let s = 0; s < 6; s++) {
const a = field + rad(-90 + 60 * s);
const end = { x: o.x + Math.cos(a) * 640, y: o.y + Math.sin(a) * 640 };
const g = ctx.createLinearGradient(o.x, o.y, end.x, end.y);
g.addColorStop(0, rgba(LIGHT, 0.2 * lines));
g.addColorStop(1, rgba(LIGHT, 0));
ctx.strokeStyle = g;
ctx.beginPath();
ctx.moveTo(o.x, o.y);
ctx.lineTo(end.x, end.y);
ctx.stroke();
}
}
const bloom = 0.09 * InOut(phase(time, 200, 1000)) * (1 - Standard(phase(time, 1500, 2600)));
if (bloom > 0.001) { if (bloom > 0.001) {
ctx.globalCompositeOperation = 'lighter'; ctx.globalCompositeOperation = 'lighter';
const g = ctx.createRadialGradient(o.x, o.y, 0, o.x, o.y, 300); const g = ctx.createRadialGradient(o.x, o.y, 0, o.x, o.y, 300);
@ -195,56 +172,36 @@ function draw(ctx: CanvasRenderingContext2D, w: number, h: number, time: number,
ctx.globalCompositeOperation = 'source-over'; ctx.globalCompositeOperation = 'source-over';
} }
// Shards spiral inward, faster than the field turns, and vanish into the centre. // The six facets spin in from a loose ring and lock into the mark.
ctx.globalCompositeOperation = 'screen';
const inward = Emphasized(phase(time, 0, 1350));
FACETS.forEach((f, s) => { FACETS.forEach((f, s) => {
SHARDS.forEach((d, j) => { const start = s * FACET_STAGGER;
const appear = Standard(phase(time, j * 50 + s * 25, j * 50 + s * 25 + 420)); const p = Emphasized(phase(time, start, start + FACET_MS));
const vanish = Standard(phase(time, 750 + j * 45, 1350 + j * 45)); ctx.globalAlpha = Standard(phase(time, start, start + 160));
if (appear <= 0 || vanish >= 1) return;
const a = f.angle + rad(d.angle) + field * 1.5;
const r = d.radius * (1 - 0.88 * inward);
ctx.globalAlpha = appear * (1 - vanish) * 0.9;
ctx.fillStyle = PALETTE[(s + d.color) % 6];
ctx.beginPath();
shardPath(ctx, f, { x: o.x + Math.cos(a) * r, y: o.y + Math.sin(a) * r }, unit * d.scale * (1 - 0.6 * vanish), field * 2 + d.spin * (1 - gather));
ctx.fill();
});
});
ctx.globalAlpha = 1;
ctx.globalCompositeOperation = 'source-over';
// The six facets ride in from the field and lock into the mark.
FACETS.forEach((f, s) => {
const r = 240 * (1 - gather);
const a = f.angle + field;
ctx.globalAlpha = Standard(phase(time, s * 25, s * 25 + 420));
ctx.fillStyle = f.color; ctx.fillStyle = f.color;
ctx.beginPath(); ctx.beginPath();
facetPath(ctx, f, o, unit, field, mix(0.55, 1, gather), rad(-60) * (1 - gather), { x: Math.cos(a) * r, y: Math.sin(a) * r }); facetPath(ctx, f, o, unit, 7 * (1 - p), mix(0.5, 1, p), rad(-45) * (1 - p), rad(-60) * (1 - p));
ctx.fill(); ctx.fill();
}); });
ctx.globalAlpha = 1; ctx.globalAlpha = 1;
// A ring pulses out as the facets lock. // A ring pulses out as the facets lock.
const pulse = phase(time, 1380, 2050); const pulse = phase(time, 340, 900);
if (pulse > 0 && pulse < 1) { if (pulse > 0 && pulse < 1) {
ctx.strokeStyle = rgba(SEA_GLASS, 0.45 * (1 - pulse)); ctx.strokeStyle = rgba(SEA_GLASS, 0.45 * (1 - pulse) * (1 - phase(q, 0, 0.3)));
ctx.lineWidth = 1.5; ctx.lineWidth = 1.5;
ctx.beginPath(); ctx.beginPath();
hexagon(ctx, o, (30 + 24 * EmphasizedDecelerate(pulse)) * unit); hexagon(ctx, o, (30 + 22 * EmphasizedDecelerate(pulse)) * unit);
ctx.stroke(); ctx.stroke();
} }
// Still starting: small shards keep circling the mark. // Still starting: small shards circle the mark.
const idle = Standard(phase(time, 2300, 2900)) * (1 - phase(q, 0, 0.25)); const idle = Standard(phase(time, IDLE_START, IDLE_START + 600)) * (1 - phase(q, 0, 0.25));
if (idle > 0) { if (idle > 0) {
ctx.globalCompositeOperation = 'screen'; ctx.globalCompositeOperation = 'screen';
ctx.globalAlpha = 0.4 * idle; ctx.globalAlpha = 0.4 * idle;
for (let s = 0; s < 6; s++) { for (let s = 0; s < 6; s++) {
for (const side of [-1, 1]) { for (const side of [-1, 1]) {
const a = rad(-60 + 60 * s) + side * rad(11) + (time - 2300) * 0.00032; const a = rad(-60 + 60 * s) + side * rad(11) + (time - IDLE_START) * 0.00032;
ctx.fillStyle = PALETTE[(s + (side > 0 ? 2 : 4)) % 6]; ctx.fillStyle = PALETTE[(s + (side > 0 ? 2 : 4)) % 6];
ctx.beginPath(); ctx.beginPath();
shardPath(ctx, FACETS[s], { x: o.x + Math.cos(a) * 50 * unit, y: o.y + Math.sin(a) * 50 * unit }, unit * 0.16, a * 2); shardPath(ctx, FACETS[s], { x: o.x + Math.cos(a) * 50 * unit, y: o.y + Math.sin(a) * 50 * unit }, unit * 0.16, a * 2);
@ -255,12 +212,12 @@ function draw(ctx: CanvasRenderingContext2D, w: number, h: number, time: number,
ctx.globalCompositeOperation = 'source-over'; ctx.globalCompositeOperation = 'source-over';
} }
// A band of light crosses the settled mark, then again every few seconds while it waits. // While it waits, a band of light crosses the mark every few seconds.
const sheen = time < 1500 ? 0 : ((time - 1500) % 3600) / 900; const sheen = time < IDLE_START ? 0 : ((time - IDLE_START) % 3600) / 900;
if (q === 0 && sheen > 0 && sheen < 1) { if (q === 0 && sheen > 0 && sheen < 1) {
ctx.save(); ctx.save();
ctx.beginPath(); ctx.beginPath();
FACETS.forEach((f) => facetPath(ctx, f, o, unit, 0, 1, 0, { x: 0, y: 0 })); FACETS.forEach((f) => facetPath(ctx, f, o, unit));
ctx.clip(); ctx.clip();
const reach = 40 * unit; const reach = 40 * unit;
const a = rad(36); const a = rad(36);
@ -334,7 +291,7 @@ export function Splash({ ready, onDone }: { ready: boolean; onDone: () => void }
cancelAnimationFrame(raf); cancelAnimationFrame(raf);
window.removeEventListener('resize', size); window.removeEventListener('resize', size);
// Let the arrival settle finish after the splash is gone. // Let the arrival settle finish after the splash is gone.
setTimeout(() => document.documentElement.classList.remove('splash-arrival'), 700); setTimeout(() => document.documentElement.classList.remove('splash-arrival'), EXIT_MS + 60);
}; };
}, [reduced]); }, [reduced]);

View file

@ -270,10 +270,11 @@ html.os-macos:not(.window-fullscreen) .topbar {
pointer-events: none; pointer-events: none;
} }
/* The app beneath settles from a slight zoom as the camera flies through the /* The app beneath settles from a slight zoom as the camera flies through the
aperture (held for the first quarter of the exit, then decelerating). */ aperture (held for the first quarter of the exit, then decelerating).
The duration matches EXIT_MS in Splash.tsx. */
html.splash-arrival .app-shell, html.splash-arrival .app-shell,
html.splash-arrival .auth-screen { html.splash-arrival .auth-screen {
animation: splash-arrival 640ms linear both; animation: splash-arrival 540ms linear both;
} }
@keyframes splash-arrival { @keyframes splash-arrival {
0% { 0% {