From 6775d29249afca7b75c36e79968f869eeded18c0 Mon Sep 17 00:00:00 2001 From: Elijah Date: Fri, 13 Nov 2026 20:08:56 -0700 Subject: [PATCH] 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 --- src/screens/Splash.tsx | 133 ++++++++++++++--------------------------- src/styles/app.css | 5 +- 2 files changed, 48 insertions(+), 90 deletions(-) diff --git a/src/screens/Splash.tsx b/src/screens/Splash.tsx index a9a62a1..dba47ab 100644 --- a/src/screens/Splash.tsx +++ b/src/screens/Splash.tsx @@ -2,11 +2,11 @@ import { useEffect, useRef } from 'react'; import { useSettings } from '../app/settings'; /** - * The cold-start brand sequence: a kaleidoscope. A mirrored field of shards - * turns and gathers into the mark's six facets; if startup is still going, - * small shards keep circling the mark. Once startup is ready the camera flies - * through the mark's open centre, revealing the app drawn beneath (which - * settles from a slight zoom, `html.splash-arrival`). + * The cold-start brand sequence, kept short because desktop startup is quick: + * the mark's six facets spin in from a loose ring and snap together with a + * ring pulse. If startup is still going, small shards circle the mark. Once + * startup is ready the camera flies through the mark's open centre, revealing + * the app drawn beneath (which settles from a slight zoom, `html.splash-arrival`). */ 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']; // 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 = [ [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], @@ -63,48 +63,46 @@ const FACETS = [ const points: Point[] = []; 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 }; - 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]; -// 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. const INNER_RADIUS = 13.6; const MARK_BOX = 140; -// Timeline (ms): the mark has formed at INTRO_END; the sequence then idles until startup is ready. -const INTRO_END = 1700; -const EXIT_MS = 640; -// The mark is larger than the old lockup, so it zooms less to end the flight at the same size. +// Timeline (ms): the last facet locks at INTRO_END; the sequence then idles until startup is ready. +const FACET_STAGGER = 18; +const FACET_MS = 350; +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 INK = '#090a0c'; 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)})`; -/** 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 sr = Math.sin(rot); const cs = Math.cos(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) => { - const rx = p.x - f.centroid.x; - const ry = p.y - f.centroid.y; - const x = f.centroid.x + (rx * cs - ry * ss) * scale; - const y = f.centroid.y + (rx * ss + ry * cs) * scale; - const px = o.x + (x * cr - y * sr) * unit + offset.x; - const py = o.y + (x * sr + y * cr) * unit + offset.y; + const rx = p.x + f.normal.x * out - cx; + const ry = p.y + f.normal.y * out - cy; + const x = cx + (rx * cs - ry * ss) * scale; + const y = cy + (rx * ss + ry * cs) * scale; + const px = o.x + (x * cr - y * sr) * unit; + const py = o.y + (x * sr + y * cr) * unit; if (i === 0) ctx.moveTo(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); const zoom = q > 0 ? Math.exp(Math.log(FLIGHT_ZOOM) * Flight(q)) : 1; 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. 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; } - // The kaleidoscope's mirror lines, turning with the field. - 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))); + const bloom = 0.09 * InOut(phase(time, 0, 260)) * (1 - Standard(phase(time, 420, 1100))); if (bloom > 0.001) { ctx.globalCompositeOperation = 'lighter'; 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'; } - // Shards spiral inward, faster than the field turns, and vanish into the centre. - ctx.globalCompositeOperation = 'screen'; - const inward = Emphasized(phase(time, 0, 1350)); + // The six facets spin in from a loose ring and lock into the mark. FACETS.forEach((f, s) => { - SHARDS.forEach((d, j) => { - const appear = Standard(phase(time, j * 50 + s * 25, j * 50 + s * 25 + 420)); - const vanish = Standard(phase(time, 750 + j * 45, 1350 + j * 45)); - 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)); + const start = s * FACET_STAGGER; + const p = Emphasized(phase(time, start, start + FACET_MS)); + ctx.globalAlpha = Standard(phase(time, start, start + 160)); ctx.fillStyle = f.color; 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.globalAlpha = 1; // 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) { - 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.beginPath(); - hexagon(ctx, o, (30 + 24 * EmphasizedDecelerate(pulse)) * unit); + hexagon(ctx, o, (30 + 22 * EmphasizedDecelerate(pulse)) * unit); ctx.stroke(); } - // Still starting: small shards keep circling the mark. - const idle = Standard(phase(time, 2300, 2900)) * (1 - phase(q, 0, 0.25)); + // Still starting: small shards circle the mark. + const idle = Standard(phase(time, IDLE_START, IDLE_START + 600)) * (1 - phase(q, 0, 0.25)); if (idle > 0) { ctx.globalCompositeOperation = 'screen'; ctx.globalAlpha = 0.4 * idle; for (let s = 0; s < 6; s++) { 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.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); @@ -255,12 +212,12 @@ function draw(ctx: CanvasRenderingContext2D, w: number, h: number, time: number, ctx.globalCompositeOperation = 'source-over'; } - // A band of light crosses the settled mark, then again every few seconds while it waits. - const sheen = time < 1500 ? 0 : ((time - 1500) % 3600) / 900; + // While it waits, a band of light crosses the mark every few seconds. + const sheen = time < IDLE_START ? 0 : ((time - IDLE_START) % 3600) / 900; if (q === 0 && sheen > 0 && sheen < 1) { ctx.save(); 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(); const reach = 40 * unit; const a = rad(36); @@ -334,7 +291,7 @@ export function Splash({ ready, onDone }: { ready: boolean; onDone: () => void } cancelAnimationFrame(raf); window.removeEventListener('resize', size); // 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]); diff --git a/src/styles/app.css b/src/styles/app.css index 63eec8e..ff3508c 100644 --- a/src/styles/app.css +++ b/src/styles/app.css @@ -270,10 +270,11 @@ html.os-macos:not(.window-fullscreen) .topbar { pointer-events: none; } /* 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 .auth-screen { - animation: splash-arrival 640ms linear both; + animation: splash-arrival 540ms linear both; } @keyframes splash-arrival { 0% {