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:
parent
940fe0a6b6
commit
6775d29249
2 changed files with 48 additions and 90 deletions
|
|
@ -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]);
|
||||
|
||||
|
|
|
|||
|
|
@ -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% {
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue