shaders 2.5.103 → 2.5.104

package/dist/core/Smoke-LIDjCv7f.js

@@ -0,0 +1,629 @@
+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 { 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 } from "three/tsl";
+var GRID_GPU = 256;
+var GRID_CPU = 56;
+var JACOBI_ITERS = 20;
+var PRESSURE_DISSIPATION = .8;
+var VELOCITY_DISSIPATION = .2;
+const componentDefinition = {
+	name: "Smoke",
+	category: "Interactive",
+	description: "Realistic fluid smoke simulation with vorticity dynamics",
+	props: {
+		colorA: {
+			default: "#fc83f9",
+			transform: transformColor,
+			description: "Color of fresh smoke",
+			ui: {
+				type: "color",
+				label: "Start Color",
+				group: "Colors"
+			}
+		},
+		colorB: {
+			default: "#c21c79",
+			transform: transformColor,
+			description: "Color smoke transitions to as it ages",
+			ui: {
+				type: "color",
+				label: "End Color",
+				group: "Colors"
+			}
+		},
+		emitFrom: {
+			default: {
+				x: .5,
+				y: 1
+			},
+			transform: transformPosition,
+			description: "The emission source point",
+			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: 20,
+			description: "Emission velocity strength",
+			ui: {
+				type: "range",
+				min: .1,
+				max: 50,
+				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: .08,
+			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: .2,
+			description: "How fast smoke fades over time",
+			ui: {
+				type: "range",
+				min: .1,
+				max: 3,
+				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",
+			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"
+			}
+		}
+	},
+	computeNode: ({ uniforms, onCleanup, 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 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 outTex = new StorageTexture(N, N);
+		outTex.type = FloatType;
+		const outTexNode = storageTexture(outTex);
+		onCleanup(() => {
+			outTex.dispose();
+		});
+		const dtU = uniform(.016);
+		const emitXU = uniform(128);
+		const emitYU = uniform(256);
+		const emitVelXU = uniform(0);
+		const emitVelYU = uniform(-50);
+		const perpDirXU = uniform(1);
+		const perpDirYU = uniform(0);
+		const spreadFactorU = uniform(.5);
+		const emitRadU = uniform(15);
+		const emitIntensityU = uniform(.7);
+		const densDissipU = uniform(1);
+		const curlStrengthU = uniform(30);
+		const gravityU = uniform(.5);
+		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 colorDecayU = uniform(1);
+		const splatPass = Fn(() => {
+			const idx = instanceIndex;
+			const j = idx.mod(gs);
+			const i = idx.div(gs);
+			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();
+			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));
+			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);
+			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 fx = gy.div(gl).mul(cc).mul(curlStrengthU).mul(dtU);
+			const fy = gx.div(gl).negate().mul(cc).mul(curlStrengthU).mul(dtU);
+			const vel = velA.element(idx);
+			velA.element(idx).assign(vec4(vel.x.add(fx), vel.y.add(fy), 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 selfVel = velA.element(idx);
+			const normalL = velA.element(nidx(ii, ji, 0, -1)).x;
+			const normalR = velA.element(nidx(ii, ji, 0, 1)).x;
+			const normalU = velA.element(nidx(ii, ji, -1, 0)).y;
+			const normalD = velA.element(nidx(ii, ji, 1, 0)).y;
+			const L = jf.lessThan(float(.5)).select(selfVel.x.negate(), normalL);
+			const R = jf.greaterThan(float(N - 1.5)).select(selfVel.x.negate(), normalR);
+			const T = iF.lessThan(float(.5)).select(selfVel.y.negate(), normalU);
+			const B = iF.greaterThan(float(N - 1.5)).select(selfVel.y.negate(), normalD);
+			const div$1 = R.sub(L).add(B.sub(T)).mul(float(.5));
+			const oldP = pressDivBuf.element(idx).x.mul(float(PRESSURE_DISSIPATION));
+			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));
+			velB.element(idx).assign(vec4(mix(mix(v00.x, v10.x, sx), mix(v01.x, v11.x, sx), sy).div(decay), mix(mix(v00.y, v10.y, sx), mix(v01.y, v11.y, sx), sy).div(decay), 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));
+			densB.element(idx).assign(vec4(dens.div(decay).max(float(0)), 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", 3);
+				const dirRad = getNum("direction", 0) * Math.PI / 180;
+				const spreadHalf = Math.min(89 * Math.PI / 180, getNum("spread", 45) * Math.PI / 360);
+				const emitPos = uniforms.emitFrom.uniform.value;
+				const epx = typeof emitPos === "object" ? emitPos.x ?? .5 : .5;
+				const epy = typeof emitPos === "object" ? emitPos.y ?? 0 : 0;
+				dtU.value = dt;
+				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", .06) * N;
+				emitIntensityU.value = getNum("intensity", .7);
+				densDissipU.value = getNum("dissipation", 1);
+				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;
+				const 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(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 }) => {
+		let smokeField;
+		if (computeOutputs?.smokeTexture) smokeField = texture(computeOutputs.smokeTexture);
+		else {
+			const cpuN = GRID_CPU;
+			const cells = cpuN * cpuN;
+			const vx = new Float32Array(cells);
+			const vy = new Float32Array(cells);
+			const vtx = new Float32Array(cells);
+			const vty = new Float32Array(cells);
+			const den = new Float32Array(cells);
+			const ag = new Float32Array(cells);
+			const dtmp = new Float32Array(cells);
+			const atmp = new Float32Array(cells);
+			const pres = new Float32Array(cells);
+			const divg = new Float32Array(cells);
+			const crl = new Float32Array(cells);
+			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();
+			let cpuPrevMx = .5, cpuPrevMy = .5;
+			const bl = (f, fx, fy) => {
+				const sx = Math.max(0, Math.min(cpuN - 1, fx));
+				const sy = Math.max(0, Math.min(cpuN - 1, fy));
+				const x0 = Math.max(0, Math.min(cpuN - 2, Math.floor(sx)));
+				const y0 = Math.max(0, Math.min(cpuN - 2, Math.floor(sy)));
+				const tx = sx - x0, ty = sy - y0;
+				const i00 = y0 * cpuN + x0;
+				return (1 - tx) * (1 - ty) * f[i00] + tx * (1 - ty) * f[i00 + 1] + (1 - tx) * ty * f[i00 + cpuN] + tx * ty * f[i00 + cpuN + 1];
+			};
+			const ni = (i, j, di, dj) => Math.max(0, Math.min(cpuN - 1, i + di)) * cpuN + Math.max(0, Math.min(cpuN - 1, j + dj));
+			onBeforeRender(({ pointer }) => {
+				const now = Date.now();
+				const dt = Math.min((now - lt) / 1e3, .033);
+				lt = now;
+				if (dt < .001) return;
+				const sp = cpuGetNum("speed", 3);
+				const dr = uniforms.direction.uniform.value * Math.PI / 180;
+				const sh = Math.min(89 * Math.PI / 180, uniforms.spread.uniform.value * Math.PI / 360);
+				const ep = uniforms.emitFrom.uniform.value;
+				const ex = (typeof ep === "object" ? ep.x ?? .5 : .5) * cpuN;
+				const ey = (1 - (typeof ep === "object" ? ep.y ?? 0 : 0)) * cpuN;
+				const vm = sp * cpuN * .15;
+				const evx = Math.sin(dr) * vm, evy = -Math.cos(dr) * vm;
+				const px = Math.cos(dr), py = Math.sin(dr), sf = Math.tan(sh);
+				const er = uniforms.emitRadius.uniform.value * cpuN;
+				const ei = uniforms.intensity.uniform.value;
+				const cv = cpuGetNum("detail", 30);
+				const bv = cpuGetNum("gravity", .5);
+				const cd = cpuGetNum("colorDecay", 1);
+				const dd = cpuGetNum("dissipation", .2);
+				const mi = uniforms.mouseInfluence.uniform.value;
+				const mr = uniforms.mouseRadius.uniform.value * cpuN;
+				const mx = pointer?.x ?? cpuPrevMx;
+				const my = pointer?.y ?? cpuPrevMy;
+				const mdx = mx - cpuPrevMx, mdy = my - cpuPrevMy;
+				cpuPrevMx = mx;
+				cpuPrevMy = my;
+				const cActive = Math.sqrt(mdx * mdx + mdy * mdy) > 5e-4 && mi > 0;
+				const cvx = cActive ? mdx * cpuN * 15 * mi : 0;
+				const cvy = cActive ? mdy * cpuN * 15 * mi : 0;
+				const cxGrid = mx * cpuN, cyGrid = my * 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));
+					const od = den[idx], ad = ei * inf * dt * 8;
+					const nd = Math.min(1, od + ad);
+					ag[idx] *= 1 - Math.min(1, ad / Math.max(.001, nd));
+					den[idx] = nd;
+					const po = (dx * px + dy * py) / Math.max(1, er);
+					const vms = Math.sqrt(evx * evx + evy * evy);
+					const tvx2 = evx + px * po * sf * vms, tvy2 = evy + py * po * sf * vms;
+					const br = Math.min(1, inf * dt * 3);
+					const cdx = j + .5 - cxGrid, cdy = i + .5 - cyGrid;
+					const cinf = cActive ? Math.exp(-(cdx * cdx + cdy * cdy) / Math.max(1, mr * mr)) : 0;
+					vx[idx] = vx[idx] * (1 - br) + tvx2 * br + cvx * cinf;
+					vy[idx] = vy[idx] * (1 - br) + tvy2 * br + bv * od * dt * cpuN * .08 + cvy * cinf;
+				}
+				if (cv > 0) {
+					for (let i = 0; i < cpuN; i++) for (let j = 0; j < cpuN; j++) crl[i * cpuN + j] = .5 * (vy[ni(i, j, 0, 1)] - vy[ni(i, j, 0, -1)] - (vx[ni(i, j, 1, 0)] - vx[ni(i, j, -1, 0)]));
+					for (let i = 0; i < cpuN; i++) for (let j = 0; j < cpuN; j++) {
+						const idx = i * cpuN + j;
+						const gx = .5 * (Math.abs(crl[ni(i, j, 0, 1)]) - Math.abs(crl[ni(i, j, 0, -1)]));
+						const gy = .5 * (Math.abs(crl[ni(i, j, 1, 0)]) - Math.abs(crl[ni(i, j, -1, 0)]));
+						const gl = Math.max(1e-5, Math.sqrt(gx * gx + gy * gy));
+						vx[idx] += gy / gl * crl[idx] * cv * dt;
+						vy[idx] += -(gx / gl) * crl[idx] * cv * dt;
+					}
+				}
+				for (let i = 0; i < cpuN; i++) for (let j = 0; j < cpuN; j++) {
+					const idx = i * cpuN + j;
+					const L = j === 0 ? -vx[idx] : vx[ni(i, j, 0, -1)];
+					const R = j === cpuN - 1 ? -vx[idx] : vx[ni(i, j, 0, 1)];
+					const T = i === 0 ? -vy[idx] : vy[ni(i, j, -1, 0)];
+					const B = i === cpuN - 1 ? -vy[idx] : vy[ni(i, j, 1, 0)];
+					divg[idx] = .5 * (R - L + B - T);
+					pres[idx] *= PRESSURE_DISSIPATION;
+				}
+				for (let it = 0; it < 6; it++) for (let i = 0; i < cpuN; i++) for (let j = 0; j < cpuN; j++) {
+					const idx = i * cpuN + j;
+					pres[idx] = .25 * (pres[ni(i, j, 0, -1)] + pres[ni(i, j, 0, 1)] + pres[ni(i, j, -1, 0)] + pres[ni(i, j, 1, 0)] - divg[idx]);
+				}
+				for (let i = 0; i < cpuN; i++) for (let j = 0; j < cpuN; j++) {
+					const idx = i * cpuN + j;
+					vx[idx] -= .5 * (pres[ni(i, j, 0, 1)] - pres[ni(i, j, 0, -1)]);
+					vy[idx] -= .5 * (pres[ni(i, j, 1, 0)] - pres[ni(i, j, -1, 0)]);
+				}
+				const vDecay = 1 + VELOCITY_DISSIPATION * dt;
+				for (let i = 0; i < cpuN; i++) for (let j = 0; j < cpuN; j++) {
+					const idx = i * cpuN + j;
+					vtx[idx] = bl(vx, j - vx[idx] * dt, i - vy[idx] * dt) / vDecay;
+					vty[idx] = bl(vy, j - vx[idx] * dt, i - vy[idx] * dt) / vDecay;
+				}
+				vx.set(vtx);
+				vy.set(vty);
+				const dDecay = 1 + dd * dt;
+				for (let i = 0; i < cpuN; i++) for (let j = 0; j < cpuN; j++) {
+					const idx = i * cpuN + j;
+					const sx = j - vx[idx] * dt, sy = i - vy[idx] * dt;
+					dtmp[idx] = Math.max(0, bl(den, sx, sy) / dDecay);
+					atmp[idx] = Math.min(1, bl(ag, sx, sy) + dt * .4 * cd);
+				}
+				den.set(dtmp);
+				ag.set(atmp);
+				for (let i = 0; i < cells; i++) {
+					texData[i * 4] = den[i];
+					texData[i * 4 + 1] = ag[i];
+				}
+				smokeTex.needsUpdate = true;
+			});
+			onCleanup(() => {
+				smokeTex.dispose();
+			});
+		}
+		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));
+	}
+};
+var Smoke_default = componentDefinition;
+export { componentDefinition as n, Smoke_default as t };