shaders 2.5.102 → 2.5.104

package/dist/core/SmokeFill-ChSIfTxW.js

@@ -0,0 +1,641 @@
+import { a as transformColor, l as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-B5lM6fYX.js";
+import { t as mixColors } from "./colorMixing-BPpDnR5I.js";
+import { n as createAnalyticSdfSampler, r as createSvgSdfSampler } from "./sdf-DyC2H_qS.js";
+import { StorageTexture } from "three/webgpu";
+import { DataTexture, FloatType, LinearFilter as LinearFilter$1, RGBAFormat } from "three";
+import { Fn, attributeArray, float, floor, instanceIndex, int, mix, screenUV, storageTexture, texture, textureStore, uint, uniform, uvec2, vec2, vec4, viewportSize } from "three/tsl";
+var DEFAULT_SHAPE_CONFIG = JSON.stringify({
+	type: "circleSDF",
+	radius: .35
+});
+var GRID_GPU = 256;
+var GRID_CPU = 56;
+var JACOBI_ITERS = 20;
+var PRESSURE_DISSIPATION = .8;
+var VELOCITY_DISSIPATION = .2;
+const componentDefinition = {
+	name: "SmokeFill",
+	category: "Shape Effects",
+	description: "Fill a shape with swirling fluid smoke that interacts with the shape boundary",
+	requiresRTT: false,
+	requiresChild: false,
+	props: {
+		colorA: {
+			default: "#8cf3ff",
+			transform: transformColor,
+			description: "Color of fresh smoke",
+			ui: {
+				type: "color",
+				label: "Start Color",
+				group: "Colors"
+			}
+		},
+		colorB: {
+			default: "#04a0d6",
+			transform: transformColor,
+			description: "Color smoke transitions to as it ages",
+			ui: {
+				type: "color",
+				label: "End Color",
+				group: "Colors"
+			}
+		},
+		center: {
+			default: {
+				x: .5,
+				y: .5
+			},
+			transform: transformPosition,
+			description: "Center position of the shape",
+			ui: {
+				type: "position",
+				label: "Center",
+				group: "Position"
+			}
+		},
+		scale: {
+			default: 1,
+			description: "Scale of the shape (1 = default size)",
+			ui: {
+				type: "range",
+				min: .1,
+				max: 3,
+				step: .05,
+				label: "Scale",
+				group: "Position"
+			}
+		},
+		emitFrom: {
+			default: {
+				x: .5,
+				y: .5
+			},
+			transform: transformPosition,
+			description: "Emission source point within the shape",
+			ui: {
+				type: "position",
+				label: "Emit From",
+				group: "Emission"
+			}
+		},
+		direction: {
+			default: 0,
+			description: "Emission direction (0 = up, 90 = right, 180 = down, 270 = left)",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Direction",
+				group: "Emission"
+			}
+		},
+		speed: {
+			default: 10,
+			description: "Emission velocity strength",
+			ui: {
+				type: "range",
+				min: .1,
+				max: 30,
+				step: .1,
+				label: "Speed",
+				group: "Emission"
+			}
+		},
+		spread: {
+			default: 60,
+			description: "Emission cone angle in degrees",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 180,
+				step: 1,
+				label: "Spread",
+				group: "Emission"
+			}
+		},
+		emitRadius: {
+			default: .03,
+			description: "Size of the emission area",
+			ui: {
+				type: "range",
+				min: .01,
+				max: .3,
+				step: .01,
+				label: "Emit Size",
+				group: "Emission"
+			}
+		},
+		intensity: {
+			default: 1,
+			description: "Smoke emission density",
+			ui: {
+				type: "range",
+				min: .1,
+				max: 1,
+				step: .05,
+				label: "Intensity",
+				group: "Effect"
+			}
+		},
+		dissipation: {
+			default: .3,
+			description: "How fast smoke fades over time",
+			ui: {
+				type: "range",
+				min: .1,
+				max: 5,
+				step: .1,
+				label: "Dissipation",
+				group: "Effect"
+			}
+		},
+		detail: {
+			default: 25,
+			description: "Fine-scale swirling detail",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 50,
+				step: 1,
+				label: "Detail",
+				group: "Effect"
+			}
+		},
+		gravity: {
+			default: .5,
+			description: "Downward gravitational pull on smoke — 0 = weightless, negative values = smoke rises",
+			ui: {
+				type: "range",
+				min: -2,
+				max: 2,
+				step: .1,
+				label: "Gravity",
+				group: "Effect"
+			}
+		},
+		colorDecay: {
+			default: .4,
+			description: "How quickly smoke shifts from Color A to Color B",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 3,
+				step: .1,
+				label: "Color Decay",
+				group: "Colors"
+			}
+		},
+		mouseInfluence: {
+			default: .1,
+			description: "Strength of cursor influence",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 2,
+				step: .05,
+				label: "Cursor Influence",
+				group: "Interaction"
+			}
+		},
+		mouseRadius: {
+			default: .1,
+			description: "Radius of cursor influence area",
+			ui: {
+				type: "range",
+				min: .02,
+				max: .5,
+				step: .01,
+				label: "Cursor Radius",
+				group: "Interaction"
+			}
+		},
+		colorSpace: {
+			default: "linear",
+			transform: transformColorSpace,
+			compileTime: true,
+			description: "Color space for color interpolation",
+			ui: {
+				type: "select",
+				options: colorSpaceOptions,
+				label: "Color Space",
+				group: "Colors"
+			}
+		},
+		shape: {
+			default: DEFAULT_SHAPE_CONFIG,
+			description: "Serialized shape configuration (JSON)",
+			ui: {
+				type: "shape",
+				label: "Shape",
+				group: "Shape"
+			}
+		},
+		shapeSdfUrl: {
+			default: "",
+			compileTime: true,
+			description: "URL to a pre-generated SDF .bin file"
+		},
+		shapeType: {
+			default: "",
+			compileTime: true,
+			description: "Active SDF shape type"
+		}
+	},
+	computeNode: ({ uniforms, onCleanup, onBeforeRender, renderer }) => {
+		const N = GRID_GPU;
+		const gs = uint(N);
+		const Ni = int(N);
+		const Nm1 = int(N - 1);
+		const count = N * N;
+		const nidx = (ii, ji, di, dj) => ii.add(int(di)).clamp(int(0), Nm1).mul(Ni).add(ji.add(int(dj)).clamp(int(0), Nm1));
+		const shapeSdfUrl = uniforms.shapeSdfUrl.uniform.value;
+		const initialConfig = (() => {
+			const val = uniforms.shape.uniform.value;
+			try {
+				return JSON.parse(val);
+			} catch {
+				return {
+					type: "circleSDF",
+					radius: .35
+				};
+			}
+		})();
+		let sdfSampler;
+		if (shapeSdfUrl) sdfSampler = createSvgSdfSampler(shapeSdfUrl, onBeforeRender, onCleanup);
+		else sdfSampler = createAnalyticSdfSampler(uniforms.shapeType.uniform.value || initialConfig.type || "circleSDF", initialConfig, uniforms.shape, onBeforeRender);
+		const velA = attributeArray(count, "vec4");
+		const velB = attributeArray(count, "vec4");
+		const densA = attributeArray(count, "vec4");
+		const densB = attributeArray(count, "vec4");
+		const pressDivBuf = attributeArray(count, "vec4");
+		const maskBuf = attributeArray(count, "vec4");
+		const outTex = new StorageTexture(N, N);
+		outTex.type = FloatType;
+		const outTexNode = storageTexture(outTex);
+		onCleanup(() => {
+			outTex.dispose();
+		});
+		const dtU = uniform(.016);
+		const emitXU = uniform(.5);
+		const emitYU = uniform(.5);
+		const emitVelXU = uniform(0);
+		const emitVelYU = uniform(-50);
+		const perpDirXU = uniform(1);
+		const perpDirYU = uniform(0);
+		const spreadFactorU = uniform(.5);
+		const emitRadU = uniform(10);
+		const emitIntensityU = uniform(.8);
+		const densDissipU = uniform(.5);
+		const curlStrengthU = uniform(30);
+		const gravityU = uniform(.5);
+		const colorDecayU = uniform(1);
+		const centerXU = uniform(.5);
+		const centerYU = uniform(.5);
+		const scaleU = uniform(1);
+		const aspectU = uniform(1);
+		const cursorXU = uniform(128);
+		const cursorYU = uniform(128);
+		const cursorVelXU = uniform(0);
+		const cursorVelYU = uniform(0);
+		const mouseActiveU = uniform(0);
+		const mouseRadSqU = uniform(900);
+		const maskPass = Fn(() => {
+			const idx = instanceIndex;
+			const j = idx.mod(gs);
+			const i = idx.div(gs);
+			const u = j.toFloat().add(float(.5)).div(float(N));
+			const v = i.toFloat().add(float(.5)).div(float(N));
+			const sdfUV = vec2(u.sub(centerXU).mul(aspectU).div(scaleU).add(float(.5)), v.sub(centerYU).div(scaleU).add(float(.5)));
+			const dist = sdfSampler(sdfUV).x;
+			const inside = dist.lessThan(float(0)).select(float(1), float(0));
+			maskBuf.element(idx).assign(vec4(inside, dist, float(0), float(0)));
+		})().compute(count, [256]);
+		const splatPass = Fn(() => {
+			const idx = instanceIndex;
+			const j = idx.mod(gs);
+			const i = idx.div(gs);
+			const mask = maskBuf.element(idx).x;
+			const cellX = j.toFloat().add(float(.5));
+			const cellY = i.toFloat().add(float(.5));
+			const dx = cellX.sub(emitXU);
+			const dy = cellY.sub(emitYU);
+			const distSq = dx.mul(dx).add(dy.mul(dy));
+			const radSq = emitRadU.mul(emitRadU).max(float(1));
+			const influence = distSq.negate().div(radSq).exp().mul(mask);
+			const cell = densA.element(idx);
+			const oldDens = cell.x;
+			const addDens = emitIntensityU.mul(influence).mul(dtU).mul(float(8));
+			const newDens = oldDens.add(addDens).min(float(1));
+			const rejuvenate = addDens.div(newDens.max(float(.001)));
+			densA.element(idx).assign(vec4(newDens, cell.y.mul(float(1).sub(rejuvenate.min(float(1)))), float(0), float(0)));
+			const vel = velA.element(idx);
+			const perpOff = dx.mul(perpDirXU).add(dy.mul(perpDirYU)).div(emitRadU.max(float(1)));
+			const vmSq = emitVelXU.mul(emitVelXU).add(emitVelYU.mul(emitVelYU)).max(float(1));
+			const tvx = emitVelXU.add(perpDirXU.mul(perpOff).mul(spreadFactorU).mul(vmSq.sqrt()));
+			const tvy = emitVelYU.add(perpDirYU.mul(perpOff).mul(spreadFactorU).mul(vmSq.sqrt()));
+			const br = influence.mul(dtU).mul(float(3)).min(float(1));
+			const gravForce = gravityU.mul(oldDens).mul(dtU).mul(float(N * .08)).mul(mask);
+			const cursorDX = cellX.sub(cursorXU);
+			const cursorDY = cellY.sub(cursorYU);
+			const cursorInf = cursorDX.mul(cursorDX).add(cursorDY.mul(cursorDY)).negate().div(mouseRadSqU.max(float(1))).exp().mul(mouseActiveU).mul(mask);
+			velA.element(idx).assign(vec4(mix(vel.x, tvx, br).add(cursorVelXU.mul(cursorInf)), mix(vel.y, tvy, br).add(gravForce).add(cursorVelYU.mul(cursorInf)), vel.z, float(0)));
+		})().compute(count, [256]);
+		const curlPass = Fn(() => {
+			const idx = instanceIndex;
+			const ji = idx.mod(gs).toInt();
+			const ii = idx.div(gs).toInt();
+			const vL = velA.element(nidx(ii, ji, 0, -1));
+			const vR = velA.element(nidx(ii, ji, 0, 1));
+			const vU = velA.element(nidx(ii, ji, -1, 0));
+			const vD = velA.element(nidx(ii, ji, 1, 0));
+			const curl = vR.y.sub(vL.y).sub(vD.x.sub(vU.x)).mul(float(.5));
+			const vel = velA.element(idx);
+			velA.element(idx).assign(vec4(vel.x, vel.y, curl, float(0)));
+		})().compute(count, [256]);
+		const vorticityPass = Fn(() => {
+			const idx = instanceIndex;
+			const ji = idx.mod(gs).toInt();
+			const ii = idx.div(gs).toInt();
+			const cL = velA.element(nidx(ii, ji, 0, -1)).z.abs();
+			const cR = velA.element(nidx(ii, ji, 0, 1)).z.abs();
+			const cU = velA.element(nidx(ii, ji, -1, 0)).z.abs();
+			const cD = velA.element(nidx(ii, ji, 1, 0)).z.abs();
+			const cc = velA.element(idx).z;
+			const gx = cR.sub(cL).mul(float(.5));
+			const gy = cD.sub(cU).mul(float(.5));
+			const gl = gx.mul(gx).add(gy.mul(gy)).sqrt().max(float(1e-5));
+			const vel = velA.element(idx);
+			velA.element(idx).assign(vec4(vel.x.add(gy.div(gl).mul(cc).mul(curlStrengthU).mul(dtU)), vel.y.add(gx.div(gl).negate().mul(cc).mul(curlStrengthU).mul(dtU)), vel.z, float(0)));
+		})().compute(count, [256]);
+		const divergencePass = Fn(() => {
+			const idx = instanceIndex;
+			const ji = idx.mod(gs).toInt();
+			const ii = idx.div(gs).toInt();
+			const jf = ji.toFloat();
+			const iF = ii.toFloat();
+			const selfMask = maskBuf.element(idx).x;
+			const selfVel = velA.element(idx);
+			const isWallL = jf.lessThan(float(.5)).or(maskBuf.element(nidx(ii, ji, 0, -1)).x.lessThan(float(.5)));
+			const isWallR = jf.greaterThan(float(N - 1.5)).or(maskBuf.element(nidx(ii, ji, 0, 1)).x.lessThan(float(.5)));
+			const isWallT = iF.lessThan(float(.5)).or(maskBuf.element(nidx(ii, ji, -1, 0)).x.lessThan(float(.5)));
+			const isWallB = iF.greaterThan(float(N - 1.5)).or(maskBuf.element(nidx(ii, ji, 1, 0)).x.lessThan(float(.5)));
+			const L = isWallL.select(selfVel.x.negate(), velA.element(nidx(ii, ji, 0, -1)).x);
+			const R = isWallR.select(selfVel.x.negate(), velA.element(nidx(ii, ji, 0, 1)).x);
+			const T = isWallT.select(selfVel.y.negate(), velA.element(nidx(ii, ji, -1, 0)).y);
+			const B = isWallB.select(selfVel.y.negate(), velA.element(nidx(ii, ji, 1, 0)).y);
+			const div$1 = R.sub(L).add(B.sub(T)).mul(float(.5)).mul(selfMask);
+			const oldP = pressDivBuf.element(idx).x.mul(float(PRESSURE_DISSIPATION)).mul(selfMask);
+			pressDivBuf.element(idx).assign(vec4(oldP, div$1, float(0), float(0)));
+		})().compute(count, [256]);
+		const jacobiPass = Fn(() => {
+			const idx = instanceIndex;
+			const ji = idx.mod(gs).toInt();
+			const ii = idx.div(gs).toInt();
+			const pL = pressDivBuf.element(nidx(ii, ji, 0, -1)).x;
+			const pR = pressDivBuf.element(nidx(ii, ji, 0, 1)).x;
+			const pU = pressDivBuf.element(nidx(ii, ji, -1, 0)).x;
+			const pD = pressDivBuf.element(nidx(ii, ji, 1, 0)).x;
+			const div$1 = pressDivBuf.element(idx).y;
+			pressDivBuf.element(idx).assign(vec4(pL.add(pR).add(pU).add(pD).sub(div$1).mul(float(.25)), div$1, float(0), float(0)));
+		})().compute(count, [256]);
+		const gradSubtractPass = Fn(() => {
+			const idx = instanceIndex;
+			const ji = idx.mod(gs).toInt();
+			const ii = idx.div(gs).toInt();
+			const pL = pressDivBuf.element(nidx(ii, ji, 0, -1)).x;
+			const pR = pressDivBuf.element(nidx(ii, ji, 0, 1)).x;
+			const pU = pressDivBuf.element(nidx(ii, ji, -1, 0)).x;
+			const pD = pressDivBuf.element(nidx(ii, ji, 1, 0)).x;
+			const vel = velA.element(idx);
+			velA.element(idx).assign(vec4(vel.x.sub(pR.sub(pL).mul(float(.5))), vel.y.sub(pD.sub(pU).mul(float(.5))), vel.z, float(0)));
+		})().compute(count, [256]);
+		const advectVelPass = Fn(() => {
+			const idx = instanceIndex;
+			const j = idx.mod(gs);
+			const i = idx.div(gs);
+			const vel = velA.element(idx);
+			const srcX = j.toFloat().sub(vel.x.mul(dtU)).clamp(float(0), float(N - 1));
+			const srcY = i.toFloat().sub(vel.y.mul(dtU)).clamp(float(0), float(N - 1));
+			const x0 = floor(srcX).clamp(float(0), float(N - 2));
+			const y0 = floor(srcY).clamp(float(0), float(N - 2));
+			const sx = srcX.sub(x0);
+			const sy = srcY.sub(y0);
+			const ix0 = x0.toInt();
+			const iy0 = y0.toInt();
+			const v00 = velA.element(iy0.mul(Ni).add(ix0));
+			const v10 = velA.element(iy0.mul(Ni).add(ix0.add(int(1))));
+			const v01 = velA.element(iy0.add(int(1)).mul(Ni).add(ix0));
+			const v11 = velA.element(iy0.add(int(1)).mul(Ni).add(ix0.add(int(1))));
+			const decay = float(1).add(float(VELOCITY_DISSIPATION).mul(dtU));
+			const mask = maskBuf.element(idx).x;
+			velB.element(idx).assign(vec4(mix(mix(v00.x, v10.x, sx), mix(v01.x, v11.x, sx), sy).div(decay).mul(mask), mix(mix(v00.y, v10.y, sx), mix(v01.y, v11.y, sx), sy).div(decay).mul(mask), float(0), float(0)));
+		})().compute(count, [256]);
+		const copyVelPass = Fn(() => {
+			const v = velB.element(instanceIndex);
+			velA.element(instanceIndex).assign(vec4(v.x, v.y, float(0), float(0)));
+		})().compute(count, [256]);
+		const advectDensPass = Fn(() => {
+			const idx = instanceIndex;
+			const j = idx.mod(gs);
+			const i = idx.div(gs);
+			const vel = velA.element(idx);
+			const srcX = j.toFloat().sub(vel.x.mul(dtU)).clamp(float(0), float(N - 1));
+			const srcY = i.toFloat().sub(vel.y.mul(dtU)).clamp(float(0), float(N - 1));
+			const x0 = floor(srcX).clamp(float(0), float(N - 2));
+			const y0 = floor(srcY).clamp(float(0), float(N - 2));
+			const sx = srcX.sub(x0);
+			const sy = srcY.sub(y0);
+			const ix0 = x0.toInt();
+			const iy0 = y0.toInt();
+			const d00 = densA.element(iy0.mul(Ni).add(ix0));
+			const d10 = densA.element(iy0.mul(Ni).add(ix0.add(int(1))));
+			const d01 = densA.element(iy0.add(int(1)).mul(Ni).add(ix0));
+			const d11 = densA.element(iy0.add(int(1)).mul(Ni).add(ix0.add(int(1))));
+			const dens = mix(mix(d00.x, d10.x, sx), mix(d01.x, d11.x, sx), sy);
+			const age = mix(mix(d00.y, d10.y, sx), mix(d01.y, d11.y, sx), sy);
+			const decay = float(1).add(densDissipU.mul(dtU));
+			const mask = maskBuf.element(idx).x;
+			densB.element(idx).assign(vec4(dens.div(decay).max(float(0)).mul(mask), age.add(dtU.mul(float(.4)).mul(colorDecayU)).min(float(1)), float(0), float(0)));
+		})().compute(count, [256]);
+		const copyDensPass = Fn(() => {
+			const d = densB.element(instanceIndex);
+			densA.element(instanceIndex).assign(vec4(d.x, d.y, float(0), float(0)));
+		})().compute(count, [256]);
+		const outputPass = Fn(() => {
+			const idx = instanceIndex;
+			const j = idx.mod(gs);
+			const i = idx.div(gs);
+			const d = densA.element(idx);
+			textureStore(outTexNode, uvec2(j, i), vec4(d.x, d.y, float(0), float(0))).toWriteOnly();
+		})().compute(count, [256]);
+		let lastTime = Date.now();
+		let prevMx = .5, prevMy = .5;
+		return {
+			outputs: { smokeTexture: outTex },
+			getComputeNodes: (params) => {
+				const now = Date.now();
+				const dt = Math.min((now - lastTime) / 1e3, .033);
+				lastTime = now;
+				if (dt < .001) return null;
+				const getNum = (key, fallback) => {
+					const def = uniforms[key];
+					if (!def) return fallback;
+					if (typeof def.getCpuValue === "function") {
+						const v$1 = def.getCpuValue();
+						return typeof v$1 === "number" ? v$1 : fallback;
+					}
+					const v = def.uniform?.value;
+					return typeof v === "number" ? v : fallback;
+				};
+				const speed = getNum("speed", 2);
+				const dirRad = getNum("direction", 0) * Math.PI / 180;
+				const spreadHalf = Math.min(89 * Math.PI / 180, getNum("spread", 60) * Math.PI / 360);
+				const centerPos = uniforms.center.uniform.value;
+				const cpx = typeof centerPos === "object" ? centerPos.x ?? .5 : .5;
+				const cpy = typeof centerPos === "object" ? centerPos.y ?? .5 : .5;
+				const aspect = typeof window !== "undefined" && renderer?.domElement ? renderer.domElement.width / Math.max(1, renderer.domElement.height) : 1;
+				dtU.value = dt;
+				centerXU.value = cpx;
+				centerYU.value = 1 - cpy;
+				scaleU.value = getNum("scale", 1);
+				aspectU.value = aspect;
+				const emitPos = uniforms.emitFrom?.uniform?.value;
+				const epx = typeof emitPos === "object" ? emitPos.x ?? .5 : .5;
+				const epy = typeof emitPos === "object" ? emitPos.y ?? .5 : .5;
+				emitXU.value = epx * N;
+				emitYU.value = (1 - epy) * N;
+				const velMag = speed * N * .15;
+				emitVelXU.value = Math.sin(dirRad) * velMag;
+				emitVelYU.value = -Math.cos(dirRad) * velMag;
+				perpDirXU.value = Math.cos(dirRad);
+				perpDirYU.value = Math.sin(dirRad);
+				spreadFactorU.value = Math.tan(spreadHalf);
+				emitRadU.value = getNum("emitRadius", .03) * N;
+				emitIntensityU.value = getNum("intensity", .8);
+				densDissipU.value = getNum("dissipation", .5);
+				curlStrengthU.value = getNum("detail", 30);
+				gravityU.value = getNum("gravity", .5);
+				colorDecayU.value = getNum("colorDecay", 1);
+				const mouseInf = getNum("mouseInfluence", .5);
+				const mouseRad = getNum("mouseRadius", .12);
+				const mx = params?.pointer?.x ?? prevMx;
+				const my = params?.pointer?.y ?? prevMy;
+				const mdx = mx - prevMx, mdy = my - prevMy;
+				prevMx = mx;
+				prevMy = my;
+				const cursorSpeed = Math.sqrt(mdx * mdx + mdy * mdy);
+				const mouseRadGrid = mouseRad * N;
+				mouseRadSqU.value = mouseRadGrid * mouseRadGrid;
+				if (cursorSpeed > 5e-4 && mouseInf > 0) {
+					cursorXU.value = mx * N;
+					cursorYU.value = my * N;
+					cursorVelXU.value = mdx * N * 15 * mouseInf;
+					cursorVelYU.value = mdy * N * 15 * mouseInf;
+					mouseActiveU.value = 1;
+				} else mouseActiveU.value = 0;
+				renderer.compute(maskPass);
+				renderer.compute(splatPass);
+				renderer.compute(curlPass);
+				renderer.compute(vorticityPass);
+				renderer.compute(divergencePass);
+				for (let iter = 0; iter < JACOBI_ITERS; iter++) renderer.compute(jacobiPass);
+				renderer.compute(gradSubtractPass);
+				renderer.compute(advectVelPass);
+				renderer.compute(copyVelPass);
+				renderer.compute(advectDensPass);
+				renderer.compute(copyDensPass);
+				return [outputPass];
+			}
+		};
+	},
+	fragmentNode: ({ uniforms, onBeforeRender, onCleanup, computeOutputs }) => {
+		const shapeSdfUrl = uniforms.shapeSdfUrl.uniform.value;
+		const initialConfig = (() => {
+			const val = uniforms.shape.uniform.value;
+			try {
+				return JSON.parse(val);
+			} catch {
+				return {
+					type: "circleSDF",
+					radius: .35
+				};
+			}
+		})();
+		let sdfSampler;
+		if (shapeSdfUrl) sdfSampler = createSvgSdfSampler(shapeSdfUrl, onBeforeRender, onCleanup);
+		else sdfSampler = createAnalyticSdfSampler(uniforms.shapeType.uniform.value || initialConfig.type || "circleSDF", initialConfig, uniforms.shape, onBeforeRender);
+		let smokeField;
+		const N = computeOutputs?.smokeTexture ? GRID_GPU : GRID_CPU;
+		if (computeOutputs?.smokeTexture) smokeField = texture(computeOutputs.smokeTexture);
+		else {
+			const cpuN = GRID_CPU;
+			const cells = cpuN * cpuN;
+			const texData = new Float32Array(cells * 4);
+			const smokeTex = new DataTexture(texData, cpuN, cpuN, RGBAFormat, FloatType);
+			smokeTex.magFilter = LinearFilter$1;
+			smokeTex.minFilter = LinearFilter$1;
+			smokeTex.needsUpdate = true;
+			smokeField = texture(smokeTex);
+			const cpuGetNum = (key, fallback) => {
+				const def = uniforms[key];
+				if (!def) return fallback;
+				if (typeof def.getCpuValue === "function") {
+					const v$1 = def.getCpuValue();
+					return typeof v$1 === "number" ? v$1 : fallback;
+				}
+				const v = def.uniform?.value;
+				return typeof v === "number" ? v : fallback;
+			};
+			let lt = Date.now();
+			onBeforeRender(() => {
+				const now = Date.now();
+				const dt = Math.min((now - lt) / 1e3, .033);
+				lt = now;
+				if (dt < .001) return;
+				const ei = cpuGetNum("intensity", .8);
+				const dd = cpuGetNum("dissipation", .5);
+				const ep = uniforms.emitFrom?.uniform?.value;
+				const ex = (typeof ep === "object" ? ep.x ?? .5 : .5) * cpuN;
+				const ey = (1 - (typeof ep === "object" ? ep.y ?? .5 : .5)) * cpuN;
+				const er = cpuGetNum("emitRadius", .03) * cpuN;
+				for (let i = 0; i < cpuN; i++) for (let j = 0; j < cpuN; j++) {
+					const idx = i * cpuN + j;
+					const dx = j + .5 - ex, dy = i + .5 - ey;
+					const inf = Math.exp(-(dx * dx + dy * dy) / Math.max(1, er * er));
+					texData[idx * 4] = Math.max(0, (texData[idx * 4] + ei * inf * dt * 8) / (1 + dd * dt));
+					texData[idx * 4 + 1] = Math.min(1, texData[idx * 4 + 1] + dt * .4 * cpuGetNum("colorDecay", 1));
+				}
+				smokeTex.needsUpdate = true;
+			});
+			onCleanup(() => {
+				smokeTex.dispose();
+			});
+		}
+		const uv$1 = screenUV;
+		const aspect = viewportSize.x.div(viewportSize.y);
+		const centerPos = vec2(uniforms.center.uniform.x, uniforms.center.uniform.y.oneMinus());
+		const scale = uniforms.scale.uniform;
+		const sdfUV = vec2(uv$1.x.sub(centerPos.x).mul(aspect).div(scale).add(float(.5)), uv$1.y.sub(centerPos.y).div(scale).add(float(.5)));
+		const shapeMask = sdfSampler(sdfUV).x.negate().mul(float(N * 4)).clamp(float(0), float(1));
+		let smokeDensity, smokeAge;
+		if (computeOutputs?.smokeTexture) {
+			const px = float(1 / GRID_GPU);
+			const s0 = smokeField.sample(screenUV);
+			const s1 = smokeField.sample(screenUV.add(vec2(px, float(0))));
+			const s2 = smokeField.sample(screenUV.add(vec2(float(0), px)));
+			const s3 = smokeField.sample(screenUV.add(vec2(px.negate(), float(0))));
+			const s4 = smokeField.sample(screenUV.add(vec2(float(0), px.negate())));
+			smokeDensity = s0.x.mul(float(.5)).add(s1.x.mul(float(.125))).add(s2.x.mul(float(.125))).add(s3.x.mul(float(.125))).add(s4.x.mul(float(.125)));
+			smokeAge = s0.y.mul(float(.5)).add(s1.y.mul(float(.125))).add(s2.y.mul(float(.125))).add(s3.y.mul(float(.125))).add(s4.y.mul(float(.125)));
+		} else {
+			const s = smokeField.sample(screenUV);
+			smokeDensity = s.x;
+			smokeAge = s.y;
+		}
+		const smokeColor = mixColors(uniforms.colorA.uniform, uniforms.colorB.uniform, smokeAge, uniforms.colorSpace.uniform.value);
+		return vec4(smokeColor.x, smokeColor.y, smokeColor.z, smokeColor.w.mul(smokeDensity).mul(shapeMask));
+	}
+};
+var SmokeFill_default = componentDefinition;
+export { componentDefinition as n, SmokeFill_default as t };

package/dist/core/{VideoTexture-DnHIs4pp.js → VideoTexture-SWLe5c3m.js}

@@ -1,4 +1,4 @@
-import { t as needsVideoCanvasWorkaround } from "./browser-DTNngPey.js";
+import { t as needsVideoCanvasWorkaround } from "./browser-D8zonASQ.js";
 import { CanvasTexture, SRGBColorSpace, VideoTexture } from "three/webgpu";
 import { float, max, min, or, screenUV, select, step, texture, uniform, vec2, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {

package/dist/core/{WebcamTexture-XBDo2kgN.js → WebcamTexture-cXPyEumA.js}

@@ -1,4 +1,4 @@
-import { t as needsVideoCanvasWorkaround } from "./browser-DTNngPey.js";
+import { t as needsVideoCanvasWorkaround } from "./browser-D8zonASQ.js";
 import { CanvasTexture, SRGBColorSpace, VideoTexture } from "three/webgpu";
 import { float, max, min, or, screenUV, select, step, texture, uniform, vec2, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {