Scenes

Sky Lockup

Logo outro in under two seconds. A one-line promise takes itself apart word by word, the white page washes off to a soft sky, and the mark in the middle of the sentence slides over, turns white and picks up your wordmark.

Sky Lockup preview, rendered with Remotion.

Source

components/kuchi/sky-lockup/index.tsx
"use client";
import { loadFont as loadGeist } from "@remotion/google-fonts/Geist";
import { loadFont as loadPoppins } from "@remotion/google-fonts/Poppins";
import type { ReactNode } from "react";
import { useEffect, useId, useState } from "react";
import {
AbsoluteFill,
continueRender,
delayRender,
Img,
useCurrentFrame,
useVideoConfig,
} from "remotion";
import {
mixOklch,
resolveFont,
type KuchiTheme,
useKuchiTheme,
} from "@/lib/kuchi-ui";
import {
CUT,
FLIP_FROM,
FLIP_INK,
FLIP_PAPER,
FLIP_WIDTH,
LEAVE,
LEAVE_FADE,
LEAVE_Y,
LETTER_FADE,
LETTER_RISE,
LETTERS_OFF,
LETTERS_ON,
LINE_CENTER,
LINE_ON,
LINE_PIVOT,
LINE_SCALE,
LINE_X,
LINE_Y,
LOCKUP_CENTER,
LOCKUP_GAP,
LOCKUP_MARK,
LOCKUP_SIZE,
LOCKUP_Y,
MARK_SCALE,
MARK_X,
MARK_Y,
SKY,
SKY_ZOOM,
KUCHI_MARK,
TILE_FADE,
TILE_LINE,
TILE_RADIUS,
TILE_SIZE,
TILE_STROKE,
TYPE_SIZE,
TYPE_TRACKING,
WIPE,
WIPE_LEAN,
WIPE_STOPS,
WORD_FADE,
WORD_GAP,
WORD_RISE,
} from "./data";
const { fontFamily: GEIST } = loadGeist("normal", {
weights: ["500"],
subsets: ["latin"],
});
const { fontFamily: POPPINS } = loadPoppins("normal", {
weights: ["600"],
subsets: ["latin"],
});
const STAGE_W = 1920;
const STAGE_H = 1080;
/** The line may fill this much of the stage before it scales down to fit. */
const MAX_LINE = STAGE_W * 0.86;
/** The source frames the mark rests in the lockup, and in the line. */
const LOCKUP_FRAME = 12;
const LINE_FRAME = 44;
/** The source frame the line's layout was measured on. */
const LAYOUT_FRAME = 72;
export interface SkyLockupProps {
/** The wordmark that types on beside the mark, on the sky. */
wordmark?: string;
/** Your mark as SVG paths, like Cut Lockup's `logo`. Defaults to the kuchi mark. */
logo?: { width: number; height: number; shapes: readonly string[] };
/** The words left of the mark. */
before?: string;
/** The words right of the mark. */
after?: string;
/** Any image URL. Defaults to the Portal Intro picture. */
sky?: string;
/** A label from `fonts.ts` or a CSS family you have loaded. Defaults to Geist. */
fontFamily?: string;
fontWeight?: number;
/** Type size on a 1920x1080 stage. */
fontSize?: number;
/** Nudge per word, `[x, y]` in stage px, for optical spacing. */
wordNudge?: [number, number][];
/** Tracking per word in em. */
wordTracking?: number[];
/** The wordmark's own face. Defaults to Poppins, which is the kuchi logotype. */
wordmarkFont?: string;
wordmarkWeight?: number;
/** Wordmark size on that stage. */
wordmarkSize?: number;
/** Wordmark tracking in em. */
wordmarkTracking?: number;
/** Space between the mark and the wordmark, in stage px. */
wordmarkGap?: number;
/** Mark and wordmark colour on the sky. */
lockupColor?: string;
speed?: number;
theme?: Partial<KuchiTheme>;
mode?: "light" | "dark";
}
/** Sample a measured table at a fractional index; holds both ends. */
export const sample = (table: readonly number[], at: number) => {
const x = Math.max(0, Math.min(at, table.length - 1));
const i = Math.floor(x);
const a = table[i] ?? 0;
return a + ((table[i + 1] ?? a) - a) * (x - i);
};
/** Which source frame an out frame shows. The clip runs backwards through `CUT`. */
export const sourceFrame = (frame: number) => {
const last = CUT[CUT.length - 1];
if (frame >= last[0]) return last[1];
const next = CUT.findIndex(([f]) => f > Math.max(0, frame));
const [f0, s0] = CUT[next - 1];
const [f1, s1] = CUT[next];
return s0 + ((Math.max(0, frame) - f0) / (f1 - f0)) * (s1 - s0);
};
/** `count` beats spread evenly from `from` to `to`. */
export const beats = (count: number, from: number, to: number) => {
const step = count > 1 ? (to - from) / (count - 1) : 0;
return Array.from({ length: count }, (_, i) => from + i * step);
};
/** Where each word starts, on the frames the measured line keys them. */
export const wordBeats = (count: number, at: readonly number[]) =>
Array.from(
{ length: count },
(_, i) =>
(at[Math.min(i, at.length - 1)] ?? 0) +
Math.max(0, i - at.length + 1) * LINE_ON.step,
);
/** Left edge of every word, in px from the centre of the tile. */
export const layoutLine = (
before: readonly number[],
after: readonly number[],
gap: number,
tile: number,
) => {
const left: number[] = [];
let x = -tile / 2;
for (let i = before.length - 1; i >= 0; i--) {
x -= gap + (before[i] ?? 0);
left.unshift(x);
}
const start = left[0] ?? -tile / 2;
const right: number[] = [];
let y = tile / 2;
for (const w of after) {
y += gap;
right.push(y);
y += w;
}
return {
before: left,
after: right,
centre: (start + y) / 2,
width: y - start,
};
};
interface Metrics {
before: number[];
after: number[];
letters: number[];
wordmark: number;
}
const measure = (
face: string,
weight: number,
before: string[],
after: string[],
tracking: (i: number) => number,
markFace: string,
markWeight: number,
markTracking: number,
wordmark: string,
): Metrics => {
const P = 100;
const ctx = document.createElement("canvas").getContext("2d");
if (!ctx) throw new Error("sky-lockup: no 2d context");
const em = (text: string, f: string, w: number, track: number) => {
ctx.font = `${w} ${P}px ${f}`;
ctx.letterSpacing = `${track * P}px`;
return ctx.measureText(text).width / P - track;
};
const chars = Array.from(wordmark);
return {
before: before.map((w, i) => em(w, face, weight, tracking(i))),
after: after.map((w, i) =>
em(w, face, weight, tracking(before.length + i)),
),
letters: chars.map((_, i) =>
i === 0
? 0
: em(
chars.slice(0, i + 1).join(""),
markFace,
markWeight,
markTracking,
) - em(chars[i] ?? "", markFace, markWeight, markTracking),
),
wordmark: em(wordmark, markFace, markWeight, markTracking),
};
};
/**
* Type at a fraction of a device pixel. Chrome rounds a baseline to a whole device
* row, which turns a slow rise into a staircase, so the word is painted on the two
* rows around `y` and added by the fraction between them. The scale pivots on the
* baseline, so neither copy can climb the grid.
*/
const Word: React.FC<{
x: number;
y: number;
scale: number;
opacity: number;
px: number;
children: ReactNode;
}> = ({ x, y, scale, opacity, px, children }) => {
if (opacity <= 0) return null;
const row = Math.floor(y * px);
const f = y * px - row;
return (
<g opacity={opacity} style={{ isolation: "isolate" }}>
{[
{ r: row, w: 1 - f },
{ r: row + 1, w: f },
].map(({ r, w }) => (
<g
key={r}
transform={`translate(${x} ${(r + 1e-3) / px}) scale(${scale})`}
style={{ opacity: w, mixBlendMode: "plus-lighter" }}
>
{children}
</g>
))}
</g>
);
};
/**
* Sky Lockup: a finished sentence takes itself apart word by word, the white page
* washes off to a soft sky, and the mark that sat in the middle of the sentence
* slides over, turns white and picks up its wordmark. One clock drives everything:
* `source` is a frame of the recording this was measured from.
*/
export const SkyLockupScene: React.FC<SkyLockupProps & { source: number }> = ({
source: s,
wordmark = "kuchi",
logo = KUCHI_MARK,
before = "your animations",
after = "as one install",
sky = SKY,
fontFamily,
fontWeight = 500,
fontSize = TYPE_SIZE,
wordNudge,
wordTracking,
wordmarkFont,
wordmarkWeight = 600,
wordmarkSize = LOCKUP_SIZE,
wordmarkTracking = 0,
wordmarkGap = LOCKUP_GAP,
lockupColor = "#ffffff",
theme,
mode,
}) => {
const t = useKuchiTheme(theme, mode);
const uid = useId().replace(/:/g, "");
const { width, height } = useVideoConfig();
const px = Math.max(width / STAGE_W, height / STAGE_H);
const face = resolveFont(fontFamily) ?? resolveFont(t.fontFamily) ?? GEIST;
const markFace = resolveFont(wordmarkFont) ?? POPPINS;
const left = before.trim().split(/\s+/).filter(Boolean);
const right = after.trim().split(/\s+/).filter(Boolean);
const letters = Array.from(wordmark);
const [m, setM] = useState<Metrics | null>(null);
const [handle] = useState(() => delayRender("sky-lockup: measuring type"));
const text = `${left.join(" ")}\n${right.join(" ")}`;
const tracks = wordTracking ?? [];
const trackKey = tracks.join();
useEffect(() => {
let live = true;
// measuring a fallback face measures the wrong face
Promise.all([
document.fonts.load(`${fontWeight} 100px ${face}`, text),
document.fonts.load(`${wordmarkWeight} 100px ${markFace}`, wordmark),
])
.catch(() => undefined)
.then(() => {
if (live) {
const [a = "", b = ""] = text.split("\n");
setM(
measure(
face,
fontWeight,
a.split(" ").filter(Boolean),
b.split(" ").filter(Boolean),
(i) => Number(trackKey.split(",")[i] || TYPE_TRACKING),
markFace,
wordmarkWeight,
wordmarkTracking,
wordmark,
),
);
}
});
return () => {
live = false;
};
}, [
face,
fontWeight,
text,
trackKey,
markFace,
wordmarkWeight,
wordmarkTracking,
wordmark,
]);
useEffect(() => {
if (m) continueRender(handle);
}, [m, handle]);
const tile72 = sample(TILE_SIZE, LAYOUT_FRAME);
const lineAt = (size: number) =>
m
? layoutLine(
m.before.map((w) => w * size),
m.after.map((w) => w * size),
(WORD_GAP * size) / TYPE_SIZE,
tile72,
)
: null;
const full = lineAt(fontSize);
// Only the type gives way to a long line: the tile stays the size of the mark.
const fit = full
? Math.min(1, (MAX_LINE - tile72) / (full.width - tile72))
: 1;
const rest = lineAt(fontSize * fit);
// The measured line sat `centre` off its tile. Any other sentence stays centred on
// the same spot, and carries the tile with it.
const lineShift = rest
? LINE_CENTER - sample(MARK_X, LAYOUT_FRAME) - rest.centre
: 0;
const lockupWidth = m
? LOCKUP_MARK + wordmarkGap + m.wordmark * wordmarkSize
: 0;
const lockupShift = m
? LOCKUP_CENTER -
lockupWidth / 2 +
LOCKUP_MARK / 2 -
sample(MARK_X, LOCKUP_FRAME)
: 0;
// How far the mark has travelled from lockup to line, read off its own curve, so
// a wider lockup cannot pull it into the words while they are still on screen.
const lockupX = sample(MARK_X, LOCKUP_FRAME);
const glide = Math.max(
0,
Math.min(
1,
(sample(MARK_X, s) - lockupX) /
((sample(MARK_X, LINE_FRAME) - lockupX) * 0.85),
),
);
const markX =
sample(MARK_X, s) + lockupShift * (1 - glide) + lineShift * glide;
const markY = sample(MARK_Y, s);
const markScale = sample(MARK_SCALE, s);
const logoScale = LOCKUP_MARK / Math.max(logo.width, logo.height);
const lineScale = sample(LINE_SCALE, s);
const lineDrift = sample(LINE_X, s);
const zoom = 1 + SKY_ZOOM.from * Math.exp(-s / SKY_ZOOM.tau);
const swing = sample(WIPE_LEAN, s);
const lean = 1 + swing * swing;
const wipe = sample(WIPE, s);
const [uMin = 0, uMax = 0] = [
WIPE_STOPS[0],
WIPE_STOPS[WIPE_STOPS.length - 2],
];
// Measured against the stage, so it rides with a mark that sits somewhere else.
const flipShift = markX - sample(MARK_X, s);
const flipPaper = sample(FLIP_PAPER, s - FLIP_FROM) + flipShift;
const flipInk = sample(FLIP_INK, s - FLIP_FROM) + flipShift;
const local = (x: number) => (x - markX) / (markScale * logoScale);
const tile = sample(TILE_SIZE, s);
const on = beats(letters.length, LETTERS_ON.from, LETTERS_ON.to);
const off = beats(letters.length, LETTERS_OFF.to, LETTERS_OFF.from);
const words = rest
? [
...left.map((w, i) => ({
w,
x: rest.before[i] ?? 0,
at: wordBeats(left.length, LINE_ON.first)[i] ?? 0,
})),
...right.map((w, i) => ({
w,
x: rest.after[i] ?? 0,
at: wordBeats(right.length, LINE_ON.second)[i] ?? 0,
})),
]
: [];
return (
<AbsoluteFill style={{ background: t.card, overflow: "hidden" }}>
<Img
src={sky}
style={{
position: "absolute",
inset: 0,
width: "100%",
height: "100%",
maxWidth: "none",
objectFit: "cover",
transform: `scale(${zoom})`,
}}
/>
<svg
viewBox={`0 0 ${STAGE_W} ${STAGE_H}`}
width="100%"
height="100%"
preserveAspectRatio="xMidYMid slice"
style={{ position: "absolute", inset: 0 }}
>
<title>{`${before} ${after}`}</title>
<defs>
<linearGradient
id={`${uid}w`}
gradientUnits="userSpaceOnUse"
x1={wipe + uMin / lean}
y1={STAGE_H / 2 + (swing * uMin) / lean}
x2={wipe + uMax / lean}
y2={STAGE_H / 2 + (swing * uMax) / lean}
>
{WIPE_STOPS.flatMap((u, i) =>
i % 2
? []
: [
<stop
key={u}
offset={(u - uMin) / (uMax - uMin)}
stopColor={t.card}
stopOpacity={WIPE_STOPS[i + 1]}
/>,
],
)}
</linearGradient>
{[
{ id: "p", at: flipPaper, from: 1, to: 0, c: lockupColor },
{ id: "i", at: flipInk, from: 0, to: 1, c: t.foreground },
].map(({ id, at, from, to, c }) => (
<linearGradient
key={id}
id={`${uid}${id}`}
gradientUnits="userSpaceOnUse"
x1={local(at - FLIP_WIDTH / 2) + logo.width / 2}
x2={local(at + FLIP_WIDTH / 2) + logo.width / 2}
y1={0}
y2={0}
>
<stop offset={0} stopColor={c} stopOpacity={from} />
<stop offset={1} stopColor={c} stopOpacity={to} />
</linearGradient>
))}
</defs>
<rect width={STAGE_W} height={STAGE_H} fill={`url(#${uid}w)`} />
{m &&
letters.map((ch, i) => {
const fade = sample(LETTER_FADE, s - (off[i] ?? 0));
const k = s - (on[i] ?? 0);
return (
<Word
// biome-ignore lint/suspicious/noArrayIndexKey: letters of a fixed string
key={i}
x={
markX +
LOCKUP_MARK / 2 +
wordmarkGap +
(m.letters[i] ?? 0) * wordmarkSize
}
y={LOCKUP_Y + sample(LETTER_RISE, k)}
scale={1}
opacity={k < 0 ? 0 : fade}
px={px}
>
<text
fill={lockupColor}
style={{
fontFamily: markFace,
fontWeight: wordmarkWeight,
fontSize: wordmarkSize,
textRendering: "geometricPrecision",
}}
>
{ch}
</text>
</Word>
);
})}
<g transform={`translate(${markX} ${markY})`}>
<rect
x={-tile / 2}
y={-tile / 2}
width={tile}
height={tile}
rx={(tile / 2) * TILE_RADIUS}
fill={t.card}
stroke={mixOklch(t.border, t.card, TILE_LINE)}
strokeWidth={TILE_STROKE}
opacity={sample(TILE_FADE, s - FLIP_FROM)}
/>
<g
transform={`scale(${markScale * logoScale}) translate(${-logo.width / 2} ${-logo.height / 2})`}
>
{logo.shapes.map((d) => (
<path key={d} d={d} fillRule="evenodd" fill={`url(#${uid}p)`} />
))}
{logo.shapes.map((d) => (
<path key={d} d={d} fillRule="evenodd" fill={`url(#${uid}i)`} />
))}
</g>
</g>
{words.map(({ w, x, at }, i) => {
const k = s - at;
const gone = s - LEAVE.from - i * LEAVE.stagger;
return (
<Word
key={w + at}
x={
LINE_PIVOT +
lineScale *
(sample(MARK_X, LAYOUT_FRAME) +
lineShift +
x +
(wordNudge?.[i]?.[0] ?? 0) -
LINE_PIVOT) +
lineDrift
}
y={
LINE_Y +
(wordNudge?.[i]?.[1] ?? 0) +
sample(WORD_RISE, k) +
sample(LEAVE_Y, gone) +
(lineScale - 1) * (LINE_Y - sample(MARK_Y, LAYOUT_FRAME))
}
scale={lineScale * fit}
opacity={
k < 0 ? 0 : sample(WORD_FADE, k) * sample(LEAVE_FADE, gone)
}
px={px}
>
<text
fill={t.foreground}
style={{
fontFamily: face,
fontWeight,
fontSize: fontSize,
letterSpacing: `${tracks[i] ?? TYPE_TRACKING}em`,
textRendering: "geometricPrecision",
}}
>
{w}
</text>
</Word>
);
})}
</svg>
</AbsoluteFill>
);
};
export const SkyLockup: React.FC<SkyLockupProps> = ({
speed = 1,
...props
}) => {
const frame = useCurrentFrame() * speed;
return <SkyLockupScene {...props} source={sourceFrame(frame)} />;
};
export default SkyLockup;
components/kuchi/sky-lockup/data.ts
/**
* Every number here was measured off a screen recording, one sample per frame, then
* scaled up from its 712x400 to a 1920x1080 stage. Tables are indexed by source
* frame: 0 is the logo on the sky, 77 is the finished sentence. The scene plays them
* backwards, see `CUT`.
*/
/** Out frame to source frame. Everything that moves plays one to one; only the held line is squeezed. */
export const CUT = [
[0, 77],
[27, 50],
[30, 41],
[46, 25],
[57, 14],
] as const;
/** Source frames each word and letter is keyed to. */
export const LINE_ON = {
first: [32, 36],
second: [57, 61, 65],
step: 4,
} as const;
export const LETTERS_ON = { from: 2, to: 6 } as const;
export const LETTERS_OFF = { from: 24, to: 28 } as const;
/** The rest position of the type, in stage px. */
export const LINE_Y = 569.9;
export const LINE_PIVOT = 942.5;
export const LINE_CENTER = 941.5;
export const LOCKUP_CENTER = 964.5;
export const LOCKUP_MARK = 74.4;
export const LOCKUP_GAP = 20;
export const LOCKUP_Y = 577.9;
export const TYPE_SIZE = 90.5;
export const TYPE_TRACKING = -0.02;
export const WORD_GAP = 18.5;
export const LOCKUP_SIZE = 105;
/** The card the mark sits on: its edge per source frame, then its corner as a share of half that. */
export const TILE_SIZE = [
100.3, 100.3, 100.3, 100.3, 100.3, 100.3, 100.3, 100.3, 100.3, 100.3, 100.3,
100.3, 100.3, 100.3, 100.3, 100.3, 100.3, 100.3, 100.3, 100.3, 100.3, 100.3,
100.3, 100.3, 100.3, 100.3, 100.3, 100.3, 100.3, 100.3, 100.3, 99.8, 96.5,
94.7, 94.5, 93.7, 92.3, 90.9, 90, 89.6, 89.3, 89.2, 89.2, 89.2, 89.2, 89.2,
89.2, 89.2, 89.3, 89.3, 89.3, 89.3, 89.3, 89.4, 89.5, 89.9, 90.9, 92.6, 93.7,
94.2, 94.3, 94.4, 94.5, 94.5, 94.6, 94.6, 94.7, 94.7, 94.8, 94.8, 94.7, 94.7,
94.7, 94.7, 94.7, 94.7, 94.7, 94.7,
] as const;
export const TILE_RADIUS = 0.52;
export const TILE_STROKE = 1.5;
/** The hairline is the border token, walked this far toward the card: it is lighter than a control's. */
export const TILE_LINE = 0.55;
/** Card opacity per source frame, from `FLIP_FROM`. */
export const TILE_FADE = [0, 0, 0, 0.24, 0.88, 1] as const;
/** The sky settles from a slightly tighter crop, at this much over its resting scale. */
export const SKY_ZOOM = { from: 0.00715, tau: 5.68 } as const;
/** The white band that wipes the sky swings as it crosses, like a wiper: its lean per source frame. */
export const WIPE_LEAN = [
0.03, 0.03, 0.03, 0.03, 0.03, 0.03, 0.03, 0.03, 0.03, 0.03, 0.03, 0.03, 0.03,
0.03, 0.03, 0.03, 0.03, 0.03, 0.03, 0.03, 0.03, 0.03, 0.03, 0.03, 0.03, 0.03,
0.035, 0.039, 0.06, 0.059, 0.082, 0.12, 0.162, 0.179, 0.194, 0.198, 0.209,
0.215, 0.224, 0.231, 0.228, 0.239, 0.238, 0.254, 0.249, 0.241, 0.24, 0.231,
0.229, 0.222, 0.223, 0.222, 0.225, 0.225, 0.226, 0.226, 0.227, 0.227, 0.227,
0.227, 0.227, 0.24, 0.241, 0.241, 0.241, 0.241, 0.241, 0.241, 0.241, 0.241,
0.241, 0.241, 0.241, 0.241, 0.241, 0.241, 0.241, 0.241,
] as const;
/** Band opacity by distance from its centre, stage px. A smoothstep, near enough. */
export const WIPE_STOPS = [
-647.2, 0, -566.3, 0.015, -485.4, 0.045, -404.5, 0.084, -323.6, 0.141, -242.7,
0.22, -161.8, 0.312, -80.9, 0.42, 0, 0.537, 80.9, 0.654, 161.8, 0.757, 242.7,
0.847, 323.6, 0.913, 404.5, 0.963, 485.4, 0.986, 566.3, 0.999, 647.2, 1,
] as const;
/** Band centre per source frame, stage px. It parks at the left edge and leaves on 63. */
export const WIPE = [
2967.6, 2967.6, 2967.6, 2967.6, 2967.6, 2967.6, 2967.6, 2967.6, 2967.6,
2967.6, 2967.6, 2967.6, 2967.6, 2967.6, 2967.6, 2967.6, 2967.6, 2967.6,
2967.6, 2967.6, 2967.6, 2967.6, 2967.6, 2967.6, 2722.2, 2427.9, 2327.9,
2265.8, 2130.9, 1958.8, 1678.9, 1169, 657.2, 378.2, 205.5, 82, -11.1, -85,
-145.5, -193.3, -232.9, -269.4, -293.5, -322.2, -337.5, -353.6, -358, -367.8,
-368.4, -367.8, -368, -368, -367.5, -367.5, -367.3, -367.4, -367.2, -367.2,
-367.2, -367.2, -367.2, -372.2, -372.5, -1131.2, -1131.2, -1131.2, -1131.2,
-1131.2, -1131.2, -1131.2, -1131.2, -1131.2, -1131.2, -1131.2, -1131.2,
-1131.2, -1131.2, -1131.2,
] as const;
/** Mark centre and scale per source frame. Scale 1 is the logo on the sky. */
export const MARK_X = [
881.04, 880.96, 880.96, 880.91, 880.96, 880.99, 880.99, 880.97, 880.98,
880.97, 880.95, 880.98, 880.97, 880.97, 880.96, 880.95, 880.95, 880.96,
881.05, 881.05, 881.17, 881.3, 881.83, 882.48, 883.14, 884.45, 886.15, 888.68,
891.84, 896.58, 902.18, 920.66, 939.13, 949.21, 955.76, 959.13, 961.43,
962.95, 964.13, 964.72, 965.29, 965.64, 965.75, 965.81, 965.83, 965.79, 965.8,
965.8, 965.82, 965.85, 965.91, 965.98, 966.03, 966.1, 966.21, 966.37, 966.53,
966.73, 966.92, 967.01, 967.11, 967.18, 967.25, 967.31, 967.36, 967.38,
967.41, 967.44, 967.48, 967.49, 967.5, 967.55, 967.56, 967.56, 967.56, 967.58,
967.6, 967.61,
] as const;
export const MARK_Y = [
561.09, 557.32, 555.61, 554.2, 553.17, 552.32, 551.59, 551.01, 550.41, 549.95,
549.51, 549.05, 548.77, 548.5, 548.25, 548.02, 547.77, 547.55, 547.41, 547.33,
547.2, 547.08, 546.95, 546.86, 546.85, 546.81, 546.78, 546.73, 546.79, 546.94,
546.75, 546.75, 546.73, 546.76, 546.75, 546.77, 546.78, 546.77, 546.78,
546.79, 546.78, 546.8, 546.81, 546.79, 546.79, 546.79, 546.8, 546.8, 546.8,
546.81, 546.8, 546.8, 546.8, 546.8, 546.8, 546.79, 546.78, 546.77, 546.77,
546.77, 546.76, 546.76, 546.75, 546.75, 546.76, 546.76, 546.75, 546.75,
546.75, 546.75, 546.76, 546.75, 546.76, 546.76, 546.76, 546.76, 546.76,
546.76,
] as const;
export const MARK_SCALE = [
0.8113, 0.9106, 0.9483, 0.972, 0.9876, 0.9987, 1.0062, 1.0073, 1.0075, 1.0086,
1.0096, 1.01, 1.0098, 1.009, 1.0096, 1.0092, 1.0094, 1.0087, 1.0074, 1.004,
1.0018, 0.9981, 0.9926, 0.9898, 0.9846, 0.9776, 0.9693, 0.9601, 0.9456,
0.9177, 0.88, 0.83, 0.7752, 0.7462, 0.7278, 0.7136, 0.7035, 0.6973, 0.6874,
0.6825, 0.681, 0.6764, 0.6747, 0.6735, 0.6717, 0.6712, 0.671, 0.671, 0.6712,
0.6719, 0.6731, 0.6745, 0.6759, 0.6777, 0.6805, 0.685, 0.69, 0.6963, 0.7024,
0.7058, 0.7093, 0.7114, 0.7137, 0.7154, 0.7171, 0.718, 0.7188, 0.7198, 0.7211,
0.7212, 0.7216, 0.7225, 0.7228, 0.723, 0.7233, 0.724, 0.7248, 0.7248,
] as const;
/** A short soft edge crosses the mark and swaps its colour: its x per frame from 28, off until it reaches the mark. */
export const FLIP_FROM = 28;
export const FLIP_WIDTH = 65;
export const FLIP_PAPER = [2698.0, 947.9, 933.3, 919.0, 897.2, 810.3] as const;
export const FLIP_INK = [2698.0, 1004.5, 943.6, 922.8, 903.4, 877.8] as const;
/** The whole line drifts and pushes in around `LINE_PIVOT`. */
export const LINE_SCALE = [
0.9163, 0.9163, 0.9163, 0.9163, 0.9163, 0.9163, 0.9163, 0.9163, 0.9163,
0.9163, 0.9163, 0.9163, 0.9163, 0.9163, 0.9163, 0.9163, 0.9163, 0.9163,
0.9163, 0.9163, 0.9163, 0.9163, 0.9163, 0.9163, 0.9163, 0.9163, 0.9163,
0.9163, 0.9163, 0.9163, 0.9163, 0.9163, 0.9163, 0.9163, 0.9163, 0.9163,
0.9159, 0.9168, 0.9172, 0.9176, 0.9183, 0.9192, 0.9196, 0.9204, 0.9212, 0.922,
0.9233, 0.9245, 0.9258, 0.9275, 0.9294, 0.9314, 0.9339, 0.9371, 0.9412, 0.947,
0.9545, 0.9627, 0.9705, 0.9769, 0.9813, 0.9842, 0.9868, 0.989, 0.991, 0.9927,
0.9942, 0.9953, 0.9967, 0.9978, 0.9987, 0.9995, 1.0001, 1.0007, 1.0011,
1.0017, 1.0022, 1.0025,
] as const;
export const LINE_X = [
10.2, 10.2, 10.2, 10.2, 10.2, 10.2, 10.2, 10.2, 10.2, 10.2, 10.2, 10.2, 10.2,
10.2, 10.2, 10.2, 10.2, 10.2, 10.2, 10.2, 10.2, 10.2, 10.2, 10.2, 10.2, 10.2,
10.2, 10.2, 10.2, 10.2, 10.2, 10.2, 10.2, 10.2, 9.05, 8.21, 6.95, 6.01, 5.17,
4.42, 3.85, 3.24, 2.63, 2.02, 1.56, 1.22, 0.79, 0.42, 0.27, 0.14, 0.07, 0.1,
0.07, 0.02, 0.16, 0.16, 0.04, -0.08, -0.02, 0.06, 0.07, 0.01, -0.08, -0.05,
-0.04, -0.01, -0.01, 0.02, 0.02, 0.02, 0, -0.01, 0.01, 0.02, 0, 0, -0.03,
-0.06,
] as const;
/** Each word, by frames since it started: px below rest, and opacity. */
export const WORD_RISE = [
7.91, 5.66, 4.07, 2.82, 2.05, 1.4, 0.91, 0.59, 0.31, 0.1, -0.02, -0.06, -0.07,
] as const;
export const WORD_FADE = [
0.437, 0.603, 0.71, 0.795, 0.855, 0.896, 0.929, 0.955, 0.973, 0.991, 1.003,
] as const;
/** The line starts to leave from source frame 65, one word after another. */
export const LEAVE = { from: 65, stagger: 0.7 } as const;
export const LEAVE_Y = [
-0.2, -0.33, -0.5, -0.72, -1.07, -1.44, -1.88, -2.42, -3.04, -3.82, -4.64,
-5.61, -6.9,
] as const;
export const LEAVE_FADE = [
1, 1, 1, 1, 0.983, 0.98, 0.975, 0.971, 0.953, 0.943, 0.919, 0.904, 0.883,
] as const;
/** Each letter by frames since it cut in, and frames since it started to go. */
export const LETTER_RISE = [
16.2, 12.15, 10.26, 8.64, 7.29, 5.94, 5, 4.19, 3.51, 2.84, 2.29, 1.89, 1.49,
1.13, 0.81, 0.54, 0.32, 0.14, 0,
] as const;
export const LETTER_FADE = [1, 0.7, 0.34, 0] as const;
/** The kuchi mark, outlined. */
export const KUCHI_MARK = {
width: 723,
height: 632,
shapes: [
"M139.04 0H583.96Q723 0 723 139.04V492.96000000000004Q723 632 583.96 632H139.04Q0 632 0 492.96000000000004V139.04Q0 0 139.04 0Z",
],
} as const;
/** The picture behind the logo, shared with Portal Intro. */
export const SKY = "https://kuchi-media.kalarislabs.com/components/art/art-03.svg";