shaders 2.5.128 → 2.5.130

package/dist/core/{Blur-5_t3tR_g.js → Blur-1GcG1L1y.js}

@@ -1,5 +1,5 @@
 import { t as unpremultiplyAlpha } from "./alpha-C4ptedXe.js";
-import { i as createVariableGaussianBlurCompute, r as createGaussianBlurCompute } from "./computeBlur-CprKe0xa.js";
+import { i as createVariableGaussianBlurCompute, r as createGaussianBlurCompute } from "./computeBlur-oxyhoztH.js";
 import { Fn, If, clamp, convertToTexture, dot, float, instanceIndex, int, mix, pow, screenUV, texture, textureLoad, textureStore, uint, uniform, uvec2, vec2, vec3, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "Blur",

package/dist/core/{ChannelBlur-DWgS3nhn.js → ChannelBlur-CxlVaYGM.js}

@@ -1,5 +1,5 @@
 import { t as unpremultiplyAlpha } from "./alpha-C4ptedXe.js";
-import { r as createGaussianBlurCompute } from "./computeBlur-CprKe0xa.js";
+import { r as createGaussianBlurCompute } from "./computeBlur-oxyhoztH.js";
 import { Fn, convertToTexture, float, mix, screenUV, texture, vec2, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "ChannelBlur",

package/dist/core/Exposure-CFn2J_t3.js

@@ -0,0 +1,29 @@
+import { vec3, vec4 } from "three/tsl";
+const componentDefinition = {
+	name: "Exposure",
+	category: "Adjustments",
+	description: "Multiplicative exposure (gain) on the child. Unlike additive brightness, it scales values around black — blacks stay black while highlights can be pushed past 1.0 to feed HDR bloom and tone-mapping roll-off. Pointwise, so no extra render pass is needed.",
+	requiresChild: true,
+	props: { exposure: {
+		default: 1,
+		description: "Brightness multiplier (gain). 1 = unchanged, >1 pushes highlights past white for HDR bloom, <1 darkens.",
+		ui: {
+			type: ["range", "map"],
+			min: 0,
+			max: 8,
+			step: .1,
+			label: "Exposure",
+			group: "Appearance"
+		}
+	} },
+	fragmentNode: ({ uniforms, childNode }) => {
+		if (!childNode) {
+			console.error("You must pass a child component into the Exposure shader.");
+			return vec4(0);
+		}
+		const gain = uniforms.exposure.uniform;
+		return vec4(vec3(childNode.r, childNode.g, childNode.b).mul(gain), childNode.a);
+	}
+};
+var Exposure_default = componentDefinition;
+export { componentDefinition as n, Exposure_default as t };

package/dist/core/{Glass-CXT1jdLw.js → Glass-D8DayF1P.js}

@@ -1,5 +1,5 @@
 import { a as transformColor, l as transformPosition } from "./transformations-CJcUeZIC.js";
-import { r as createGaussianBlurCompute } from "./computeBlur-CprKe0xa.js";
+import { r as createGaussianBlurCompute } from "./computeBlur-oxyhoztH.js";
 import { n as createAnalyticSdfSampler, r as createSvgSdfSampler } from "./sdf-D_EAGXhN.js";
 import { Fn, If, clamp, convertToTexture, dot, exp2, float, max, mix, pow, screenUV, smoothstep, sqrt, texture, uniform, vec2, vec3, vec4, viewportSize } from "three/tsl";
 var GOLDEN_ANGLE = 2.3999632297286535;

package/dist/core/{Glow-5PP4-rM9.js → Glow-chsUpCyj.js}

@@ -1,5 +1,5 @@
 import { t as unpremultiplyAlpha } from "./alpha-C4ptedXe.js";
-import { i as createVariableGaussianBlurCompute, n as DEFAULT_COMPUTE_WIDTH, t as DEFAULT_COMPUTE_HEIGHT } from "./computeBlur-CprKe0xa.js";
+import { i as createVariableGaussianBlurCompute, n as DEFAULT_COMPUTE_WIDTH, t as DEFAULT_COMPUTE_HEIGHT } from "./computeBlur-oxyhoztH.js";
 import { StorageTexture } from "three/webgpu";
 import { FloatType } from "three";
 import { Fn, If, clamp, convertToTexture, dot, float, instanceIndex, int, max, mix, pow, screenUV, storageTexture, texture, textureLoad, textureStore, uint, uniform, uvec2, vec2, vec3, vec4, viewportSize } from "three/tsl";
@@ -58,8 +58,10 @@ const componentDefinition = {
 		const dpr = renderer?.getPixelRatio?.() ?? 1;
 		const texWidth = Math.round(dimensions.width * dpr);
 		const texHeight = Math.round(dimensions.height * dpr);
-		const computeWidth = DEFAULT_COMPUTE_WIDTH;
-		const computeHeight = 640;
+		const LONG_EDGE = Math.max(DEFAULT_COMPUTE_WIDTH, 640);
+		const aspect = texHeight > 0 ? texWidth / texHeight : 1;
+		const computeWidth = Math.max(8, aspect >= 1 ? LONG_EDGE : Math.round(LONG_EDGE * aspect));
+		const computeHeight = Math.max(8, aspect >= 1 ? Math.round(LONG_EDGE / aspect) : LONG_EDGE);
 		const brightTex = new StorageTexture(computeWidth, computeHeight);
 		brightTex.type = FloatType;
 		const brightWriteNode = storageTexture(brightTex);
@@ -67,7 +69,7 @@ const componentDefinition = {
 		onCleanup(() => {
 			brightTex.dispose();
 		});
-		const { computeNodes: blurNodes, outputTexture: blurredTex, blurMapWriteNode } = createVariableGaussianBlurCompute(brightReadNode, computeWidth, computeHeight, onCleanup);
+		const { computeNodes: blurNodes, outputTexture: blurredTex, blurMapWriteNode } = createVariableGaussianBlurCompute(brightReadNode, computeWidth, computeHeight, onCleanup, void 0, computeWidth, computeHeight, { jitterTaps: true });
 		const inputWidthU = uniform(texWidth);
 		const inputHeightU = uniform(texHeight);
 		const cw = uint(computeWidth);
@@ -82,10 +84,23 @@ const componentDefinition = {
 				const v = cy.toFloat().add(float(.5)).div(float(computeHeight));
 				const srcX = u.mul(inputWidthU).round().toInt().clamp(int(0), int(inputWidthU.sub(1))).toUint();
 				const srcY = v.mul(inputHeightU).round().toInt().clamp(int(0), int(inputHeightU.sub(1))).toUint();
-				const sample = textureLoad(childTexture, uvec2(srcX, srcY), int(0));
+				const inputWm1 = int(inputWidthU.sub(1));
+				const inputHm1 = int(inputHeightU.sub(1));
+				const sample = vec4(0).toVar();
+				for (let ty = 0; ty < 4; ty++) for (let tx = 0; tx < 4; tx++) {
+					const su = cx.toFloat().add(float((tx + .5) / 4)).div(float(computeWidth));
+					const sv = cy.toFloat().add(float((ty + .5) / 4)).div(float(computeHeight));
+					const sx = su.mul(inputWidthU).toInt().clamp(int(0), inputWm1).toUint();
+					const sy = sv.mul(inputHeightU).toInt().clamp(int(0), inputHm1).toUint();
+					sample.assign(sample.add(textureLoad(childTexture, uvec2(sx, sy), int(0))));
+				}
+				sample.assign(sample.mul(float(1 / 16)));
+				const threshold = uniforms.threshold.uniform;
+				const knee = threshold.mul(float(.5)).add(float(1e-4));
 				const lum = dot(sample.rgb, vec3(.2126, .7152, .0722));
-				const mask = max(float(0), lum.sub(uniforms.threshold.uniform));
-				textureStore(brightWriteNode, uvec2(cx, cy), vec4(sample.rgb.mul(mask), sample.a)).toWriteOnly();
+				const soft = clamp(lum.sub(threshold).add(knee), float(0), knee.mul(float(2)));
+				const mask = max(soft.mul(soft).div(knee.mul(float(4))), lum.sub(threshold)).div(max(lum, float(1e-4)));
+				textureStore(brightWriteNode, uvec2(cx, cy), vec4(sample.rgb.mul(mask), sample.a.mul(mask))).toWriteOnly();
 				let radius;
 				if (sizeMapInfo) {
 					const { sourceTexture, channel, inputMin, inputMax, outputMin, outputMax, curve } = sizeMapInfo;
@@ -123,7 +138,9 @@ const componentDefinition = {
 			const bloom = texture(computeOutputs.blurredTexture).sample(screenUV);
 			const sizePin = uniforms.size.uniform.mul(float(0));
 			const intensity$1 = uniforms.intensity.uniform;
-			return unpremultiplyAlpha(vec4(original.rgb.add(bloom.rgb.mul(intensity$1)).add(sizePin), original.a));
+			const finalColor = original.rgb.add(bloom.rgb.mul(intensity$1)).add(sizePin);
+			const glowAlpha = clamp(bloom.a.mul(intensity$1), float(0), float(1));
+			return unpremultiplyAlpha(vec4(finalColor, original.a.add(glowAlpha.mul(original.a.oneMinus()))));
 		}
 		const childTexture = convertToTexture(childNode);
 		onCleanup(() => {

package/dist/core/{ProgressiveBlur-BJwJ5mE0.js → ProgressiveBlur-By_PgPtK.js}

@@ -1,6 +1,6 @@
 import { l as transformPosition, r as transformAngle } from "./transformations-CJcUeZIC.js";
 import { t as unpremultiplyAlpha } from "./alpha-C4ptedXe.js";
-import { i as createVariableGaussianBlurCompute } from "./computeBlur-CprKe0xa.js";
+import { i as createVariableGaussianBlurCompute } from "./computeBlur-oxyhoztH.js";
 import { Fn, If, clamp, convertToTexture, cos, dot, float, instanceIndex, int, max, mix, pow, radians, screenUV, sin, smoothstep, texture, textureLoad, textureStore, uint, uniform, uvec2, vec2, vec3, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "ProgressiveBlur",

package/dist/core/{ReflectivePlane-UIT4xlmn.js → ReflectivePlane-VjZ1E5B0.js}

@@ -1,7 +1,7 @@
 import { t as applyEdgeHandling } from "./edges-CX_lJB9R.js";
 import { c as transformEdges } from "./transformations-CJcUeZIC.js";
 import { t as unpremultiplyAlpha } from "./alpha-C4ptedXe.js";
-import { i as createVariableGaussianBlurCompute } from "./computeBlur-CprKe0xa.js";
+import { i as createVariableGaussianBlurCompute } from "./computeBlur-oxyhoztH.js";
 import { Fn, If, convertToTexture, float, instanceIndex, mix, screenUV, smoothstep, step, texture, textureStore, uint, uniform, uvec2, vec2, vec4, viewportSize } from "three/tsl";
 var HALF_KERNEL = 30;
 var BLUR_TO_RADIUS_PX = 12;

package/dist/core/ThinFilm-CUsi8eSg.js

@@ -0,0 +1,305 @@
+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 { t as createAnimatedTime } from "./time-DUqSFWvT.js";
+import { n as createAnalyticSdfSampler, r as createSvgSdfSampler } from "./sdf-D_EAGXhN.js";
+import { Fn, clamp, cos, float, floor, fract, mix, screenUV, sin, sqrt, step, uniform, vec2, vec3, vec4, viewportSize } from "three/tsl";
+var TWO_PI = Math.PI * 2;
+function applyThinFilmEffect(sdfSampler, params) {
+	const uniforms = params.uniforms;
+	const lx = uniform(0);
+	const ly = uniform(0);
+	const updateLightAngle = () => {
+		const rad = uniforms.lightAngle.uniform.value * Math.PI / 180;
+		lx.value = Math.cos(rad);
+		ly.value = Math.sin(rad);
+	};
+	updateLightAngle();
+	params.onBeforeRender(updateLightAngle);
+	const animTime = createAnimatedTime(params, uniforms.speed);
+	const mode = uniforms.mode.uniform.value;
+	return Fn(() => {
+		const uv$1 = screenUV;
+		const aspect = viewportSize.x.div(viewportSize.y);
+		const sharp = uniforms.edgeSoftness.uniform.mul(float(.5)).max(float(.001));
+		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 sdfRaw = sdfSampler(sdfUV).r;
+		const sdf = sdfRaw.div(scale);
+		const EPS = float(.01);
+		const gradX = sdfSampler(sdfUV.add(vec2(EPS, float(0)))).r.sub(sdfRaw).div(EPS);
+		const gradY = sdfSampler(sdfUV.add(vec2(float(0), EPS))).r.sub(sdfRaw).div(EPS);
+		const gLen = sqrt(gradX.mul(gradX).add(gradY.mul(gradY))).max(float(1e-4));
+		const nx = gradX.div(gLen);
+		const ny = gradY.div(gLen);
+		const rb1 = clamp(sdf.negate().div(sharp).mul(float(32)), float(0), float(1));
+		const rimWidth = uniforms.rimWidth.uniform.mul(float(.1)).max(float(.001));
+		const depth = clamp(sdf.negate().div(rimWidth), float(0), float(1));
+		const rim = float(1).sub(depth).mul(float(1).sub(depth)).mul(rb1);
+		const baseCos = nx.mul(lx).add(ny.mul(ly));
+		const baseSin = ny.mul(lx).sub(nx.mul(ly));
+		const theta = animTime.mul(float(TWO_PI));
+		const rotatedDot = baseCos.mul(cos(theta)).add(baseSin.mul(sin(theta)));
+		const phase = uniforms.hueShift.uniform.add(uniforms.dispersion.uniform.mul(rotatedDot)).add(uniforms.thickness.uniform.mul(depth).mul(float(2)));
+		let baseColor;
+		if (mode === "custom") {
+			const t3 = fract(phase).mul(float(3));
+			const si = fract(t3);
+			const floorT3 = floor(t3);
+			const cs = uniforms.colorSpace.uniform.value;
+			const c01 = mixColors(uniforms.colorA.uniform, uniforms.colorB.uniform, si, cs);
+			const c12 = mixColors(uniforms.colorB.uniform, uniforms.colorC.uniform, si, cs);
+			let res = mixColors(uniforms.colorC.uniform, uniforms.colorA.uniform, si, cs);
+			res = mix(res, c12, step(floorT3, float(1.5)));
+			res = mix(res, c01, step(floorT3, float(.5)));
+			baseColor = res.rgb;
+		} else baseColor = vec3(cos(phase.add(float(0)).mul(float(TWO_PI))), cos(phase.add(float(.3333)).mul(float(TWO_PI))), cos(phase.add(float(.6667)).mul(float(TWO_PI)))).mul(float(.5)).add(float(.5));
+		return vec4(mix(vec3(1), baseColor, uniforms.saturation.uniform).mul(rim).mul(uniforms.intensity.uniform), clamp(rim, float(0), float(1)));
+	})();
+}
+var DEFAULT_SHAPE_CONFIG = JSON.stringify({
+	type: "circleSDF",
+	radius: .35
+});
+const componentDefinition = {
+	name: "ThinFilm",
+	category: "Shape Effects",
+	description: "Iridescent thin-film edge",
+	props: {
+		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", "map"],
+				min: .1,
+				max: 3,
+				step: .05,
+				label: "Scale",
+				group: "Position"
+			}
+		},
+		intensity: {
+			default: 1,
+			description: "Rim brightness — values above 1 push the edge past white for HDR bloom",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 4,
+				step: .05,
+				label: "Intensity",
+				group: "Film"
+			}
+		},
+		rimWidth: {
+			default: 1,
+			description: "How far inward from the edge the iridescence reaches",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 3,
+				step: .01,
+				label: "Rim Width",
+				group: "Film"
+			}
+		},
+		edgeSoftness: {
+			default: .3,
+			description: "Softness of the shape boundary",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .05,
+				label: "Edge Softness",
+				group: "Film"
+			}
+		},
+		thickness: {
+			default: .5,
+			description: "Film thickness — higher values pack more spectral bands across the rim",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Thickness",
+				group: "Film"
+			}
+		},
+		dispersion: {
+			default: .5,
+			description: "How strongly colour separates around the perimeter (warm vs cool sides)",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Dispersion",
+				group: "Film"
+			}
+		},
+		saturation: {
+			default: 1,
+			description: "Spectral saturation — 0 = white rim, 1 = full iridescence",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Saturation",
+				group: "Film"
+			}
+		},
+		hueShift: {
+			default: 0,
+			description: "Rotate the spectrum to reposition the colours",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Hue Shift",
+				group: "Film"
+			}
+		},
+		lightAngle: {
+			default: 300,
+			description: "Light angle in degrees — sets which side of the rim runs warm vs cool",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Light Angle",
+				group: "Film"
+			}
+		},
+		mode: {
+			default: "rainbow",
+			compileTime: true,
+			description: "Rainbow uses the full iridescent spectrum; Custom cycles through your three chosen colours",
+			ui: {
+				type: "select",
+				options: [{
+					label: "Rainbow",
+					value: "rainbow"
+				}, {
+					label: "Custom",
+					value: "custom"
+				}],
+				label: "Mode",
+				group: "Colors"
+			}
+		},
+		colorA: {
+			default: "#2b6fff",
+			transform: transformColor,
+			description: "First colour in the rim cycle",
+			ui: {
+				type: "color",
+				label: "Color 1",
+				group: "Colors",
+				condition: { mode: "custom" }
+			}
+		},
+		colorB: {
+			default: "#ffffff",
+			transform: transformColor,
+			description: "Second colour in the rim cycle",
+			ui: {
+				type: "color",
+				label: "Color 2",
+				group: "Colors",
+				condition: { mode: "custom" }
+			}
+		},
+		colorC: {
+			default: "#ff7a21",
+			transform: transformColor,
+			description: "Third colour in the rim cycle",
+			ui: {
+				type: "color",
+				label: "Color 3",
+				group: "Colors",
+				condition: { mode: "custom" }
+			}
+		},
+		colorSpace: {
+			default: "oklch",
+			transform: transformColorSpace,
+			compileTime: true,
+			description: "Colour space used to blend between custom colours",
+			ui: {
+				type: "select",
+				options: colorSpaceOptions,
+				label: "Color Space",
+				group: "Colors",
+				condition: { mode: "custom" }
+			}
+		},
+		speed: {
+			default: .1,
+			description: "Speed at which the colours rotate around the rim (0 = static)",
+			ui: {
+				type: "range",
+				min: -1,
+				max: 1,
+				step: .01,
+				label: "Speed",
+				group: "Animation"
+			}
+		},
+		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 — when non-empty, activates SVG mode and triggers a shader recompile"
+		},
+		shapeType: {
+			default: "",
+			compileTime: true,
+			description: "Active SDF shape type — triggers recompile when shape is switched. When empty, derived from shape JSON at mount time."
+		}
+	},
+	fragmentNode: (params) => {
+		const { uniforms, onCleanup, onBeforeRender } = params;
+		const shapeSdfUrl = uniforms.shapeSdfUrl.uniform.value;
+		const initialConfig = (() => {
+			const val = uniforms.shape.uniform.value;
+			if (typeof val === "object" && val !== null) return val;
+			try {
+				return JSON.parse(val);
+			} catch {
+				return {
+					type: "circleSDF",
+					radius: .35
+				};
+			}
+		})();
+		if (shapeSdfUrl) return applyThinFilmEffect(createSvgSdfSampler(shapeSdfUrl, onBeforeRender, onCleanup), params);
+		else return applyThinFilmEffect(createAnalyticSdfSampler(uniforms.shapeType.uniform.value || initialConfig.type || "circleSDF", initialConfig, uniforms.shape, onBeforeRender), params);
+	}
+};
+var ThinFilm_default = componentDefinition;
+export { componentDefinition as n, ThinFilm_default as t };

