Write HTML. Render video. Built for agents.
JavaScript aiai-agentsanimationclaude-codeffmpegframeworkgsaphtmlhtml-to-videomcpmotion-graphicspuppeteerrenderingtypescriptvideo-editor
// `logo` shape: load an SVG, round corners, extrude with a bevel, crease normals, voxelise a signed distance grid
// (three-mesh-bvh) so raycast, sampling and raymarch match the primitives. FROST: loadLogo() is split into
// loadLogoShapes() + extrudeShapes() + voxelize() so headlines share the pipeline and several shapes share one `bound`.
import { unionOutlines } from "./unionOutlines";
import * as THREE from "three/webgpu";
import { SVGLoader } from "three/addons/loaders/SVGLoader.js";
import { mergeVertices, toCreasedNormals } from "three/addons/utils/BufferGeometryUtils.js";
import { MeshBVH } from "three-mesh-bvh";
import type { LogoSDF } from "./sdf";
export interface LogoParams {
/** overall width of the mark in world units */
width: number;
/** extrusion depth as a fraction of the width */
depth: number;
bevelThickness: number;
bevelSize: number;
bevelOffset: number;
bevelSegments: number;
curveSegments: number;
/** rounding radius applied to the 2D outline corners (fraction of the width, 0 = keep hard corners) */
cornerRadius: number;
/** normals are hard above this angle (degrees) and smooth below it */
creaseAngle: number;
/** SDF grid resolution */
sdfRes: number;
}
export const DEFAULT_LOGO_PARAMS: LogoParams = {
width: 2.6,
depth: 0.22,
bevelThickness: 0.06,
bevelSize: 0.05,
bevelOffset: 0,
bevelSegments: 5,
curveSegments: 24,
cornerRadius: 0.03,
creaseAngle: 40,
sdfRes: 64,
};
/** Round the corners of a closed polygon: cut each sharp corner back by `r` and bridge it with a quadratic curve. */
function roundPolygon(pts: THREE.Vector2[], r: number): THREE.Path {
// Closed paths repeat their first point. Keeping that duplicate makes both end
// segments zero-length and drops the first real corner (e.g. the H's left foot).
pts = pts.filter((p, i) => i === 0 || p.distanceToSquared(pts[i - 1]) > 1e-18);
if (pts.length > 1 && pts[0].distanceToSquared(pts[pts.length - 1]) < 1e-18)
pts = pts.slice(0, -1);
const n = pts.length;
const path = new THREE.Path();
if (r <= 0 || n < 3) {
path.moveTo(pts[0].x, pts[0].y);
for (let i = 1; i < n; i++) path.lineTo(pts[i].x, pts[i].y);
path.closePath();
return path;
}
const segs: { a: THREE.Vector2; c: THREE.Vector2; b: THREE.Vector2; sharp: boolean }[] = [];
for (let i = 0; i < n; i++) {
const p = pts[i],
prev = pts[(i - 1 + n) % n],
next = pts[(i + 1) % n];
const d1 = prev.clone().sub(p),
d2 = next.clone().sub(p);
const l1 = d1.length(),
l2 = d2.length();
if (l1 < 1e-9 || l2 < 1e-9) continue;
const ang = Math.acos(THREE.MathUtils.clamp(d1.dot(d2) / (l1 * l2), -1, 1));
const sharp = ang < THREE.MathUtils.degToRad(168);
const rr = Math.min(r, l1 * 0.45, l2 * 0.45);
segs.push({
a: p.clone().addScaledVector(d1.normalize(), sharp ? rr : 0),
c: p,
b: p.clone().addScaledVector(d2.normalize(), sharp ? rr : 0),
sharp,
});
}
segs.forEach((s, i) => {
if (i === 0) path.moveTo(s.a.x, s.a.y);
else path.lineTo(s.a.x, s.a.y);
if (s.sharp) path.quadraticCurveTo(s.c.x, s.c.y, s.b.x, s.b.y);
});
path.closePath();
return path;
}
/** A relative or root-relative path, or an inline SVG data URI: never a scheme or protocol-relative host. */
const isProjectAssetUrl = (url: string) =>
/^data:image\/svg\+xml[,;]/i.test(url) || !/^(?:[a-z][a-z0-9+.-]*:|[\\/]{2})/i.test(url.trim());
/** The SVG's shapes fitted to `P.width`, centred, y-up (world units). */
export async function loadLogoShapes(
url: string,
params: Partial<LogoParams> = {},
): Promise<THREE.Shape[]> {
const P = { ...DEFAULT_LOGO_PARAMS, ...params };
if (!isProjectAssetUrl(url)) throw new Error("The logo must be a project asset path, not " + url);
const text = await fetch(url).then((r) =>
r.ok ? r.text() : Promise.reject(new Error("no logo")),
);
const data = new SVGLoader().parse(text);
const raw: THREE.Shape[] = [];
for (const p of data.paths) raw.push(...(p as any).toShapes(true));
if (!raw.length) return [];
// svg units -> world units (fit the width), y-up
const box = new THREE.Box2();
for (const s of raw) for (const pt of s.getPoints(8)) box.expandByPoint(pt);
const size = box.getSize(new THREE.Vector2()),
centre = box.getCenter(new THREE.Vector2());
const k = P.width / Math.max(size.x, size.y);
const tx = (v: THREE.Vector2) => new THREE.Vector2((v.x - centre.x) * k, -(v.y - centre.y) * k);
return raw.map((s) => {
const shape = new THREE.Shape(s.getPoints(P.curveSegments).map(tx));
shape.holes = s.holes.map((h) => new THREE.Path(h.getPoints(P.curveSegments).map(tx)));
return shape;
});
}
/**
* Round outline corners (radius `P.cornerRadius * ref`), extrude with a bevel (depth and bevel as fractions of
* `ref`), merge, crease normals and centre. `ref` is the mark's width for the logo, the font size for a headline.
*/
export function extrudeShapes(
raw: THREE.Shape[],
P: LogoParams,
ref: number,
): THREE.BufferGeometry {
const r = P.cornerRadius * ref;
const rounded: THREE.Shape[] = unionOutlines(raw, P.curveSegments).map((s) => {
const outer = roundPolygon(s.getPoints(P.curveSegments), r);
const shape = new THREE.Shape(outer.getPoints(P.curveSegments));
shape.holes = s.holes.map((h) => roundPolygon(h.getPoints(P.curveSegments), r));
return shape;
});
const shapes = unionOutlines(rounded, P.curveSegments);
const bevel = P.bevelThickness > 0 || P.bevelSize > 0;
let geo: THREE.BufferGeometry = new THREE.ExtrudeGeometry(shapes, {
depth: P.depth * ref,
bevelEnabled: bevel,
bevelThickness: P.bevelThickness * ref,
bevelSize: P.bevelSize * ref,
bevelOffset: P.bevelOffset * ref,
bevelSegments: Math.max(1, Math.round(P.bevelSegments)),
curveSegments: Math.max(2, Math.round(P.curveSegments)),
});
geo.center();
geo = mergeVertices(geo, 1e-5);
geo = toCreasedNormals(geo, THREE.MathUtils.degToRad(P.creaseAngle));
geo.computeBoundingBox();
// The broad caps are planes. Averaging adjacent bevel faces into their
// normals makes Earcut's long triangles show through reflective materials.
// Keep the end rings tangent to the caps, so the rounded bevel joins smoothly
// without tilting the entire cap. Positions/topology and the SDF stay identical.
if (P.bevelThickness > 0 && P.bevelSize > 0) {
const position = geo.getAttribute("position"),
normal = geo.getAttribute("normal");
const { min, max } = geo.boundingBox!;
const epsilon = Math.max((max.z - min.z) * 1e-6, 1e-8);
for (let i = 0; i < position.count; i++) {
const z = position.getZ(i);
if (Math.abs(z - min.z) <= epsilon) normal.setXYZ(i, 0, 0, -1);
else if (Math.abs(z - max.z) <= epsilon) normal.setXYZ(i, 0, 0, 1);
}
normal.needsUpdate = true;
}
return geo;
}
/** Half extents of a centred geometry. */
export function halfExtents(geo: THREE.BufferGeometry) {
if (!geo.boundingBox) geo.computeBoundingBox();
const half = new THREE.Vector3();
geo.boundingBox!.getSize(half).multiplyScalar(0.5);
return half;
}
/** The texture samples [-sampleBound, sampleBound]^3; bound keeps the shared simulation domain and distance range. */
export function makeLogoSDF(
data3: Float32Array,
n: number,
bound: number,
thickness: number,
sampleBound = bound,
): LogoSDF {
const range = bound;
// Sampling can be tight per shape while erosion/particles keep a common world domain.
const sampleDomain = { value: sampleBound };
const tex = new THREE.Data3DTexture(data3, n, n, n);
tex.format = THREE.RedFormat;
tex.type = THREE.FloatType;
tex.minFilter = tex.magFilter = THREE.LinearFilter;
tex.wrapS = tex.wrapT = tex.wrapR = THREE.ClampToEdgeWrapping;
tex.needsUpdate = true;
const sample = (x: number, y: number, z: number) => {
const bound = sampleDomain.value;
const fx = (x / (2 * bound) + 0.5) * n - 0.5,
fy = (y / (2 * bound) + 0.5) * n - 0.5,
fz = (z / (2 * bound) + 0.5) * n - 0.5;
const ix = Math.max(0, Math.min(n - 2, Math.floor(fx))),
iy = Math.max(0, Math.min(n - 2, Math.floor(fy))),
iz = Math.max(0, Math.min(n - 2, Math.floor(fz)));
const tx2 = Math.max(0, Math.min(1, fx - ix)),
ty = Math.max(0, Math.min(1, fy - iy)),
tz = Math.max(0, Math.min(1, fz - iz));
const v = (a: number, b: number, c: number) => data3[a + b * n + c * n * n];
const c00 = v(ix, iy, iz) * (1 - tx2) + v(ix + 1, iy, iz) * tx2,
c10 = v(ix, iy + 1, iz) * (1 - tx2) + v(ix + 1, iy + 1, iz) * tx2;
const c01 = v(ix, iy, iz + 1) * (1 - tx2) + v(ix + 1, iy, iz + 1) * tx2,
c11 = v(ix, iy + 1, iz + 1) * (1 - tx2) + v(ix + 1, iy + 1, iz + 1) * tx2;
const c0 = c00 * (1 - ty) + c10 * ty,
c1 = c01 * (1 - ty) + c11 * ty;
const outside = Math.abs(x) > bound || Math.abs(y) > bound || Math.abs(z) > bound;
const distance = (c0 * (1 - tz) + c1 * tz) * 2 * range - range;
return outside
? Math.max(
distance,
Math.hypot(
Math.max(Math.abs(x) - bound, 0),
Math.max(Math.abs(y) - bound, 0),
Math.max(Math.abs(z) - bound, 0),
),
)
: distance;
};
return { texture: tex, res: n, bound, range, thickness, data: data3, sample, sampleDomain };
}
/**
* Voxel SDF over [-bound, bound]^3 at `res` per axis: BVH closest-point distance, signed by z-ray parity.
* Face normals give wrong signs near edges and bevels, so those voxels read solid and never erode.
*/
export function voxelize(
geo: THREE.BufferGeometry,
bound: number,
res: number,
sampleBound = bound,
): LogoSDF {
const half = halfExtents(geo);
const thickness = Math.min(half.x, half.y, half.z);
const bvh = new MeshBVH(geo);
const n = Math.max(16, Math.round(res)),
data3 = new Float32Array(n * n * n);
const p = new THREE.Vector3();
const range = bound;
const voxel = (2 * sampleBound) / n;
const maxDist = Math.min(range, Math.max(thickness * 2.5, voxel * 14));
const box = geo.boundingBox!;
const maxDistSquared = maxDist * maxDist;
const hit: any = {};
const ray = new THREE.Ray(new THREE.Vector3(), new THREE.Vector3(0, 0, 1));
const inside = new Uint8Array(n);
for (let y = 0; y < n; y++)
for (let x = 0; x < n; x++) {
// one ray per column, nudged off the grid so it never grazes an edge exactly
const cx = ((x + 0.5) / n - 0.5) * 2 * sampleBound + voxel * 0.013,
cy = ((y + 0.5) / n - 0.5) * 2 * sampleBound + voxel * 0.017;
ray.origin.set(cx, cy, -sampleBound - 1);
const hits = bvh.raycast(ray, THREE.DoubleSide) as { distance: number }[];
const crossings = (hits as any[])
.map((h) => ({ z: h.distance - sampleBound - 1, delta: h.face.normal.z < 0 ? 1 : -1 }))
.sort((a, b) => a.z - b.z);
let k = 0,
winding = 0;
for (let z = 0; z < n; z++) {
const pz = ((z + 0.5) / n - 0.5) * 2 * sampleBound;
while (k < crossings.length && crossings[k].z < pz) winding += crossings[k++].delta;
inside[z] = Number(winding !== 0);
}
for (let z = 0; z < n; z++) {
p.set(
((x + 0.5) / n - 0.5) * 2 * sampleBound,
((y + 0.5) / n - 0.5) * 2 * sampleBound,
((z + 0.5) / n - 0.5) * 2 * sampleBound,
);
// A thin extrusion occupies little of the cube. The box distance is a
// lower bound: skip BVH work only when the capped query cannot find a hit.
const dx = Math.max(box.min.x - p.x, 0, p.x - box.max.x);
const dy = Math.max(box.min.y - p.y, 0, p.y - box.max.y);
const dz = Math.max(box.min.z - p.z, 0, p.z - box.max.z);
const res2 =
dx * dx + dy * dy + dz * dz > maxDistSquared
? null
: bvh.closestPointToPoint(p, hit, 0, maxDist);
let d = res2 ? res2.distance : range;
if (inside[z]) d = -d;
data3[x + y * n + z * n * n] = Math.min(1, Math.max(0, (d + range) / (2 * range)));
}
}
return makeLogoSDF(data3, n, bound, thickness, sampleBound);
}
/** The experiment's original entry point: SVG -> extruded geometry + its own SDF. */
export async function loadLogo(
url: string,
params: Partial<LogoParams> = {},
): Promise<{ sdf: LogoSDF; geometry: THREE.BufferGeometry } | undefined> {
const P = { ...DEFAULT_LOGO_PARAMS, ...params };
const shapes = await loadLogoShapes(url, P);
if (!shapes.length) return undefined;
const geo = extrudeShapes(shapes, P, P.width);
const half = halfExtents(geo);
const bound = Math.max(half.x, half.y, half.z) * 1.15;
return { sdf: voxelize(geo, bound, P.sdfRes), geometry: geo };
}