Write HTML. Render video. Built for agents.
JavaScript aiai-agentsanimationclaude-codeffmpegframeworkgsaphtmlhtml-to-videomcpmotion-graphicspuppeteerrenderingtypescriptvideo-editor
/** Text-only mesh density. Priority edge bisection spends a strict budget on the longest
* remaining edges; every incident face splits together, including cap/bevel/side seams. */
import preset from "../../presets/approved-material.json";
export const TEXT_MESH_DETAIL_DEFAULT = preset.textMeshDetail;
export function resolveTextMeshDetail(value?: number) {
return typeof value === "number" && Number.isFinite(value)
? Math.max(1, Math.min(4, Math.round(value)))
: TEXT_MESH_DETAIL_DEFAULT;
}
export function textRefinementSettings(scale: number, detail: number) {
const level = resolveTextMeshDetail(detail);
return { maxEdge: scale / (2 * level), extraTriangles: 160_000 * level };
}
type Edge = { a: number; b: number; length2: number; faces: Set<number> };
/** Exported for measurement before displacement; positions gain shared midpoint vertices. */
export function refineText(
positions: number[],
initial: number[],
maxEdge: number,
extraTriangles: number,
) {
const triangles: (number[] | null)[] = [],
edges = new Map<string, Edge>(),
heap: Edge[] = [];
const max2 = maxEdge * maxEdge,
limit = initial.length / 3 + extraTriangles;
let count = initial.length / 3;
const key = (a: number, b: number) => (a < b ? `${a}:${b}` : `${b}:${a}`);
const better = (a: Edge, b: Edge) =>
a.length2 > b.length2 || (a.length2 === b.length2 && (a.a < b.a || (a.a === b.a && a.b < b.b)));
function push(edge: Edge) {
let i = heap.length;
heap.push(edge);
while (i > 0) {
const parent = (i - 1) >> 1;
if (!better(edge, heap[parent])) break;
heap[i] = heap[parent];
i = parent;
}
heap[i] = edge;
}
function pop() {
const best = heap[0],
last = heap.pop()!;
if (heap.length) {
let i = 0;
while (i * 2 + 1 < heap.length) {
let child = i * 2 + 1;
if (child + 1 < heap.length && better(heap[child + 1], heap[child])) child++;
if (!better(heap[child], last)) break;
heap[i] = heap[child];
i = child;
}
heap[i] = last;
}
return best;
}
function add(a: number, b: number, c: number) {
const id = triangles.length;
triangles.push([a, b, c]);
for (const [u, v] of [
[a, b],
[b, c],
[c, a],
]) {
const k = key(u, v);
let edge = edges.get(k);
if (!edge) {
const dx = positions[u * 3] - positions[v * 3],
dy = positions[u * 3 + 1] - positions[v * 3 + 1],
dz = positions[u * 3 + 2] - positions[v * 3 + 2];
edge = {
a: Math.min(u, v),
b: Math.max(u, v),
length2: dx * dx + dy * dy + dz * dz,
faces: new Set(),
};
edges.set(k, edge);
if (edge.length2 > max2) push(edge);
}
edge.faces.add(id);
}
}
function remove(id: number) {
const t = triangles[id]!;
triangles[id] = null;
for (let j = 0; j < 3; j++) {
const k = key(t[j], t[(j + 1) % 3]),
e = edges.get(k)!;
e.faces.delete(id);
if (!e.faces.size) edges.delete(k);
}
}
for (let i = 0; i < initial.length; i += 3) add(initial[i], initial[i + 1], initial[i + 2]);
while (heap.length && count < limit) {
const edge = pop();
if (edges.get(key(edge.a, edge.b)) !== edge) continue;
const ids = [...edge.faces];
if (count + ids.length > limit) continue;
const m = positions.length / 3;
positions.push(
(positions[edge.a * 3] + positions[edge.b * 3]) / 2,
(positions[edge.a * 3 + 1] + positions[edge.b * 3 + 1]) / 2,
(positions[edge.a * 3 + 2] + positions[edge.b * 3 + 2]) / 2,
);
const faces = ids.map((id) => triangles[id]!);
for (const id of ids) remove(id);
for (const t of faces) {
// Retain original winding, regardless of which side sees a->b versus b->a.
const j = t.findIndex((v, j) => key(v, t[(j + 1) % 3]) === key(edge.a, edge.b));
const a = t[j],
b = t[(j + 1) % 3],
c = t[(j + 2) % 3];
add(a, m, c);
add(m, b, c);
}
count += ids.length;
}
const out: number[] = [];
for (const t of triangles) if (t) out.push(t[0], t[1], t[2]);
return out;
}
/** Repair subpixel extrusion seam duplicates before subdividing them. Only boundary
* vertices are eligible; real glyph contours/counters and the SVG path are untouched. */
export function repairTextSeams(positions: number[], indices: number[]) {
const clean: number[] = [];
for (let i = 0; i < indices.length; i += 3) {
const [a, b, c] = indices.slice(i, i + 3);
if (a !== b && b !== c && c !== a) clean.push(a, b, c);
}
const edges = new Map<string, { a: number; b: number; count: number }>();
for (let i = 0; i < clean.length; i += 3)
for (const [a, b] of [
[clean[i], clean[i + 1]],
[clean[i + 1], clean[i + 2]],
[clean[i + 2], clean[i]],
]) {
const key = a < b ? `${a}:${b}` : `${b}:${a}`,
edge = edges.get(key);
if (edge) edge.count++;
else edges.set(key, { a, b, count: 1 });
}
const boundary = new Set<number>();
for (const e of edges.values())
if (e.count === 1) {
boundary.add(e.a);
boundary.add(e.b);
}
const eps = 1e-5,
grid = new Map<string, number[]>(),
remap = new Map<number, number>();
for (const v of [...boundary].sort((a, b) => a - b)) {
const x = positions[v * 3],
y = positions[v * 3 + 1],
z = positions[v * 3 + 2],
cx = Math.floor(x / eps),
cy = Math.floor(y / eps),
cz = Math.floor(z / eps);
let representative = v;
for (let dx = -1; dx <= 1; dx++)
for (let dy = -1; dy <= 1; dy++)
for (let dz = -1; dz <= 1; dz++)
for (const other of grid.get(`${cx + dx}:${cy + dy}:${cz + dz}`) || []) {
if (
Math.hypot(
x - positions[other * 3],
y - positions[other * 3 + 1],
z - positions[other * 3 + 2],
) <= eps
)
representative = Math.min(representative, other);
}
remap.set(v, representative);
if (representative === v) {
const key = `${cx}:${cy}:${cz}`,
bucket = grid.get(key) || [];
bucket.push(v);
grid.set(key, bucket);
}
}
const out: number[] = [];
for (let i = 0; i < clean.length; i += 3) {
const [a, b, c] = clean.slice(i, i + 3).map((v) => remap.get(v) ?? v);
if (a !== b && b !== c && c !== a) out.push(a, b, c);
}
return out;
}