Write HTML. Render video. Built for agents.
JavaScript aiai-agentsanimationclaude-codeffmpegframeworkgsaphtmlhtml-to-videomcpmotion-graphicspuppeteerrenderingtypescriptvideo-editor
import * as THREE from "three/webgpu";
import { ImprovedNoise } from "three/addons/math/ImprovedNoise.js";
import { mergeVertices, toCreasedNormals } from "three/addons/utils/BufferGeometryUtils.js";
import { rng } from "../core/seed";
import approvedPreset from "../../presets/approved-material.json";
import { refineText, textRefinementSettings, repairTextSeams } from "./textRefine";
import { logoRefinementSettings } from "./logoRefine";
export interface Deformation {
strength: number;
scale: number;
seed: number;
}
export const DEFORMATION_DEFAULTS: Readonly<Deformation> = Object.freeze({
strength: approvedPreset.deformStrength,
scale: approvedPreset.deformScale,
seed: approvedPreset.deformSeed,
});
export function validateDeformationScale(value: number) {
if (!Number.isFinite(value) || value < 0.001 || value > 0.5)
throw new RangeError(
`Noise feature size ${value} is outside 0.001–0.5. Edit this value to load the preset; other settings have not been changed.`,
);
return value;
}
export function resolveDeformation(input?: Partial<Deformation>): Deformation {
const number = (key: keyof Deformation, min: number, max: number) => {
const v = input?.[key];
return typeof v === "number" && Number.isFinite(v)
? Math.max(min, Math.min(max, v))
: DEFORMATION_DEFAULTS[key];
};
return {
strength: number("strength", 0, 0.08),
scale: validateDeformationScale(input?.scale ?? DEFORMATION_DEFAULTS.scale),
seed: Math.round(number("seed", 0, 65535)),
};
}
/** Three octave Perlin noise, like the original shader FBM, baked in object space.
* Sequential noise shears keep a one-to-one continuous map (each shear has determinant 1),
* so opposite sides of thin strokes/counters move together instead of inflating into each other.
*/
export function makeDeformation(input: Deformation) {
const { strength, scale, seed } = resolveDeformation(input);
const noise = new ImprovedNoise(),
rand = rng(seed);
const offsets = Array.from({ length: 3 }, () => [rand() * 256, rand() * 256, rand() * 256]);
function fbm(a: number, b: number, channel: number) {
const o = offsets[channel];
let x = a / scale + o[0],
y = b / scale + o[1],
z = o[2],
sum = 0,
amp = 1;
for (let i = 0; i < 3; i++) {
sum += amp * noise.noise(x, y, z);
x = x * 2 + 17.3;
y = y * 2 + 9.1;
z = z * 2 + 31.7;
amp *= 0.5;
}
return sum / 1.75;
}
return (x: number, y: number, z: number): [number, number, number] => {
if (strength === 0) return [x, y, z];
x += strength * fbm(y, z, 0);
y += strength * fbm(z, x, 1);
z += strength * fbm(x, y, 2);
return [x, y, z];
};
}
/** Conforming shared-edge subdivision. Stop before exceeding a fixed extra-triangle budget.
* Every marked edge is split in ALL adjacent triangles, including cap/side seams.
*/
function refine(positions: number[], initial: number[], maxEdge: number) {
let triangles = initial;
const limit = initial.length / 3 + 6000,
maxLength2 = maxEdge * maxEdge;
const key = (a: number, b: number) => (a < b ? `${a}:${b}` : `${b}:${a}`);
for (let pass = 0; pass < 8; pass++) {
const marked = new Map<string, number>();
let extra = 0;
for (let i = 0; i < triangles.length; i += 3) {
const a = triangles[i],
b = triangles[i + 1],
c = triangles[i + 2];
for (const [u, v] of [
[a, b],
[b, c],
[c, a],
]) {
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];
if (dx * dx + dy * dy + dz * dz > maxLength2) {
marked.set(key(u, v), -1);
extra++;
}
}
}
if (!marked.size || triangles.length / 3 + extra > limit) break;
for (const [edge] of marked) {
const [a, b] = edge.split(":").map(Number),
m = positions.length / 3;
positions.push(
(positions[a * 3] + positions[b * 3]) / 2,
(positions[a * 3 + 1] + positions[b * 3 + 1]) / 2,
(positions[a * 3 + 2] + positions[b * 3 + 2]) / 2,
);
marked.set(edge, m);
}
const out: number[] = [];
for (let i = 0; i < triangles.length; i += 3) {
const a = triangles[i],
b = triangles[i + 1],
c = triangles[i + 2];
const ab = marked.get(key(a, b)),
bc = marked.get(key(b, c)),
ca = marked.get(key(c, a));
if (ab !== undefined && bc !== undefined && ca !== undefined)
out.push(a, ab, ca, ab, b, bc, ca, bc, c, ab, bc, ca);
else if (ab !== undefined && bc !== undefined) out.push(b, bc, ab, a, ab, c, ab, bc, c);
else if (bc !== undefined && ca !== undefined) out.push(c, ca, bc, b, bc, a, bc, ca, a);
else if (ca !== undefined && ab !== undefined) out.push(a, ab, ca, c, ca, b, ca, ab, b);
else if (ab !== undefined) out.push(a, ab, c, ab, b, c);
else if (bc !== undefined) out.push(b, bc, a, bc, c, a);
else if (ca !== undefined) out.push(c, ca, b, ca, a, b);
else out.push(a, b, c);
}
triangles = out;
}
return triangles;
}
/** Zero is an exact identity, including original buffers/normals. Caller owns the returned geometry. */
export function deformGeometry(
source: THREE.BufferGeometry,
input: Deformation,
creaseAngle = 40,
textMeshDetail?: number,
logoMeshDetail?: number,
): THREE.BufferGeometry {
const options = resolveDeformation(input);
if (options.strength === 0) return source;
const copy = source.clone();
// The material uses object-space fields, not UVs. Weld geometric seams before refinement.
for (const name of Object.keys(copy.attributes))
if (name !== "position") copy.deleteAttribute(name);
copy.clearGroups();
const welded = mergeVertices(copy, 1e-7);
copy.dispose();
const positions = Array.from(welded.getAttribute("position").array);
const original = Array.from(welded.index!.array);
welded.dispose();
// Independent text/logo budgets share conforming surface refinement. Legacy callers
// without a mesh-detail argument retain the original refinement path.
const settings =
textMeshDetail !== undefined
? textRefinementSettings(options.scale, textMeshDetail)
: logoMeshDetail !== undefined
? logoRefinementSettings(source, logoMeshDetail)
: null;
const triangles = settings
? refineText(
positions,
repairTextSeams(positions, original),
settings.maxEdge,
settings.extraTriangles,
)
: refine(positions, original, options.scale * 0.3);
const warp = makeDeformation(options);
for (let i = 0; i < positions.length; i += 3) {
const q = warp(positions[i], positions[i + 1], positions[i + 2]);
positions[i] = q[0];
positions[i + 1] = q[1];
positions[i + 2] = q[2];
}
const geometry = new THREE.BufferGeometry();
geometry.setAttribute("position", new THREE.Float32BufferAttribute(positions, 3));
geometry.setIndex(triangles);
const result = toCreasedNormals(geometry, THREE.MathUtils.degToRad(creaseAngle));
if (result !== geometry) geometry.dispose();
// Keep the centered-geometry contract used by bounds and shard-home sampling.
result.center();
result.computeBoundingBox();
result.computeBoundingSphere();
return result;
}