Write HTML. Render video. Built for agents.
JavaScript aiai-agentsanimationclaude-codeffmpegframeworkgsaphtmlhtml-to-videomcpmotion-graphicspuppeteerrenderingtypescriptvideo-editor
// The erosion field: a 3D storage texture in object space (rgba16float: r = erosion 0..1, g = refrost).
// Cursor strokes splat capsules into it (compute), erosion crumbles along the crack network for a
// short while after a stroke, and after `healDelay` the field decays back to 0 with a frost-first refill.
// One canonical texture `tex` is read by every consumer; `scratch` receives the step, then is copied back.
import * as THREE from "three/webgpu";
import { tsl } from "../tsl/t";
const {
Fn,
vec3,
vec4,
float,
uniform,
uniformArray,
instanceIndex,
texture3D,
textureStore,
uvec3,
ivec3,
int,
uint,
If,
Loop,
max,
min,
length,
dot,
clamp,
smoothstep,
mix,
abs,
select,
instancedArray,
atomicAdd,
atomicMax,
atomicStore,
atomicLoad,
} = tsl;
import type { ShapeSpec } from "../shape/sdf";
import { hash31, voronoiEdge, voronoiCell, gnoise, saturate } from "../tsl/noise";
import { D } from "../dials/store";
import { sim } from "../core/state";
type N = any;
export const MAX_SEGMENTS = 12;
export class ErosionField {
/** Floor (object units) for the erodable shell just outside the distance-field surface; set before construction. */
static extraShell = 0;
readonly res: number;
readonly bound: number;
readonly tex: THREE.Storage3DTexture;
readonly scratch: THREE.Storage3DTexture;
readonly crackTex: THREE.Storage3DTexture;
/** Baked break cells: xyz = cell centre (object space), w = cell hash. The brush snaps to these. */
readonly cellTex: THREE.Storage3DTexture;
readonly u = {
reconstruct: uniform(0),
dt: uniform(0),
time: uniform(0),
heal: uniform(0),
healRate: uniform(0.6),
healGap: uniform(0.12),
fallbackHeal: uniform(0.04),
fallbackOn: uniform(0),
refrostTime: uniform(4),
cellRestore: uniform(30),
growEdges: uniform(1),
breakup: uniform(0.7),
breakupScale: uniform(10),
crumbleRate: uniform(1.6),
crumbleCrackBias: uniform(2.5),
crumbleUntil: uniform(-1),
brushNoise: uniform(0.55),
brushNoiseScale: uniform(9),
brushSoftness: uniform(0.5),
segCount: uniform(0),
seed: uniform(0),
crackScale: uniform(2.2),
crackWarp: uniform(0.45),
crackWarpScale: uniform(1.4),
crackCoverage: uniform(0.55),
breakScale: uniform(3),
cellSnap: uniform(0.85),
};
readonly segments = uniformArray(
Array.from({ length: MAX_SEGMENTS * 2 }, () => new THREE.Vector4()),
);
private stepNode: any;
private copyNode: any;
private cellClearNode: any;
private flightClearNode: any;
private clearNode: any;
private fillNode: any;
private healClearNode: any;
private bakeNode: any;
private statsNode: any;
private statsClearNode: any;
private statsBuf: any;
private statsPending = false;
/** Last readback: max erosion, voxels > 0.5, voxels > 0.9 (debug HUD). */
readonly stats = { max: 0, over50: 0, over90: 0, refrost: 0 };
/** clock time of the last stats readback that completed (for the idle-skip logic). */
statsReadT = -1;
private statsIssuedT = -1;
private baked = false;
skipBake = false;
private texNode: any;
private lastCrackSig = "";
private settingsVersion = -1;
/**
* @param atomics shared atomic uint buffer (also holds the powder density grid + counters);
* the heal grid (one counter per field voxel) starts at `healOffset`.
*/
readonly atomics: any;
readonly healOffset: number;
readonly cellOffset: number;
readonly flightOffset: number;
constructor(
readonly renderer: THREE.WebGPURenderer,
readonly shape: ShapeSpec,
res: number,
seed: number,
atomics: any,
healOffset: number,
cellOffset: number,
flightOffset: number,
) {
this.cellOffset = cellOffset;
this.flightOffset = flightOffset;
// assigned explicitly (not as parameter properties): buildComputes() below reads them, and the
// TS->JS transform may order parameter-property assignment after field initialisation
this.atomics = atomics;
this.healOffset = healOffset;
if (!Number.isInteger(healOffset))
throw new Error("ErosionField: healOffset must be an integer");
this.res = res;
this.bound = shape.bound;
this.u.seed.value = seed;
const make = () => {
const t = new THREE.Storage3DTexture(res, res, res);
t.type = THREE.HalfFloatType;
t.format = THREE.RGBAFormat;
t.minFilter = THREE.LinearFilter;
t.magFilter = THREE.LinearFilter;
t.wrapS = t.wrapT = t.wrapR = THREE.ClampToEdgeWrapping;
t.generateMipmaps = false;
return t;
};
this.tex = make();
this.scratch = make();
this.crackTex = make();
this.cellTex = make();
this.texNode = texture3D(this.tex);
this.buildComputes();
}
/** Object-space position -> field uvw. */
uvw(p: N) {
return vec3(p)
.div(this.bound * 2)
.add(0.5);
}
/** Sample the field (trilinear) at an object-space position. Returns vec4 (r erosion, g refrost). */
sample(pObject: N) {
return this.texNode.sample(this.uvw(pObject)).level(0);
}
/** Baked crack helper texture: xyz = domain-warp vector (unit-less, -1..1), w = crack proximity 0..1. */
sampleCrack(pObject: N) {
return texture3D(this.crackTex).sample(this.uvw(pObject)).level(0);
}
/** Warped crack-domain coordinate for an object-space point (shared by bake + material). */
static warpDomain(p: N, warp: N, scale: N, warpAmount: N) {
return vec3(p).mul(scale).add(vec3(warp).mul(warpAmount));
}
private buildComputes() {
const res = this.res,
total = res * res * res,
bound = this.bound;
const u = this.u;
const voxel = (bound * 2) / res;
const shell = Math.max(voxel * 1.5, ErosionField.extraShell);
const idx = instanceIndex;
const coord = () => {
const x = idx.mod(uint(res));
const y = idx.div(uint(res)).mod(uint(res));
const z = idx.div(uint(res * res));
return uvec3(x, y, z);
};
const toObject = (c: N) =>
vec3(c)
.add(0.5)
.div(res)
.sub(0.5)
.mul(bound * 2);
const readTex = texture3D(this.tex);
const readScratch = texture3D(this.scratch);
const crack = texture3D(this.crackTex);
const cells = texture3D(this.cellTex);
// --- step: crumble propagation + heal + stroke splats -> scratch
this.stepNode = Fn(() => {
const c = coord();
// NOTE: values used inside loops/branches AND afterwards must be pinned with toVar() up front,
// otherwise TSL assigns them at first use (inside the branch) and later reads are uninitialised.
const p = toObject(c).toVar();
const sd = this.shape.sdfNode(p).toVar();
const cur = readTex.load(ivec3(c)).level(0).toVar();
const e = cur.r.toVar();
const refrost = cur.g.toVar();
const mark = cur.b.toVar(); // 1 = healed by a landed grain (propagation may spread from here only)
const hit = max(0.0, cur.a.sub(u.dt.div(0.2))).toVar(); // brush-hit age: 1 the frame the brush touches this voxel, 0 after 0.2 s
const crackP = crack.load(ivec3(c)).level(0).w;
// breakup: every refill / cleanup / refrost timer runs at a locally varied rate, so a break cell (whose
// voxels all carry the same erosion value) no longer crosses the look thresholds all at once
const bn = gnoise(p.mul(u.breakupScale).add(u.seed.mul(1.7).add(11.0)))
.mul(0.5)
.add(0.5);
const rateMul = mix(float(1), float(0.15).add(saturate(bn).mul(1.7)), u.breakup).toVar();
// crumble propagation: erosion spreads toward the max of the 6 neighbours, biased by crack proximity
If(u.time.lessThan(u.crumbleUntil), () => {
const nb = float(0).toVar();
const offs = [
ivec3(1, 0, 0),
ivec3(-1, 0, 0),
ivec3(0, 1, 0),
ivec3(0, -1, 0),
ivec3(0, 0, 1),
ivec3(0, 0, -1),
];
for (const o of offs) {
const cc = clamp(ivec3(c).add(o), ivec3(0), ivec3(res - 1));
nb.assign(max(nb, readTex.load(cc).level(0).r));
}
const inside = smoothstep(0.02, -0.02, sd);
const rate = u.crumbleRate.mul(float(1).add(crackP.mul(u.crumbleCrackBias))).mul(inside);
const target = nb.mul(0.92).sub(0.06);
If(target.greaterThan(e), () => {
e.assign(min(target, e.add(target.sub(e).mul(saturate(rate.mul(u.dt))))));
});
});
// stroke splats: soft capsules with a ragged noise boundary
// break cell of this voxel: ice breaks along cell faces, so the brush is evaluated at the cell centre
// (every voxel of a cell gets the same erosion -> flat facets) and mixed with the smooth capsule
const cell = cells.load(ivec3(c)).level(0).toVar();
Loop({ start: int(0), end: int(u.segCount), type: "int", condition: "<" }, ({ i }: any) => {
const a4 = this.segments.element(i.mul(2));
const b4 = this.segments.element(i.mul(2).add(1));
const a = a4.xyz,
b = b4.xyz,
radius = a4.w,
strength = b4.w;
const ab = b.sub(a);
const capsuleDist = (q: N) => {
const tt = clamp(dot(q.sub(a), ab).div(max(dot(ab, ab), 1e-6)), 0.0, 1.0);
return length(q.sub(a.add(ab.mul(tt))));
};
const n = gnoise(p.mul(u.brushNoiseScale).add(u.seed))
.mul(0.5)
.add(gnoise(p.mul(u.brushNoiseScale.mul(2.7)).add(u.seed.add(3.1))).mul(0.25));
const r = radius.mul(float(1).add(n.mul(u.brushNoise)));
const inner = r.mul(float(1).sub(u.brushSoftness));
const wSmooth = smoothstep(r, inner, capsuleDist(p));
const rCell = radius.mul(float(1).add(cell.w.sub(0.5).mul(u.brushNoise).mul(0.6)));
const wCell = smoothstep(
rCell,
rCell.mul(float(1).sub(u.brushSoftness)),
capsuleDist(cell.xyz),
);
const w = mix(wSmooth, wCell, u.cellSnap);
e.assign(min(1.0, e.add(w.mul(strength).mul(u.dt))));
If(w.greaterThan(0.02), () => {
hit.assign(1.0);
});
});
// healing is driven by the returning grains: a grain that lands deposits into the heal grid and
// the voxel refills (as frost first); voxels without a grain follow their healed neighbours
const healIdx = uint(this.healOffset).add(idx);
const deposits = float(atomicLoad(this.atomics.element(healIdx))).toVar();
// Ordinary healing waits for its cell; reconstruction deposits restore locally on arrival.
const cellId0 = uint(clamp(cell.w.mul(65535.0), 0.0, 65535.0));
const cellReady0 = atomicLoad(
this.atomics.element(uint(this.flightOffset).add(cellId0)),
).equal(uint(0));
If(deposits.greaterThan(0.5).and(cellReady0.or(u.reconstruct.greaterThan(0.5))), () => {
atomicStore(this.atomics.element(healIdx), uint(0));
refrost.assign(min(1.0, refrost.add(e.mul(2.5))));
e.assign(0.0);
mark.assign(1.0);
});
// break-cell restore: the last grain of the cell to land triggers it (cellHits, one frame), then the
// whole cell refills at `cellRestore` (mark = 2 marks a restoring voxel). Nothing else may refill a
// voxel whose cell still has grains in flight (cellReady), so the object never rebuilds ahead of them.
const cellId = uint(clamp(cell.w.mul(65535.0), 0.0, 65535.0));
const cellHits = float(atomicLoad(this.atomics.element(uint(this.cellOffset).add(cellId))));
const inFlight = atomicLoad(this.atomics.element(uint(this.flightOffset).add(cellId)));
const cellReady = inFlight.equal(uint(0));
If(cellHits.greaterThan(0.5).and(e.greaterThan(0.0)), () => {
mark.assign(2.0);
});
If(
mark
.greaterThan(1.5)
.and(e.greaterThan(0.0))
.and(cellReady)
.and(u.reconstruct.lessThan(0.5)),
() => {
// grow back from what is already solid (hole floor, walls, landed grains) instead of popping in at once
const canGrow = float(1).toVar();
If(u.growEdges.greaterThan(0.5), () => {
canGrow.assign(0.0);
const offs2 = [
ivec3(1, 0, 0),
ivec3(-1, 0, 0),
ivec3(0, 1, 0),
ivec3(0, -1, 0),
ivec3(0, 0, 1),
ivec3(0, 0, -1),
];
for (const o of offs2) {
const cc = clamp(ivec3(c).add(o), ivec3(0), ivec3(res - 1));
If(readTex.load(cc).level(0).r.lessThan(0.5), () => {
canGrow.assign(1.0);
});
}
});
If(canGrow.greaterThan(0.5), () => {
const before = e;
const after = max(0.0, e.sub(u.cellRestore.mul(rateMul).mul(u.dt)));
refrost.assign(min(1.0, refrost.add(before.sub(after).mul(2.5))));
e.assign(after);
});
},
);
If(u.heal.greaterThan(0.5).and(cellReady.or(u.reconstruct.greaterThan(0.5))), () => {
// voxels without a grain of their own follow neighbours that a grain has already rebuilt
const nbMin = float(8).toVar();
const nbMark = float(0).toVar();
const offs = [
ivec3(1, 0, 0),
ivec3(-1, 0, 0),
ivec3(0, 1, 0),
ivec3(0, -1, 0),
ivec3(0, 0, 1),
ivec3(0, 0, -1),
];
for (const o of offs) {
const cc = clamp(ivec3(c).add(o), ivec3(0), ivec3(res - 1));
const nv = readTex.load(cc).level(0);
If(nv.b.greaterThan(0.5), () => {
nbMin.assign(min(nbMin, nv.r));
nbMark.assign(1.0);
});
}
// Spatial front from deposited material; an additive gap per voxel left permanent holes.
const reconstruct = u.reconstruct.greaterThan(0.5);
const target = select(
reconstruct,
select(nbMin.lessThan(0.05), float(0), float(1)),
nbMin.add(u.healGap),
);
If(nbMark.greaterThan(0.5).and(target.lessThan(e)), () => {
const rate = select(
reconstruct,
max(u.cellRestore.mul(u.fallbackHeal), u.healRate),
u.healRate,
);
const after = max(target, e.sub(rate.mul(rateMul).mul(u.dt)));
refrost.assign(min(1.0, refrost.add(e.sub(after).mul(3.0))));
e.assign(after);
If(after.lessThanEqual(target.add(0.001)), () => {
mark.assign(1.0);
});
});
// fallback cleanup only after the whole wave has landed (never ahead of the grains)
If(u.fallbackOn.greaterThan(0.5).and(reconstruct.not()), () => {
const after2 = max(0.0, e.sub(u.fallbackHeal.mul(rateMul).mul(u.dt)));
refrost.assign(min(1.0, refrost.add(e.sub(after2).mul(3.0))));
e.assign(after2);
});
});
// anything that eroded this frame is no longer "rebuilt"
If(e.greaterThan(cur.r.add(0.0005)), () => {
mark.assign(0.0);
});
refrost.assign(max(0.0, refrost.sub(u.dt.mul(rateMul).div(max(u.refrostTime, 0.01)))));
// keep the field zero outside the shape so the surface sampling never reads garbage
e.assign(select(sd.greaterThan(shell), 0.0, e));
textureStore(this.scratch, c, vec4(e, refrost, mark, hit)).toWriteOnly();
})().compute(total, [64]);
// --- clear the break-cell restore triggers (after the step consumed them); the in-flight counters only
// clear on reset
this.cellClearNode = Fn(() => {
atomicStore(this.atomics.element(uint(this.cellOffset).add(instanceIndex)), uint(0));
})().compute(65536, [64]);
this.flightClearNode = Fn(() => {
atomicStore(this.atomics.element(uint(this.flightOffset).add(instanceIndex)), uint(0));
})().compute(65536, [64]);
// --- copy scratch -> tex
this.copyNode = Fn(() => {
const c = coord();
const v = readScratch.load(ivec3(c)).level(0);
textureStore(this.tex, c, v).toWriteOnly();
})().compute(total, [64]);
// --- stats reduction (debug HUD): max erosion + voxel counts above thresholds
this.statsBuf = instancedArray(4, "uint").toAtomic();
this.statsClearNode = Fn(() => {
Loop(4, ({ i: k }: any) => {
atomicStore(this.statsBuf.element(k), uint(0));
});
})().compute(1, [1]);
this.statsNode = Fn(() => {
const c = coord();
const v = readTex.load(ivec3(c)).level(0);
const e = v.r;
atomicMax(this.statsBuf.element(0), uint(e.mul(65535.0)));
atomicMax(this.statsBuf.element(3), uint(v.g.mul(65535.0)));
If(e.greaterThan(0.5), () => {
atomicAdd(this.statsBuf.element(1), uint(1));
});
If(e.greaterThan(0.9), () => {
atomicAdd(this.statsBuf.element(2), uint(1));
});
})().compute(total, [64]);
// --- clear both
this.clearNode = Fn(() => {
const c = coord();
textureStore(this.tex, c, vec4(0.0)).toWriteOnly();
})().compute(total, [64]);
// --- FROST: the whole shape fully eroded (a shape that is not there yet: the grains heal it in), and the
// heal-grid counters cleared (both used when the distance field is retargeted to another shape)
this.fillNode = Fn(() => {
const c = coord();
const sd = this.shape.sdfNode(toObject(c));
textureStore(
this.tex,
c,
vec4(select(sd.greaterThan(shell), 0.0, 1.0), 0.0, 0.0, 0.0),
).toWriteOnly();
})().compute(total, [64]);
this.healClearNode = Fn(() => {
atomicStore(this.atomics.element(uint(this.healOffset).add(instanceIndex)), uint(0));
})().compute(total, [64]);
// --- bake the crack helper: a low-frequency domain-warp vector (so cell boundaries curve instead of
// reading as flat polygons) and the proximity to the nearest (warped, partially covered) boundary
this.bakeNode = Fn(() => {
const c = coord();
const p = toObject(c).toVar();
const wq = p.mul(u.crackWarpScale).add(u.seed.mul(0.11));
const warp = vec3(
gnoise(wq)
.mul(0.6)
.add(gnoise(wq.mul(2.1).add(vec3(7.3, 1.9, 4.4))).mul(0.4)),
gnoise(wq.add(vec3(13.7, 5.1, 9.9)))
.mul(0.6)
.add(gnoise(wq.mul(2.1).add(vec3(2.2, 8.8, 6.1))).mul(0.4)),
gnoise(wq.add(vec3(3.3, 17.1, 12.5)))
.mul(0.6)
.add(gnoise(wq.mul(2.1).add(vec3(9.7, 4.4, 1.1))).mul(0.4)),
);
const q = ErosionField.warpDomain(p, warp, u.crackScale, u.crackWarp);
const ve = voronoiEdge(q, u.seed, u.crackCoverage);
const dEdge = ve.w.div(u.crackScale); // approx object-space distance
const prox = smoothstep(voxel * 2.5, 0.0, dEdge);
const h = hash31(vec3(c)).mul(0.15);
textureStore(this.crackTex, c, vec4(warp, saturate(prox.add(h.mul(prox))))).toWriteOnly();
// break cells (a separate, finer Voronoi in the same warped domain): centre back in object space
const bq = ErosionField.warpDomain(p, warp, u.breakScale, u.crackWarp);
const bc = voronoiCell(bq, u.seed.add(3.0));
const centreObj = bc.xyz.sub(warp.mul(u.crackWarp)).div(u.breakScale);
textureStore(this.cellTex, c, vec4(centreObj, hash31(bc.xyz.add(u.seed)))).toWriteOnly();
})().compute(total, [64]);
void abs;
void mix;
}
clear(renderer: THREE.WebGPURenderer) {
renderer.compute(this.clearNode);
renderer.compute(this.cellClearNode);
renderer.compute(this.flightClearNode);
}
/**
* The shape behind `this.shape.sdfNode` changed: re-bake the crack / break-cell helpers, reset the heal grid
* and cell counters, start solid (`fill` false) or fully eroded (`fill` true, healed in by returning grains).
*/
rebake(renderer: THREE.WebGPURenderer, fill: boolean) {
const u = this.u,
E = D.erosion,
C = D.ice.cracks;
u.crackScale.value = C.largeScale;
u.crackWarp.value = C.warp;
u.crackWarpScale.value = C.warpScale;
u.crackCoverage.value = C.coverage;
u.breakScale.value = E.breakCellScale;
// Helpers depend on the shared bound and crack parameters, never the shape.
const sig = `${C.largeScale}|${C.warp}|${C.warpScale}|${C.coverage}|${E.breakCellScale}`;
if ((!this.baked || sig !== this.lastCrackSig) && !this.skipBake)
renderer.compute(this.bakeNode);
this.lastCrackSig = sig;
this.baked = true;
u.reconstruct.value = fill ? 1 : 0;
renderer.compute(fill ? this.fillNode : this.clearNode);
renderer.compute(this.cellClearNode);
renderer.compute(this.flightClearNode);
renderer.compute(this.healClearNode);
this.crumbleUntil = -1;
u.crumbleUntil.value = -1;
}
/** Debug: reduce the field and read the result back asynchronously (throttled by the caller). */
readStats(renderer: THREE.WebGPURenderer, t = 0) {
if (this.statsPending) return;
this.statsPending = true;
this.statsIssuedT = t;
renderer.compute(this.statsClearNode);
renderer.compute(this.statsNode);
renderer
.getArrayBufferAsync(this.statsBuf.value)
.then((buf: ArrayBuffer) => {
const a = new Uint32Array(buf);
this.stats.max = a[0] / 65535;
this.stats.over50 = a[1];
this.stats.over90 = a[2];
this.stats.refrost = a[3] / 65535;
this.statsReadT = this.statsIssuedT;
this.statsPending = false;
})
.catch(() => {
this.statsPending = false;
});
}
/** True while a stroke, the crumble window, or (refrost) healing can still change the field. */
crumbleUntil = -1;
/**
* Advance the field. `segments` holds MAX_SEGMENTS capsules as (ax,ay,az,radius),(bx,by,bz,strength).
* With `run` false only the bookkeeping happens (the GPU passes are skipped: the field is static).
*/
step(
renderer: THREE.WebGPURenderer,
t: number,
dt: number,
segments: THREE.Vector4[],
segCount: number,
run = true,
) {
const E = D.erosion,
H = D.healing;
const u = this.u;
u.dt.value = Math.min(dt, 1 / 30);
u.time.value = t;
if (D.version !== this.settingsVersion) {
this.settingsVersion = D.version;
const C = D.ice.cracks;
const crackSig = `${C.largeScale}|${C.warp}|${C.warpScale}|${C.coverage}|${E.breakCellScale}`;
if (!this.baked || crackSig !== this.lastCrackSig) {
u.crackScale.value = C.largeScale;
u.crackWarp.value = C.warp;
u.crackWarpScale.value = C.warpScale;
u.crackCoverage.value = C.coverage;
u.breakScale.value = E.breakCellScale;
if (!this.skipBake) renderer.compute(this.bakeNode);
if (!this.baked) renderer.compute(this.clearNode);
this.baked = true;
this.lastCrackSig = crackSig;
}
u.healRate.value = H.healRate;
u.healGap.value = H.healGap;
u.fallbackHeal.value = H.fallbackHeal;
u.refrostTime.value = H.refrostTime;
u.cellRestore.value = H.cellRestore;
u.growEdges.value = H.growFromEdges ? 1 : 0;
u.breakup.value = H.breakup;
u.breakupScale.value = H.breakupScale;
u.crumbleRate.value = E.crumbleRate;
u.crumbleCrackBias.value = E.crumbleCrackBias;
u.brushNoise.value = E.brushNoise;
u.brushNoiseScale.value = E.brushNoiseScale;
u.cellSnap.value = E.cellSnap;
// Softness 0 makes the capsule falloff smoothstep(r, r, d): undefined in WGSL, 1 everywhere here (whole
// shape eroded in one frame); keep a sliver of softness.
u.brushSoftness.value = Math.max(E.brushSoftness, 0.02);
}
if (segCount > 0) {
sim.lastStrokeT = t;
u.crumbleUntil.value = t + E.crumbleDuration;
this.crumbleUntil = t + E.crumbleDuration;
}
const healing = t - sim.lastStrokeT > H.healDelay;
sim.healing = healing;
u.heal.value = healing ? 1 : 0;
// the timer-based cleanup may only start once every grain of the wave has had time to land
u.fallbackOn.value =
t - sim.lastStrokeT >
H.healDelay + H.waveTime + H.waveJitter + Math.max(H.returnDuration, H.returnAfter) + 1.0
? 1
: 0;
u.segCount.value = segCount;
if (segCount > 0) {
const arr = this.segments.array as THREE.Vector4[];
for (let i = 0; i < segCount * 2; i++) arr[i].copy(segments[i]);
}
if (!run || u.reconstruct.value > 0.5) return; // AssemblyField owns arrival-driven coverage.
renderer.compute(this.stepNode);
renderer.compute(this.cellClearNode);
renderer.compute(this.copyNode);
}
/** Commit the assembly pass before both the ice and powder read the same field. */
commitAssembly(renderer: THREE.WebGPURenderer) {
renderer.compute(this.copyNode);
}
dispose() {
this.tex.dispose();
this.scratch.dispose();
this.crackTex.dispose();
this.cellTex.dispose();
}
}