shaders 2.5.103 → 2.5.104

package/dist/core/Fog-DhFHErOx.js

@@ -0,0 +1,674 @@
+import { a as transformColor, 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, cos, float, floor, fract, instanceIndex, int, mix, mod, screenUV, sin, storageTexture, texture, textureStore, uint, uniform, uvec2, vec2, vec4 } from "three/tsl";
+var GRID_GPU = 256;
+var GRID_CPU = 64;
+var JACOBI_ITERS = 20;
+var PRESSURE_DISSIPATION = .8;
+var VELOCITY_DISSIPATION = .15;
+var INTERNAL_MAX_VEL = GRID_GPU * .6;
+const componentDefinition = {
+	name: "Fog",
+	category: "Interactive",
+	description: "Fog that fills the screen and interacts with the mouse",
+	props: {
+		colorA: {
+			default: "#e0e0e0",
+			transform: transformColor,
+			description: "Primary fog color",
+			ui: {
+				type: "color",
+				label: "Color A",
+				group: "Colors"
+			}
+		},
+		colorB: {
+			default: "#888888",
+			transform: transformColor,
+			description: "Secondary fog color — creates variation across the field",
+			ui: {
+				type: "color",
+				label: "Color B",
+				group: "Colors"
+			}
+		},
+		seed: {
+			default: 0,
+			description: "Deterministic starting pattern — different seeds produce different fog configurations",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 999,
+				step: 1,
+				label: "Seed",
+				group: "Field"
+			}
+		},
+		speed: {
+			default: 1,
+			description: "Simulation speed multiplier",
+			ui: {
+				type: "range",
+				min: .1,
+				max: 3,
+				step: .1,
+				label: "Speed",
+				group: "Field"
+			}
+		},
+		turbulence: {
+			default: 1,
+			description: "Ambient motion strength",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 3,
+				step: .05,
+				label: "Turbulence",
+				group: "Field"
+			}
+		},
+		detail: {
+			default: 15,
+			description: "Fine-scale swirling structure — higher values produce more intricate wisps and vortices",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 50,
+				step: 1,
+				label: "Detail",
+				group: "Field"
+			}
+		},
+		blending: {
+			default: .3,
+			description: "How much the two colors blend together — 0 behaves like oil & water (colors stay distinct with sharp boundaries), 1 behaves like food coloring (colors fully mix)",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .05,
+				label: "Blending",
+				group: "Field"
+			}
+		},
+		mouseInfluence: {
+			default: .1,
+			description: "Strength of cursor influence — move the cursor to push fog",
+			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 Nf = float(N);
+		const TAU = float(Math.PI * 2);
+		const count = N * N;
+		const nw = (ii, ji, di, dj) => ii.add(int(di)).add(Ni).mod(Ni).mul(Ni).add(ji.add(int(dj)).add(Ni).mod(Ni));
+		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 valueNoise2D = Fn(([nx, ny]) => {
+			const ix = floor(nx), iy = floor(ny);
+			const sx = fract(nx), sy = fract(ny);
+			const ux = sx.mul(sx).mul(float(3).sub(sx.mul(float(2))));
+			const uy = sy.mul(sy).mul(float(3).sub(sy.mul(float(2))));
+			const h = (px, py) => fract(sin(px.mul(float(127.1)).add(py.mul(float(311.7)))).mul(float(43758.5453)));
+			return mix(mix(h(ix, iy), h(ix.add(float(1)), iy), ux), mix(h(ix, iy.add(float(1))), h(ix.add(float(1)), iy.add(float(1))), ux), uy);
+		});
+		const fbm = Fn(([nx, ny]) => valueNoise2D(nx, ny).mul(float(.5)).add(valueNoise2D(nx.mul(float(2)).add(float(5.37)), ny.mul(float(2)).add(float(9.13))).mul(float(.3))).add(valueNoise2D(nx.mul(float(4)).add(float(1.79)), ny.mul(float(4)).add(float(3.51))).mul(float(.2))));
+		const outTex = new StorageTexture(N, N);
+		outTex.type = FloatType;
+		const outTexNode = storageTexture(outTex);
+		onCleanup(() => {
+			outTex.dispose();
+		});
+		const dtU = uniform(.016);
+		const timeU = uniform(0);
+		const seedU = uniform(0);
+		const turbulenceU = uniform(.3);
+		const curlStrengthU = uniform(25);
+		const blendingU = uniform(.3);
+		const cursorXU = uniform(128);
+		const cursorYU = uniform(128);
+		const cursorVelXU = uniform(0);
+		const cursorVelYU = uniform(0);
+		const mouseActiveU = uniform(0);
+		const mouseRadSqU = uniform(1500);
+		const initPass = Fn(() => {
+			const idx = instanceIndex;
+			const jf = idx.mod(gs).toFloat();
+			const iF = idx.div(gs).toFloat();
+			const sdx = fract(sin(seedU.mul(float(37.31))).mul(float(43758.5453))).mul(float(97));
+			const sdy = fract(sin(seedU.mul(float(83.17))).mul(float(43758.5453))).mul(float(97));
+			const nx = jf.div(Nf).mul(float(3)).add(sdx);
+			const ny = iF.div(Nf).mul(float(3)).add(sdy);
+			const fogDens = fbm(nx.add(float(31.7)), ny.add(float(53.3))).mul(float(.75)).add(float(.25)).clamp(float(.15), float(.9));
+			const colorVar = fbm(nx, ny).clamp(float(0), float(1));
+			densA.element(idx).assign(vec4(fogDens, colorVar, float(0), float(0)));
+			densB.element(idx).assign(vec4(fogDens, colorVar, float(0), float(0)));
+			velA.element(idx).assign(vec4(float(0), float(0), float(0), float(0)));
+			velB.element(idx).assign(vec4(float(0), float(0), float(0), float(0)));
+			pressDivBuf.element(idx).assign(vec4(float(0), float(0), float(0), float(0)));
+		})().compute(count, [256]);
+		const forcePass = Fn(() => {
+			const idx = instanceIndex;
+			const j = idx.mod(gs);
+			const i = idx.div(gs);
+			const jf = j.toFloat().add(float(.5));
+			const iF = i.toFloat().add(float(.5));
+			const x = jf.div(Nf).mul(TAU);
+			const y = iF.div(Nf).mul(TAU);
+			const vel = velA.element(idx);
+			const t = timeU;
+			const fx = sin(x.mul(float(2)).add(t.mul(float(.31)))).mul(cos(y.mul(float(1.5)).add(t.mul(float(.23))))).add(sin(x.mul(float(.7)).add(y.mul(float(1.3))).add(t.mul(float(.17)))).mul(float(.4))).mul(turbulenceU).mul(float(N * .04)).mul(dtU);
+			const fy = cos(x.mul(float(1.5)).add(t.mul(float(.27)))).mul(sin(y.mul(float(2)).add(t.mul(float(.19))))).add(cos(x.mul(float(1.1)).add(y.mul(float(.9))).add(t.mul(float(.21)))).mul(float(.4))).mul(turbulenceU).mul(float(N * .04)).mul(dtU);
+			const cellX = jf;
+			const cellY = iF;
+			const cdx = cellX.sub(cursorXU);
+			const cdy = cellY.sub(cursorYU);
+			const cursorInf = cdx.mul(cdx).add(cdy.mul(cdy)).negate().div(mouseRadSqU.max(float(1))).exp().mul(mouseActiveU);
+			const newVx = vel.x.add(fx).add(cursorVelXU.mul(cursorInf));
+			const newVy = vel.y.add(fy).add(cursorVelYU.mul(cursorInf));
+			velA.element(idx).assign(vec4(newVx, newVy, 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(nw(ii, ji, 0, -1));
+			const vR = velA.element(nw(ii, ji, 0, 1));
+			const vU = velA.element(nw(ii, ji, -1, 0));
+			const vD = velA.element(nw(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(nw(ii, ji, 0, -1)).z.abs();
+			const cR = velA.element(nw(ii, ji, 0, 1)).z.abs();
+			const cU = velA.element(nw(ii, ji, -1, 0)).z.abs();
+			const cD = velA.element(nw(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 vL = velA.element(nw(ii, ji, 0, -1)).x;
+			const vR = velA.element(nw(ii, ji, 0, 1)).x;
+			const vU = velA.element(nw(ii, ji, -1, 0)).y;
+			const vD = velA.element(nw(ii, ji, 1, 0)).y;
+			const div$1 = vR.sub(vL).add(vD.sub(vU)).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(nw(ii, ji, 0, -1)).x;
+			const pR = pressDivBuf.element(nw(ii, ji, 0, 1)).x;
+			const pU = pressDivBuf.element(nw(ii, ji, -1, 0)).x;
+			const pD = pressDivBuf.element(nw(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(nw(ii, ji, 0, -1)).x;
+			const pR = pressDivBuf.element(nw(ii, ji, 0, 1)).x;
+			const pU = pressDivBuf.element(nw(ii, ji, -1, 0)).x;
+			const pD = pressDivBuf.element(nw(ii, ji, 1, 0)).x;
+			const vel = velA.element(idx);
+			const vx = vel.x.sub(pR.sub(pL).mul(float(.5)));
+			const vy = vel.y.sub(pD.sub(pU).mul(float(.5)));
+			const maxVel = float(INTERNAL_MAX_VEL);
+			const vLen = vx.mul(vx).add(vy.mul(vy)).sqrt().max(float(1e-6));
+			const capScale = maxVel.div(vLen.max(maxVel));
+			velA.element(idx).assign(vec4(vx.mul(capScale), vy.mul(capScale), 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 = mod(j.toFloat().sub(vel.x.mul(dtU)).add(Nf), Nf);
+			const srcY = mod(i.toFloat().sub(vel.y.mul(dtU)).add(Nf), Nf);
+			const x0 = floor(srcX);
+			const y0 = floor(srcY);
+			const sx = srcX.sub(x0);
+			const sy = srcY.sub(y0);
+			const ix0 = x0.toInt();
+			const iy0 = y0.toInt();
+			const ix1 = ix0.add(int(1)).mod(Ni);
+			const iy1 = iy0.add(int(1)).mod(Ni);
+			const v00 = velA.element(iy0.mul(Ni).add(ix0));
+			const v10 = velA.element(iy0.mul(Ni).add(ix1));
+			const v01 = velA.element(iy1.mul(Ni).add(ix0));
+			const v11 = velA.element(iy1.mul(Ni).add(ix1));
+			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 = mod(j.toFloat().sub(vel.x.mul(dtU)).add(Nf), Nf);
+			const srcY = mod(i.toFloat().sub(vel.y.mul(dtU)).add(Nf), Nf);
+			const x0 = floor(srcX);
+			const y0 = floor(srcY);
+			const sx = srcX.sub(x0);
+			const sy = srcY.sub(y0);
+			const ix0 = x0.toInt();
+			const iy0 = y0.toInt();
+			const ix1 = ix0.add(int(1)).mod(Ni);
+			const iy1 = iy0.add(int(1)).mod(Ni);
+			const d00 = densA.element(iy0.mul(Ni).add(ix0));
+			const d10 = densA.element(iy0.mul(Ni).add(ix1));
+			const d01 = densA.element(iy1.mul(Ni).add(ix0));
+			const d11 = densA.element(iy1.mul(Ni).add(ix1));
+			densB.element(idx).assign(vec4(mix(mix(d00.x, d10.x, sx), mix(d01.x, d11.x, sx), sy), mix(mix(d00.y, d10.y, sx), mix(d01.y, d11.y, sx), sy), 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 colorRestorePass = Fn(() => {
+			const idx = instanceIndex;
+			const jf = idx.mod(gs).toFloat();
+			const iF = idx.div(gs).toFloat();
+			const sdx2 = fract(sin(seedU.mul(float(37.31))).mul(float(43758.5453))).mul(float(97));
+			const sdy2 = fract(sin(seedU.mul(float(83.17))).mul(float(43758.5453))).mul(float(97));
+			const refRaw = fbm(jf.div(Nf).mul(float(3)).add(sdx2), iF.div(Nf).mul(float(3)).add(sdy2));
+			const invBlend = float(1).sub(blendingU);
+			const contrastBoost = float(1).add(invBlend.mul(float(5)));
+			const refBoosted = refRaw.sub(float(.5)).mul(contrastBoost).add(float(.5)).clamp(float(0), float(1));
+			const cell = densA.element(idx);
+			const rateMult = float(1).add(invBlend.mul(float(2.5)));
+			const blendRate = dtU.mul(float(.5)).mul(rateMult).min(float(.3));
+			densA.element(idx).assign(vec4(cell.x, mix(cell.y, refBoosted, blendRate), 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 elapsed = 0;
+		let prevMx = .5, prevMy = .5;
+		let lastSeed = -1;
+		let initialized = false;
+		return {
+			outputs: { fogTexture: outTex },
+			getComputeNodes: (params) => {
+				const now = Date.now();
+				const rawDt = Math.min((now - lastTime) / 1e3, .033);
+				lastTime = now;
+				if (rawDt < .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 dt = rawDt * getNum("speed", 1);
+				elapsed += rawDt;
+				const seed = Number(uniforms.seed.uniform.value ?? 0);
+				if (!initialized || seed !== lastSeed) {
+					initialized = true;
+					lastSeed = seed;
+					seedU.value = seed;
+					const warmDt = .05;
+					turbulenceU.value = getNum("turbulence", 1);
+					curlStrengthU.value = getNum("detail", 15);
+					blendingU.value = getNum("blending", .3);
+					dtU.value = warmDt;
+					renderer.compute(initPass);
+					let warmTime = Math.random() * 60;
+					for (let w = 0; w < 100; w++) {
+						timeU.value = warmTime;
+						warmTime += warmDt;
+						renderer.compute(forcePass);
+						renderer.compute(curlPass);
+						renderer.compute(vorticityPass);
+						renderer.compute(divergencePass);
+						for (let iter = 0; iter < 10; iter++) renderer.compute(jacobiPass);
+						renderer.compute(gradSubtractPass);
+						renderer.compute(advectVelPass);
+						renderer.compute(copyVelPass);
+						renderer.compute(advectDensPass);
+						renderer.compute(copyDensPass);
+						renderer.compute(colorRestorePass);
+					}
+					elapsed = warmTime;
+				}
+				dtU.value = dt;
+				timeU.value = elapsed;
+				turbulenceU.value = getNum("turbulence", 1);
+				curlStrengthU.value = getNum("detail", 15);
+				blendingU.value = getNum("blending", .3);
+				const mouseInf = getNum("mouseInfluence", .1);
+				const mouseRad = getNum("mouseRadius", .1) * GRID_GPU;
+				const mx = params?.pointer?.x ?? prevMx;
+				const my = params?.pointer?.y ?? prevMy;
+				const mdx = mx - prevMx, mdy = my - prevMy;
+				prevMx = mx;
+				prevMy = my;
+				const cspeed = Math.sqrt(mdx * mdx + mdy * mdy);
+				mouseRadSqU.value = mouseRad * mouseRad;
+				if (cspeed > 5e-4 && mouseInf > 0) {
+					cursorXU.value = mx * GRID_GPU;
+					cursorYU.value = my * GRID_GPU;
+					cursorVelXU.value = mdx * GRID_GPU * 15 * mouseInf;
+					cursorVelYU.value = mdy * GRID_GPU * 15 * mouseInf;
+					mouseActiveU.value = 1;
+				} else mouseActiveU.value = 0;
+				renderer.compute(forcePass);
+				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);
+				renderer.compute(colorRestorePass);
+				return [outputPass];
+			}
+		};
+	},
+	fragmentNode: ({ uniforms, onBeforeRender, onCleanup, computeOutputs }) => {
+		let fogField;
+		const N = computeOutputs?.fogTexture ? GRID_GPU : GRID_CPU;
+		if (computeOutputs?.fogTexture) fogField = texture(computeOutputs.fogTexture);
+		else {
+			const cpuN = GRID_CPU;
+			const cells = cpuN * cpuN;
+			const vx = new Float32Array(cells), vy = new Float32Array(cells);
+			const vtx = new Float32Array(cells), vty = new Float32Array(cells);
+			const den = new Float32Array(cells), cv = new Float32Array(cells);
+			const dtmp = new Float32Array(cells), ctmp = new Float32Array(cells);
+			const pres = new Float32Array(cells), divg = new Float32Array(cells);
+			const curlArr = new Float32Array(cells);
+			const texData = new Float32Array(cells * 4);
+			const fogTex = new DataTexture(texData, cpuN, cpuN, RGBAFormat, FloatType);
+			fogTex.magFilter = LinearFilter$1;
+			fogTex.minFilter = LinearFilter$1;
+			fogTex.needsUpdate = true;
+			fogField = texture(fogTex);
+			const hashF = (px$1, py) => {
+				const s = Math.sin(px$1 * 127.1 + py * 311.7) * 43758.5453;
+				return s - Math.floor(s);
+			};
+			const valueNoiseCPU = (nx, ny) => {
+				const ix = Math.floor(nx), iy = Math.floor(ny);
+				const fx = nx - ix, fy = ny - iy;
+				const sx = fx * fx * (3 - 2 * fx), sy = fy * fy * (3 - 2 * fy);
+				return (1 - sy) * ((1 - sx) * hashF(ix, iy) + sx * hashF(ix + 1, iy)) + sy * ((1 - sx) * hashF(ix, iy + 1) + sx * hashF(ix + 1, iy + 1));
+			};
+			const fbmCPU = (nx, ny) => valueNoiseCPU(nx, ny) * .5 + valueNoiseCPU(nx * 2 + 5.37, ny * 2 + 9.13) * .3 + valueNoiseCPU(nx * 4 + 1.79, ny * 4 + 3.51) * .2;
+			const cpuSeedOffset = (seed) => {
+				const sx2 = (x) => {
+					const s = Math.sin(x) * 43758.5453;
+					return s - Math.floor(s);
+				};
+				return {
+					sdx: sx2(seed * 37.31) * 97,
+					sdy: sx2(seed * 83.17) * 97
+				};
+			};
+			const cpuRefColorVar = (j, i, seed) => {
+				const { sdx, sdy } = cpuSeedOffset(seed);
+				const nx = (j + .5) / cpuN * 3 + sdx;
+				const ny = (i + .5) / cpuN * 3 + sdy;
+				return Math.max(0, Math.min(1, fbmCPU(nx, ny)));
+			};
+			const initCPU = (seed) => {
+				vx.fill(0);
+				vy.fill(0);
+				const { sdx, sdy } = cpuSeedOffset(seed);
+				for (let i = 0; i < cpuN; i++) for (let j = 0; j < cpuN; j++) {
+					const idx = i * cpuN + j;
+					const nx = (j + .5) / cpuN * 3 + sdx;
+					const ny = (i + .5) / cpuN * 3 + sdy;
+					den[idx] = Math.max(.15, Math.min(.9, fbmCPU(nx + 31.7, ny + 53.3) * .75 + .25));
+					cv[idx] = Math.max(0, Math.min(1, fbmCPU(nx, ny)));
+				}
+			};
+			let lt = Date.now(), elapsed = 0;
+			let prevMx = .5, prevMy = .5, lastSeed = -1;
+			const safeWrap = (x) => (x % cpuN + cpuN) % cpuN;
+			const blWrap = (f, fx, fy) => {
+				const sx = (fx % cpuN + cpuN) % cpuN;
+				const sy = (fy % cpuN + cpuN) % cpuN;
+				const x0 = Math.floor(sx) % cpuN, y0 = Math.floor(sy) % cpuN;
+				const x1 = (x0 + 1) % cpuN, y1 = (y0 + 1) % cpuN;
+				const tx = sx - x0, ty = sy - y0;
+				return (1 - tx) * (1 - ty) * f[y0 * cpuN + x0] + tx * (1 - ty) * f[y0 * cpuN + x1] + (1 - tx) * ty * f[y1 * cpuN + x0] + tx * ty * f[y1 * cpuN + x1];
+			};
+			const nw2 = (i, j, di, dj) => safeWrap(i + di) * cpuN + safeWrap(j + dj);
+			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;
+			};
+			onBeforeRender(({ pointer }) => {
+				const now = Date.now();
+				const rawDt = Math.min((now - lt) / 1e3, .033);
+				lt = now;
+				if (rawDt < .001) return;
+				const seed = Number(uniforms.seed.uniform.value ?? 0);
+				if (seed !== lastSeed) {
+					lastSeed = seed;
+					initCPU(seed);
+					const wTurb = cpuGetNum("turbulence", 1);
+					const wInvBlend = 1 - cpuGetNum("blending", .3);
+					const wBoost = 1 + wInvBlend * 5;
+					const wRateMult = 1 + wInvBlend * 2.5;
+					const wDt = .05;
+					let wt = Math.random() * 60;
+					const wMaxVel = cpuN * .6;
+					for (let w = 0; w < 60; w++) {
+						const tau2 = Math.PI * 2;
+						for (let i = 0; i < cpuN; i++) for (let j = 0; j < cpuN; j++) {
+							const idx = i * cpuN + j;
+							const x = (j + .5) / cpuN * tau2, y = (i + .5) / cpuN * tau2;
+							vx[idx] += Math.sin(2 * x + wt * .31) * Math.cos(1.5 * y + wt * .23) * wTurb * cpuN * .04 * wDt;
+							vy[idx] += Math.cos(1.5 * x + wt * .27) * Math.sin(2 * y + wt * .19) * wTurb * cpuN * .04 * wDt;
+							const vl = Math.sqrt(vx[idx] * vx[idx] + vy[idx] * vy[idx]);
+							if (vl > wMaxVel) {
+								vx[idx] *= wMaxVel / vl;
+								vy[idx] *= wMaxVel / vl;
+							}
+						}
+						for (let i = 0; i < cpuN; i++) for (let j = 0; j < cpuN; j++) {
+							const idx = i * cpuN + j;
+							dtmp[idx] = blWrap(den, j - vx[idx] * wDt, i - vy[idx] * wDt);
+							ctmp[idx] = blWrap(cv, j - vx[idx] * wDt, i - vy[idx] * wDt);
+						}
+						den.set(dtmp);
+						cv.set(ctmp);
+						const br = Math.min(.3, wDt * .5 * wRateMult);
+						for (let i2 = 0; i2 < cpuN; i2++) for (let j2 = 0; j2 < cpuN; j2++) {
+							const refRaw = cpuRefColorVar(j2, i2, seed);
+							const refBoosted = Math.max(0, Math.min(1, (refRaw - .5) * wBoost + .5));
+							cv[i2 * cpuN + j2] = cv[i2 * cpuN + j2] * (1 - br) + refBoosted * br;
+						}
+						wt += wDt;
+					}
+					elapsed = wt;
+				}
+				const dt = rawDt * cpuGetNum("speed", 1);
+				elapsed += rawDt;
+				const t = elapsed;
+				const turb = cpuGetNum("turbulence", 1);
+				const curl = cpuGetNum("detail", 15);
+				const blending = cpuGetNum("blending", .3);
+				const mi = cpuGetNum("mouseInfluence", .1);
+				const mr = cpuGetNum("mouseRadius", .1) * cpuN;
+				const mx = pointer?.x ?? prevMx, my = pointer?.y ?? prevMy;
+				const mdx = mx - prevMx, mdy = my - prevMy;
+				prevMx = mx;
+				prevMy = my;
+				const cActive = Math.sqrt(mdx * mdx + mdy * mdy) > 5e-4 && mi > 0;
+				const maxVel = cpuN * .6;
+				const tau = Math.PI * 2;
+				for (let i = 0; i < cpuN; i++) for (let j = 0; j < cpuN; j++) {
+					const idx = i * cpuN + j;
+					const x = (j + .5) / cpuN * tau, y = (i + .5) / cpuN * tau;
+					const fx = Math.sin(2 * x + t * .31) * Math.cos(1.5 * y + t * .23) * turb * cpuN * .04 * dt;
+					const fy = Math.cos(1.5 * x + t * .27) * Math.sin(2 * y + t * .19) * turb * cpuN * .04 * dt;
+					let cvxF = 0, cvyF = 0;
+					if (cActive) {
+						const cdx = j + .5 - mx * cpuN, cdy = i + .5 - my * cpuN;
+						const cinf = Math.exp(-(cdx * cdx + cdy * cdy) / Math.max(1, mr * mr));
+						cvxF = mdx * cpuN * 15 * mi * cinf;
+						cvyF = mdy * cpuN * 15 * mi * cinf;
+					}
+					vx[idx] += fx + cvxF;
+					vy[idx] += fy + cvyF;
+				}
+				if (curl > 0) {
+					for (let i = 0; i < cpuN; i++) for (let j = 0; j < cpuN; j++) curlArr[i * cpuN + j] = .5 * (vy[nw2(i, j, 0, 1)] - vy[nw2(i, j, 0, -1)] - (vx[nw2(i, j, 1, 0)] - vx[nw2(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(curlArr[nw2(i, j, 0, 1)]) - Math.abs(curlArr[nw2(i, j, 0, -1)]));
+						const gy = .5 * (Math.abs(curlArr[nw2(i, j, 1, 0)]) - Math.abs(curlArr[nw2(i, j, -1, 0)]));
+						const gl = Math.max(1e-5, Math.sqrt(gx * gx + gy * gy));
+						vx[idx] += gy / gl * curlArr[idx] * curl * dt;
+						vy[idx] += -(gx / gl) * curlArr[idx] * curl * dt;
+					}
+				}
+				for (let i = 0; i < cpuN; i++) for (let j = 0; j < cpuN; j++) {
+					const idx = i * cpuN + j;
+					divg[idx] = .5 * (vx[nw2(i, j, 0, 1)] - vx[nw2(i, j, 0, -1)] + vy[nw2(i, j, 1, 0)] - vy[nw2(i, j, -1, 0)]);
+					pres[idx] *= .8;
+				}
+				for (let it = 0; it < 12; it++) for (let i = 0; i < cpuN; i++) for (let j = 0; j < cpuN; j++) {
+					const idx = i * cpuN + j;
+					pres[idx] = .25 * (pres[nw2(i, j, 0, -1)] + pres[nw2(i, j, 0, 1)] + pres[nw2(i, j, -1, 0)] + pres[nw2(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[nw2(i, j, 0, 1)] - pres[nw2(i, j, 0, -1)]);
+					vy[idx] -= .5 * (pres[nw2(i, j, 1, 0)] - pres[nw2(i, j, -1, 0)]);
+					const vlen = Math.sqrt(vx[idx] * vx[idx] + vy[idx] * vy[idx]);
+					if (vlen > maxVel) {
+						vx[idx] *= maxVel / vlen;
+						vy[idx] *= maxVel / vlen;
+					}
+				}
+				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] = blWrap(vx, j - vx[idx] * dt, i - vy[idx] * dt) / vDecay;
+					vty[idx] = blWrap(vy, j - vx[idx] * dt, i - vy[idx] * dt) / vDecay;
+				}
+				vx.set(vtx);
+				vy.set(vty);
+				for (let i = 0; i < cpuN; i++) for (let j = 0; j < cpuN; j++) {
+					const idx = i * cpuN + j;
+					dtmp[idx] = blWrap(den, j - vx[idx] * dt, i - vy[idx] * dt);
+					ctmp[idx] = blWrap(cv, j - vx[idx] * dt, i - vy[idx] * dt);
+				}
+				den.set(dtmp);
+				cv.set(ctmp);
+				const invBlend = 1 - blending;
+				const contrastBoost = 1 + invBlend * 5;
+				const rateMult = 1 + invBlend * 2.5;
+				const blendRate = Math.min(.3, dt * .5 * rateMult);
+				const seed2 = Number(uniforms.seed.uniform.value ?? 0);
+				for (let i = 0; i < cpuN; i++) for (let j = 0; j < cpuN; j++) {
+					const idx = i * cpuN + j;
+					const refRaw = cpuRefColorVar(j, i, seed2);
+					const refBoosted = Math.max(0, Math.min(1, (refRaw - .5) * contrastBoost + .5));
+					cv[idx] = cv[idx] * (1 - blendRate) + refBoosted * blendRate;
+				}
+				for (let i = 0; i < cells; i++) {
+					texData[i * 4] = den[i];
+					texData[i * 4 + 1] = cv[i];
+				}
+				fogTex.needsUpdate = true;
+			});
+			onCleanup(() => {
+				fogTex.dispose();
+			});
+		}
+		const px = float(1 / N);
+		const s0 = fogField.sample(screenUV);
+		const s1 = fogField.sample(screenUV.add(vec2(px, float(0))));
+		const s2 = fogField.sample(screenUV.add(vec2(float(0), px)));
+		const s3 = fogField.sample(screenUV.add(vec2(px.negate(), float(0))));
+		const s4 = fogField.sample(screenUV.add(vec2(float(0), px.negate())));
+		const fogDensity = 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)));
+		const colorVar = 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)));
+		const fogColor = mixColors(uniforms.colorA.uniform, uniforms.colorB.uniform, colorVar, uniforms.colorSpace.uniform.value);
+		return vec4(fogColor.x, fogColor.y, fogColor.z, fogColor.w.mul(fogDensity));
+	}
+};
+var Fog_default = componentDefinition;
+export { componentDefinition as n, Fog_default as t };