package/dist/core/{TiltShift-DtQ3dRL-.js → TiltShift-vG90NlLr.js}

@@ -1,6 +1,6 @@
 import { l as transformPosition, r as transformAngle } from "./transformations-CJcUeZIC.js";
 import { t as unpremultiplyAlpha } from "./alpha-C4ptedXe.js";
-import { i as createVariableGaussianBlurCompute } from "./computeBlur-CprKe0xa.js";
+import { i as createVariableGaussianBlurCompute } from "./computeBlur-oxyhoztH.js";
 import { Fn, If, abs, clamp, convertToTexture, cos, dot, float, instanceIndex, int, mix, pow, radians, screenUV, sin, smoothstep, texture, textureLoad, textureStore, uint, uniform, uvec2, vec2, vec3, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "TiltShift",

package/dist/core/{VideoTexture-ClutlOqj.js → VideoTexture-FmV1l91c.js}

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

package/dist/core/{WebcamTexture-D4e06ajM.js → WebcamTexture-DlS4MCDm.js}

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

package/dist/core/blendModes/linearDodge.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"linearDodge.d.ts","sourceRoot":"","sources":["../../src/blendModes/linearDodge.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,IAAI,EAAC,MAAM,cAAc,CAAA;AAEjC,MAAM,CAAC,OAAO,WAAU,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,GAAE,MAAM,GAAG,IAAU,mCAiB9E"}
+{"version":3,"file":"linearDodge.d.ts","sourceRoot":"","sources":["../../src/blendModes/linearDodge.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,IAAI,EAAC,MAAM,cAAc,CAAA;AAEjC,MAAM,CAAC,OAAO,WAAU,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,GAAE,MAAM,GAAG,IAAU,mCAqB9E"}

package/dist/core/{computeBlur-CprKe0xa.js → computeBlur-oxyhoztH.js}

@@ -1,6 +1,6 @@
 import { StorageTexture } from "three/webgpu";
-import { FloatType } from "three";
-import { Fn, If, float, instanceIndex, int, storageTexture, textureLoad, textureStore, uint, uniform, uniformArray, uvec2, vec4 } from "three/tsl";
+import { FloatType, HalfFloatType, LinearFilter as LinearFilter$1 } from "three";
+import { Fn, If, float, fract, instanceIndex, int, storageTexture, textureLoad, textureStore, uint, uniform, uniformArray, uvec2, vec4 } from "three/tsl";
 var DEFAULT_HALF_KERNEL = 24;
 const DEFAULT_COMPUTE_WIDTH = 1024;
 const DEFAULT_COMPUTE_HEIGHT = 640;
@@ -24,7 +24,9 @@ function createGaussianBlurCompute(inputTexture, inputWidth, inputHeight, onClea
 	const intermediateTex = new StorageTexture(computeWidth, computeHeight);
 	intermediateTex.type = FloatType;
 	const outputTex = new StorageTexture(computeWidth, computeHeight);
-	outputTex.type = FloatType;
+	outputTex.type = HalfFloatType;
+	outputTex.minFilter = LinearFilter$1;
+	outputTex.magFilter = LinearFilter$1;
 	onCleanup(() => {
 		intermediateTex.dispose();
 		outputTex.dispose();
@@ -118,7 +120,8 @@ function createGaussianBlurCompute(inputTexture, inputWidth, inputHeight, onClea
 		}
 	};
 }
-function createVariableGaussianBlurCompute(inputTexture, inputWidth, inputHeight, onCleanup, halfKernel = DEFAULT_HALF_KERNEL, computeWidth = DEFAULT_COMPUTE_WIDTH, computeHeight = 640) {
+function createVariableGaussianBlurCompute(inputTexture, inputWidth, inputHeight, onCleanup, halfKernel = DEFAULT_HALF_KERNEL, computeWidth = DEFAULT_COMPUTE_WIDTH, computeHeight = 640, options) {
+	const jitterTaps = options?.jitterTaps === true;
 	const HALF_KERNEL = halfKernel;
 	const FIXED_WEIGHTS = buildFixedWeights(HALF_KERNEL);
 	const blurMapTex = new StorageTexture(computeWidth, computeHeight);
@@ -128,7 +131,9 @@ function createVariableGaussianBlurCompute(inputTexture, inputWidth, inputHeight
 	const intermediateTex = new StorageTexture(computeWidth, computeHeight);
 	intermediateTex.type = FloatType;
 	const outputTex = new StorageTexture(computeWidth, computeHeight);
-	outputTex.type = FloatType;
+	outputTex.type = HalfFloatType;
+	outputTex.minFilter = LinearFilter$1;
+	outputTex.magFilter = LinearFilter$1;
 	onCleanup(() => {
 		blurMapTex.dispose();
 		intermediateTex.dispose();
@@ -164,8 +169,9 @@ function createVariableGaussianBlurCompute(inputTexture, inputWidth, inputHeight
 					textureStore(intermediateWriteNode, uvec2(cx, cy), texel).toWriteOnly();
 				}).Else(() => {
 					const sum = vec4(0).toVar();
+					const jitterH = jitterTaps ? fract(float(52.9829189).mul(fract(cx.toFloat().mul(float(.06711056)).add(cy.toFloat().mul(float(.00583715)))))).sub(float(.5)) : float(0);
 					for (let i = -HALF_KERNEL; i <= HALF_KERNEL; i++) {
-						const offset = float(i).mul(invHalf).mul(blurRadius);
+						const offset = float(i).add(jitterH).mul(invHalf).mul(blurRadius);
 						const texel = textureLoad(inputTexture, uvec2(inputCxF.add(offset).round().toInt().clamp(int(0), inputWm1).toUint(), inputCyI.toUint()), int(0));
 						sum.assign(sum.add(texel.mul(weights.element(int(i + HALF_KERNEL)))));
 					}
@@ -185,8 +191,9 @@ function createVariableGaussianBlurCompute(inputTexture, inputWidth, inputHeight
 					const sum = vec4(0).toVar();
 					const yi = cy.toInt();
 					const radiusComputeY = blurRadius.div(scaleYU);
+					const jitterV = jitterTaps ? fract(float(52.9829189).mul(fract(cx.toFloat().mul(float(.00583715)).add(cy.toFloat().mul(float(.06711056)))))).sub(float(.5)) : float(0);
 					for (let i = -HALF_KERNEL; i <= HALF_KERNEL; i++) {
-						const offset = float(i).mul(invHalf).mul(radiusComputeY);
+						const offset = float(i).add(jitterV).mul(invHalf).mul(radiusComputeY);
 						const texel = textureLoad(intermediateReadNode, uvec2(cx, yi.add(offset.round().toInt()).clamp(int(0), computeHm1).toUint()), int(0));
 						sum.assign(sum.add(texel.mul(weights.element(int(i + HALF_KERNEL)))));
 					}

package/dist/core/effects/thinFilm.d.ts

@@ -0,0 +1,81 @@
+import { Node } from 'three/webgpu';
+import { FragmentNodeParams } from '../types';
+
+/**
+ * Iridescent thin-film rim around an SDF-defined shape.
+ *
+ * Reuses the same shape pipeline as Glass: an SDF sampler (analytic or .bin texture)
+ * provides a signed distance, and three samples build a finite-difference gradient that
+ * serves as the boundary normal. From that we derive a rim band (peaks at the edge,
+ * falls off inward) and shade it with a thin-film interference spectrum.
+ *
+ * Thin-film colour shifts with the optical path through the film, which here is driven by
+ * two terms: a directional component (normal · light) that runs the spectrum warm→cool
+ * around the perimeter — exactly the blue-on-one-side / orange-on-the-other signature —
+ * and a depth component that packs finer spectral bands across the rim width.
+ *
+ * Two colour modes mirror ColorWheel: `rainbow` uses a procedural iridescent spectrum,
+ * `custom` cycles through three user colours (A→B→C→A) blended in the chosen colour space.
+ * `speed` rotates the directional axis over time, sweeping the colours around the rim
+ * (at speed 0 the result is identical to the static look).
+ *
+ * Output is a transparent-interior generator (no child): RGB is the rim colour, alpha is
+ * the band mask. Intensity is unclamped so the rim can exceed 1.0 and blow out via the
+ * renderer's tone mapping. Composite it over a shape (e.g. Glass) with `screen` or the
+ * (unclamped) `linearDodge` blend mode.
+ *
+ * @param sdfSampler - (uv) → vec4; R channel = signed distance (negative inside)
+ * @param params     - the component's FragmentNodeParams (uniforms, onBeforeRender, time)
+ */
+export interface ThinFilmEffectUniforms {
+    center: {
+        uniform: any;
+    };
+    scale: {
+        uniform: any;
+    };
+    intensity: {
+        uniform: any;
+    };
+    rimWidth: {
+        uniform: any;
+    };
+    edgeSoftness: {
+        uniform: any;
+    };
+    thickness: {
+        uniform: any;
+    };
+    dispersion: {
+        uniform: any;
+    };
+    saturation: {
+        uniform: any;
+    };
+    hueShift: {
+        uniform: any;
+    };
+    lightAngle: {
+        uniform: any;
+    };
+    speed: {
+        uniform: any;
+    };
+    mode: {
+        uniform: any;
+    };
+    colorA: {
+        uniform: any;
+    };
+    colorB: {
+        uniform: any;
+    };
+    colorC: {
+        uniform: any;
+    };
+    colorSpace: {
+        uniform: any;
+    };
+}
+export declare function applyThinFilmEffect(sdfSampler: (uv: any) => any, params: FragmentNodeParams): Node;
+//# sourceMappingURL=thinFilm.d.ts.map

package/dist/core/effects/thinFilm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thinFilm.d.ts","sourceRoot":"","sources":["../../src/effects/thinFilm.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,cAAc,CAAA;AACtC,OAAO,KAAK,EAAC,kBAAkB,EAAc,MAAM,UAAU,CAAA;AAI7D;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,WAAW,sBAAsB;IACnC,MAAM,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IACxB,KAAK,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IACvB,SAAS,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAC3B,QAAQ,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAC1B,YAAY,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAC9B,SAAS,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAC3B,UAAU,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAC5B,UAAU,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAC5B,QAAQ,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAC1B,UAAU,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IAC5B,KAAK,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IACvB,IAAI,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IACtB,MAAM,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IACxB,MAAM,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IACxB,MAAM,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;IACxB,UAAU,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAA;CAC/B;AAID,wBAAgB,mBAAmB,CAC/B,UAAU,EAAE,CAAC,EAAE,EAAE,GAAG,KAAK,GAAG,EAC5B,MAAM,EAAE,kBAAkB,GAC3B,IAAI,CA2GN"}