Skip to content

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.ts
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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. */