Open source CapCut alternative.
TypeScript
perf(cut): settle cycling title faces once [rebuild]
David Lee13b3e7fb431
diff --git a/site/packages/effects-kit/src/render.ts b/site/packages/effects-kit/src/render.tsindex 5818e70e..fa8642e3 100644--- a/site/packages/effects-kit/src/render.ts+++ b/site/packages/effects-kit/src/render.ts@@ -503,19 +503,47 @@ export function settleCycleFace<T extends Overlay>(return { ...face, text, size } as unknown as T;}+/** The canvas every face settles on, made once through the host's seam: a+ * measure draws nothing, so one serves every frame and every title. */+let settleCtx: CanvasRenderingContext2D | null = null;++/** Settled lines and size by everything that decides them, oldest first. A+ * handful of titles cycle at once, each through a few faces. */+const settledFaces = new Map<string, { text: string; size: number }>();+const SETTLED_FACES_MAX = 256;++/** Drop every settled face, for a host whose fonts just changed: a face+ * measured in a fallback settles again in the real one. */+export function forgetSettledFaces(): void {+ settledFaces.clear();+}+/** `settleCycleFace` measured the way the painter measures: on a canvas in- * the frame's pixels, with both faces resident first. */+ * the frame's pixels, with both faces resident first. Each face settles once+ * per room and scale; a painted frame after that reuses it. */async function settledFace(o: TextOverlay, frame: PaintFrame, env: RenderEnv): Promise<TextOverlay> {const own = o.cycleOwn;if (!own) return o;const cssOf = (type: TextType) => textCssFont({ ...o, ...type }, type.size * frame.scale, env);- await Promise.all([ensureFontLoaded(cssOf(own), o.text), ensureFontLoaded(cssOf(o), o.text)]);- const ctx = newCanvas(env, 1, 1).getContext("2d")!;- return settleCycleFace(o, textWrapRoom(o, frame.width), (type, line) => {- ctx.font = cssOf(type);- if ("letterSpacing" in ctx) ctx.letterSpacing = `${(type.letterSpacing ?? 0) * type.size * frame.scale}px`;- return ctx.measureText(line).width;- });+ const room = textWrapRoom(o, frame.width);+ const key = `${room}|${frame.scale}|${cssOf(own)}|${own.letterSpacing ?? 0}|${cssOf(o)}|${o.letterSpacing ?? 0}|${o.text}`;+ let hit = settledFaces.get(key);+ if (!hit) {+ await Promise.all([ensureFontLoaded(cssOf(own), o.text), ensureFontLoaded(cssOf(o), o.text)]);+ const ctx = (settleCtx ??= newCanvas(env, 1, 1).getContext("2d")!);+ const set = settleCycleFace(o, room, (type, line) => {+ ctx.font = cssOf(type);+ if ("letterSpacing" in ctx) ctx.letterSpacing = `${(type.letterSpacing ?? 0) * type.size * frame.scale}px`;+ return ctx.measureText(line).width;+ });+ hit = { text: set.text, size: set.size };+ // Bounded: the oldest settle goes first.+ if (settledFaces.size >= SETTLED_FACES_MAX) settledFaces.delete(settledFaces.keys().next().value!);+ settledFaces.set(key, hit);+ }+ const face: TextOverlay = { ...o, text: hit.text, size: hit.size };+ delete face.cycleOwn;+ return face;}async function paintText(diff --git a/site/packages/effects-kit/src/settledFace.test.ts b/site/packages/effects-kit/src/settledFace.test.tsnew file mode 100644index 00000000..b58cb7cb--- /dev/null+++ b/site/packages/effects-kit/src/settledFace.test.ts@@ -0,0 +1,49 @@+import { expect, test } from "bun:test";+import { Canvas } from "skia-canvas";+import { withFontCycle } from "./fontCycle";+import { renderElementCanvas, type RenderEnv } from "./render";+import type { TextOverlay } from "./types";++// A cycling title is painted every frame it is on screen. Its face is settled+// onto the title's own lines once per face, on one measuring canvas: a frame+// that paints it opens only the canvas it draws on.++const title: TextOverlay = {+ id: "t",+ kind: "text",+ text: "STAY TUNED FOR MORE",+ start: 0,+ end: 2,+ x: 0.5,+ y: 0.5,+ size: 60,+ font: "montserrat",+ weight: 700,+ color: "#ffffff",+ shadow: false,+ plate: false,+ anim: { fonts: { faces: [{ font: "anton", scale: 1.6 }], at: 0, seconds: 2, rate: 10 } },+};++test("painting a cycling title again opens no canvas beyond the one it draws on", async () => {+ let made = 0;+ const env: RenderEnv = {+ fontStack: () => "Arial",+ createCanvas: (w, h) => {+ made++;+ return new Canvas(w, h) as unknown as HTMLCanvasElement;+ },+ };+ const face = withFontCycle(title, 0.5);+ await renderElementCanvas(face, 270, 480, env);+ const counts: number[] = [];+ for (let i = 0; i < 3; i++) {+ made = 0;+ await renderElementCanvas(withFontCycle(title, 0.5 + i * 0.01), 270, 480, env);+ counts.push(made);+ }+ made = 0;+ await renderElementCanvas({ ...title, anim: undefined }, 270, 480, env);+ const plain = made;+ expect(counts).toEqual([plain, plain, plain]);+});diff --git a/site/src/cut/lib/textFit.test.ts b/site/src/cut/lib/textFit.test.tsnew file mode 100644index 00000000..b35f7156--- /dev/null+++ b/site/src/cut/lib/textFit.test.ts@@ -0,0 +1,38 @@+import { expect, test } from "bun:test";+import { cycleFaceAt } from "./textFit";+import type { TextOverlay } from "./types";++// The preview resolves a cycling title on every playback tick. One face at one+// frame width settles once: the same element comes back, so the tick neither+// re-wraps the title nor hands React a new element to render.++const title = {+ id: "t",+ kind: "text",+ text: "STAY TUNED FOR MORE",+ start: 0,+ end: 2,+ x: 0.5,+ y: 0.5,+ size: 60,+ font: "montserrat",+ weight: 700,+ color: "#ffffff",+ shadow: false,+ plate: false,+ anim: { fonts: { faces: [{ font: "anton", scale: 1.6 }, { font: "caveat" }], at: 0, seconds: 2, rate: 10 } },+} as TextOverlay;++test("a face settles once per frame width, and the next face settles on its own", () => {+ const first = cycleFaceAt(title, 0.01, 1080);+ expect(first.font).toBe("anton");+ expect(cycleFaceAt(title, 0.05, 1080)).toBe(first);+ const next = cycleFaceAt(title, 0.15, 1080);+ expect(next.font).toBe("caveat");+ expect(cycleFaceAt(title, 0.25, 1080)).toBe(first);+ expect(cycleFaceAt(title, 0.05, 540)).not.toBe(first);+});++test("outside the cycle the title comes back as it is", () => {+ expect(cycleFaceAt(title, 2.5, 1080)).toBe(title);+});diff --git a/site/src/cut/lib/textFit.ts b/site/src/cut/lib/textFit.tsindex a3414f0a..5776996c 100644--- a/site/src/cut/lib/textFit.ts+++ b/site/src/cut/lib/textFit.ts@@ -1,6 +1,6 @@"use client";-import { settleCycleFace, textWrapRoom, withFontCycle, wrapTextToRoom, LINE_HEIGHT, PLATE_PAD_X, PLATE_PAD_Y } from "@donkeycut/effects-kit";+import { cycleFaceAt as faceShowingAt, forgetSettledFaces, overlayFontCycle, settleCycleFace, textWrapRoom, withFontCycle, wrapTextToRoom, LINE_HEIGHT, PLATE_PAD_X, PLATE_PAD_Y, type CycleFace } from "@donkeycut/effects-kit";import { createRasterCanvas } from "./raster";import { fontStack, type Overlay, type TextOverlay } from "./types";@@ -54,6 +54,8 @@ const widths = new Map<string, number>();*/export function forgetTextWidths(): void {widths.clear();+ settled = new WeakMap();+ forgetSettledFaces();}/** How wide one line draws, in the same pixels `frameW` is in. Falls back to a@@ -106,15 +108,37 @@ export function fitTextToFrame(o: TextOverlay, frameW: number): string {return wrapTextToRoom(o.text, room, width);}+/** Each element's settled faces, one per face, frame width and font state,+ * so a playing preview resolves a cycling title without re-wrapping it on+ * every tick. Keyed by the element, so an edit starts afresh. */+let settled = new WeakMap<Overlay, { face: CycleFace; frameW: number; ready: boolean; out: Overlay }[]>();+/** Settled faces one element keeps: its faces at a few frame widths. */+const SETTLED_PER_ELEMENT = 32;+/** The element as it is set `tLocal` seconds in, a font cycle's face set on* the title's own lines the way the kit's painters set it (`settleCycleFace`),- * so the preview never reflows a title the export keeps on one line. */+ * so the preview never reflows a title the export keeps on one line. One face+ * at one frame width hands back the same element every tick. */export function cycleFaceAt<T extends Overlay>(o: T, tLocal: number, frameW: number): T {+ const c = overlayFontCycle(o);+ const face = c ? faceShowingAt(c, tLocal) : null;+ if (!face) return o;++ // A face already settled at this width, in fonts that have not changed since.+ const ready = facesReady();+ const known = settled.get(o) ?? [];+ for (const k of known) {+ if (k.face === face && k.frameW === frameW && k.ready === ready) return k.out as T;+ }+const el = withFontCycle(o, tLocal);- if (el === o || (el.kind ?? "text") !== "text") return el;- return settleCycleFace(el, textWrapRoom(el as TextOverlay, frameW), (type, line) =>+ const out = settleCycleFace(el, textWrapRoom(el as TextOverlay, frameW), (type, line) =>measureLine(line, textFontOf(type, type.size), type.size, type.letterSpacing ?? 0));+ if (known.length >= SETTLED_PER_ELEMENT) known.shift();+ known.push({ face, frameW, ready, out });+ settled.set(o, known);+ return out;}/** Resting box in design pixels, measured once for resize gestures. */