shaders 2.5.135 → 3.0.437

package/dist/core/SmokeFill-Dy-0kjsX.js

@@ -1,642 +0,0 @@
-import { a as transformColor, l as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CJcUeZIC.js";
-import { t as mixColors } from "./colorMixing-BPpDnR5I.js";
-import { n as createAnalyticSdfSampler, r as createSvgSdfSampler } from "./sdf-D_EAGXhN.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,
-	usesPointer: true,
-	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/Solarize-BymZlSu0.js

@@ -1,47 +0,0 @@
-import { dot, mix, vec3, vec4 } from "three/tsl";
-const componentDefinition = {
-	name: "Solarize",
-	category: "Adjustments",
-	description: "Inverts tones above a luminance threshold — a classic darkroom and photo effect",
-	requiresChild: true,
-	props: {
-		threshold: {
-			default: .5,
-			description: "Luminance level above which colors are inverted. Pixels brighter than this threshold get flipped.",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Threshold",
-				group: "Effect"
-			}
-		},
-		strength: {
-			default: 1,
-			description: "Blend between original (0) and fully solarized (1)",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Strength",
-				group: "Effect"
-			}
-		}
-	},
-	fragmentNode: ({ uniforms, childNode }) => {
-		if (!childNode) {
-			console.error("You must pass a child component into the Solarize shader.");
-			return vec4(0);
-		}
-		const threshold = uniforms.threshold.uniform;
-		const strength = uniforms.strength.uniform;
-		const luminance = dot(childNode.rgb, vec3(.299, .587, .114));
-		const inverted = vec3(1).sub(childNode.rgb);
-		const solarized = luminance.greaterThan(threshold).select(inverted, childNode.rgb);
-		return vec4(mix(childNode.rgb, solarized, strength), childNode.a);
-	}
-};
-var Solarize_default = componentDefinition;
-export { componentDefinition as n, Solarize_default as t };