Write HTML. Render video. Built for agents.
JavaScript aiai-agentsanimationclaude-codeffmpegframeworkgsaphtmlhtml-to-videomcpmotion-graphicspuppeteerrenderingtypescriptvideo-editor
// One surface evaluator for intact ice and detached shards. No independent finish.
import * as THREE from "three/webgpu";
import { tsl } from "../tsl/t";
import { rng } from "../core/seed";
import { ErosionField } from "../erosion/ErosionField";
import { iceFrost } from "./SurfaceDetail";
import { fbm, gnoise, vnoise3, softThreshold, saturate, voronoiEdge } from "../tsl/noise";
const { Fn, If, vec3, vec4, float, dot, smoothstep, normalize, clamp, dFdx, dFdy, length, max } =
tsl;
type N = any;
export function iceSmudgeDirections(seed: number) {
const rand = rng(seed + 11);
return [0, 1, 2].map(() => {
const v = new THREE.Vector3(rand() * 2 - 1, rand() * 2 - 1, rand() * 2 - 1).normalize();
return vec3(v.x, v.y, v.z);
});
}
export function iceSurface(
p: N,
nBase: N,
seedV: N,
smudgeDirs: N[],
erosion: any,
u: any,
f: any,
filter = false,
) {
const band = (scale: N) =>
filter
? float(1).sub(
smoothstep(0.35, 1.25, max(length(dFdx(p.mul(scale))), length(dFdy(p.mul(scale))))),
)
: float(1);
// frost
// Sample at the visible solid hit, consistently before and during breakup.
const frost0 = iceFrost(p, seedV, u.frostScale, u.frostThreshold, u.frostSoftness);
const frost = saturate(frost0.add(u.interiorFrost)).mul(f.frost);
// smudges: anisotropic streaks in 3 directions + blotchy prints (evaluated at the solid hit)
const stretch = (q: N, d: N) =>
q.sub(d.mul(dot(q, d)).mul(float(1).sub(float(1).div(u.smudgeAniso))));
const smudgeNoise = vec4(
gnoise(stretch(p.mul(u.smudgeScale), smudgeDirs[0]).add(seedV.mul(3))),
gnoise(stretch(p.mul(u.smudgeScale), smudgeDirs[1]).add(seedV.mul(4))),
gnoise(stretch(p.mul(u.smudgeScale), smudgeDirs[2]).add(seedV.mul(5))),
gnoise(p.mul(u.smudgeScale.mul(1.7)).add(seedV.mul(7.0))),
);
const streaks = smoothstep(0.45, 0.85, smudgeNoise.x.mul(0.5).add(0.5))
.add(smoothstep(0.45, 0.85, smudgeNoise.y.mul(0.5).add(0.5)))
.add(smoothstep(0.45, 0.85, smudgeNoise.z.mul(0.5).add(0.5)));
const blotch = smoothstep(0.6, 0.72, smudgeNoise.w.mul(0.5).add(0.5));
// noise masks: where smudges / micro bumps / cracks apply (low frequency)
const maskNoise = vec3(
fbm(p.mul(u.smudgeMaskScale).add(seedV.mul(21.0)), 2)
.mul(0.5)
.add(0.5),
fbm(p.mul(u.bumpMaskScale).add(seedV.mul(27.0)), 2)
.mul(0.5)
.add(0.5),
fbm(p.mul(u.regionScale).add(seedV.mul(33.0)), 2)
.mul(0.5)
.add(0.5),
);
const smudgeMask = softThreshold(maskNoise.x, float(1).sub(u.smudgeCoverage), 0.35);
const microMask = softThreshold(maskNoise.y, float(1).sub(u.microCoverage), 0.35);
const regionMask = softThreshold(maskNoise.z, float(1).sub(u.regionCoverage), 0.45);
const smudge = saturate(
streaks.div(3).add(blotch.mul(0.6)).mul(u.smudgeAmount).mul(smudgeMask),
).mul(f.smudges);
// surface cracks (distance to the nearest Voronoi boundary at the surface)
const crackHelper = erosion.sampleCrack(p);
const warpedP = ErosionField.warpDomain(p, crackHelper.xyz, u.crackLarge, u.crackWarp).add(
seedV.mul(0.37),
);
const ve = Fn(() => {
const edge = vec4(0, 0, 1, 1).toVar();
If(f.cracks.greaterThan(0.5), () => {
edge.assign(
erosion.materialPlanes
? erosion.materialPlanes.sample(warpedP)
: voronoiEdge(warpedP, u.seed, u.crackCoverage),
);
});
return edge;
})();
const dEdge = ve.w.div(u.crackLarge);
const veinSurf = float(1).sub(
u.veinContrast.mul(
fbm(p.mul(u.veinScale).add(seedV.mul(41.0)), 2)
.mul(0.5)
.add(0.5),
),
);
const surfCrack = smoothstep(u.crackWidth.mul(5.0), 0.0, dEdge)
.mul(u.surfaceCrack)
.mul(regionMask)
.mul(veinSurf)
.mul(f.cracks);
// Independent normal layers; none is activated by the breakup field.
const topness = saturate(nBase.y.mul(0.5).add(0.5));
const crystals = vnoise3(p.mul(u.crystalScale).add(seedV))
.mul(u.crystalBump)
.mul(0.6)
.mul(f.crystals)
.mul(band(u.crystalScale));
const grain = vnoise3(p.mul(u.edgeBumpScale).add(seedV.mul(13.0)))
.mul(u.edgeBump)
.mul(0.5)
.mul(f.grain)
.mul(band(u.edgeBumpScale));
const micro = vnoise3(p.mul(u.microScale).add(seedV.mul(5.0)))
.mul(u.microBump)
.mul(microMask)
.mul(f.micro)
.mul(band(u.microScale));
const ripple = vnoise3(p.mul(u.rippleScale).add(seedV.mul(9.0)))
.mul(u.rippleBump)
.mul(topness)
.mul(f.ripples)
.mul(band(u.rippleScale));
// The master switch removes normal perturbations without discarding their saved
// strengths, crack colour, frost coverage or genuine fracture-face normals.
const detailNormal = crystals
.add(grain)
.sub(micro)
.sub(ripple)
.sub(ve.xyz.mul(surfCrack).mul(0.6));
const nSurface = normalize(nBase.add(detailNormal.mul(f.surfaceBumps)));
return {
frost,
smudge,
surfCrack,
nSurface,
regionMask,
roughness: clamp(
u.baseRough
.add(frost.mul(u.frostRough))
.add(smudge.mul(u.smudgeRough))
.add(surfCrack.mul(0.12)),
0.015,
0.8,
),
};
}