shaders 2.2.41 → 2.2.43

package/dist/core/Shatter-COjV2jLy.js

@@ -0,0 +1,299 @@
+import { t as applyEdgeHandling } from "./edges-Bd7GP4s2.js";
+import { o as transformEdges } from "./transformations-YbhRK-rd.js";
+import { DataTexture, FloatType, LinearFilter, RGBAFormat } from "three";
+import { convertToTexture, float, screenUV, smoothstep, texture, vec2, vec4 } from "three/tsl";
+var seededRandom = (seed) => {
+	const x = Math.sin(seed) * 1e4;
+	return x - Math.floor(x);
+};
+const componentDefinition = {
+	name: "Shatter",
+	category: "Interactive",
+	description: "Broken glass effect with tectonic plate displacement",
+	requiresRTT: true,
+	requiresChild: true,
+	props: {
+		crackWidth: {
+			default: 1,
+			description: "Thickness of crack lines",
+			ui: {
+				type: "range",
+				min: .5,
+				max: 5,
+				step: .1,
+				label: "Crack Width"
+			}
+		},
+		intensity: {
+			default: 4,
+			description: "How much shards shift",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 20,
+				step: 1,
+				label: "Intensity"
+			}
+		},
+		radius: {
+			default: .4,
+			description: "Cursor influence radius",
+			ui: {
+				type: "range",
+				min: .1,
+				max: 1,
+				step: .1,
+				label: "Radius"
+			}
+		},
+		decay: {
+			default: 1,
+			description: "How fast shards return to rest",
+			ui: {
+				type: "range",
+				min: .1,
+				max: 10,
+				step: .1,
+				label: "Decay"
+			}
+		},
+		seed: {
+			default: 2,
+			description: "Random seed for pattern",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 50,
+				step: 1,
+				label: "Seed"
+			}
+		},
+		chromaticSplit: {
+			default: 1,
+			description: "RGB separation for prismatic glass effect",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 5,
+				step: .1,
+				label: "Chromatic Split"
+			}
+		},
+		refractionStrength: {
+			default: 5,
+			description: "How much cracks bend/distort the underlying image",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 10,
+				step: .1,
+				label: "Refraction"
+			}
+		},
+		shardLighting: {
+			default: .1,
+			description: "Subtle lighting on tilted shards for 3D depth",
+			ui: {
+				type: "range",
+				min: 0,
+				max: .5,
+				step: .1,
+				label: "Shard Lighting"
+			}
+		},
+		edges: {
+			default: "mirror",
+			description: "How to handle edges when displacement pushes content out of bounds",
+			transform: transformEdges,
+			ui: {
+				type: "select",
+				options: [
+					{
+						label: "Stretch",
+						value: "stretch"
+					},
+					{
+						label: "Transparent",
+						value: "transparent"
+					},
+					{
+						label: "Mirror",
+						value: "mirror"
+					},
+					{
+						label: "Wrap",
+						value: "wrap"
+					}
+				],
+				label: "Edges"
+			}
+		}
+	},
+	fragmentNode: ({ uniforms, onBeforeRender, childNode, onCleanup }) => {
+		const SHARD_COUNT = 16;
+		const FRICTION = 1;
+		const cellData = new Float32Array(SHARD_COUNT * 4);
+		const cellTexture = new DataTexture(cellData, 4, 4, RGBAFormat, FloatType);
+		cellTexture.magFilter = LinearFilter;
+		cellTexture.minFilter = LinearFilter;
+		const displacementData = new Float32Array(SHARD_COUNT * 4);
+		const displacementTexture = new DataTexture(displacementData, 4, 4, RGBAFormat, FloatType);
+		displacementTexture.magFilter = LinearFilter;
+		displacementTexture.minFilter = LinearFilter;
+		const generateCells = (seed) => {
+			for (let i = 0; i < SHARD_COUNT; i++) {
+				cellData[i * 4] = seededRandom(seed + i * 2);
+				cellData[i * 4 + 1] = seededRandom(seed + i * 2 + 1);
+				cellData[i * 4 + 2] = seededRandom(seed + i * 3);
+				cellData[i * 4 + 3] = seededRandom(seed + i * 3 + 1);
+			}
+			cellTexture.needsUpdate = true;
+		};
+		let currentSeed = uniforms.seed.uniform.value;
+		generateCells(currentSeed);
+		displacementData.fill(0);
+		displacementTexture.needsUpdate = true;
+		let prevX = .5;
+		let prevY = .5;
+		let lastTime = Date.now();
+		onBeforeRender(({ pointer }) => {
+			const currentTime = Date.now();
+			const dt = Math.min((currentTime - lastTime) / 1e3, .016);
+			lastTime = currentTime;
+			const newSeed = uniforms.seed.uniform.value;
+			if (newSeed !== currentSeed) {
+				currentSeed = newSeed;
+				generateCells(currentSeed);
+				displacementData.fill(0);
+			}
+			const intensity = uniforms.intensity.uniform.value;
+			const radius = uniforms.radius.uniform.value;
+			const decay = uniforms.decay.uniform.value;
+			const friction = FRICTION;
+			let velX = dt > 0 ? (pointer.x - prevX) / dt : 0;
+			let velY = dt > 0 ? (pointer.y - prevY) / dt : 0;
+			let speed = Math.sqrt(velX * velX + velY * velY);
+			const maxVelocity = 5 + intensity * 2;
+			if (speed > maxVelocity) {
+				const scale = maxVelocity / speed;
+				velX *= scale;
+				velY *= scale;
+				speed = maxVelocity;
+			}
+			for (let i = 0; i < SHARD_COUNT; i++) {
+				const cellX = cellData[i * 4];
+				const cellY = cellData[i * 4 + 1];
+				const randomDirX = cellData[i * 4 + 2] - .5;
+				const randomDirY = cellData[i * 4 + 3] - .5;
+				const dx = cellX - pointer.x;
+				const dy = cellY - pointer.y;
+				const dist = Math.sqrt(dx * dx + dy * dy);
+				let currentDx = displacementData[i * 4];
+				let currentDy = displacementData[i * 4 + 1];
+				const decayTime = Math.max(.01, decay);
+				const decayFactor = Math.exp(-dt / decayTime);
+				currentDx *= decayFactor;
+				currentDy *= decayFactor;
+				let velocityDx = 0;
+				let velocityDy = 0;
+				if (dist < radius && speed > .01) {
+					const influence = Math.max(0, 1 - dist / radius);
+					const influenceCurve = influence * influence;
+					const pushForce = influenceCurve * speed * intensity * dt * .5;
+					velocityDx = velX * pushForce;
+					velocityDy = velY * pushForce;
+					const jitterForce = influenceCurve * speed * intensity * dt * .1;
+					velocityDx += randomDirX * jitterForce;
+					velocityDy += randomDirY * jitterForce;
+				}
+				const lerpFactor = Math.min(1, friction * dt);
+				displacementData[i * 4] = currentDx + velocityDx * lerpFactor;
+				displacementData[i * 4 + 1] = currentDy + velocityDy * lerpFactor;
+				displacementData[i * 4 + 2] = 0;
+				displacementData[i * 4 + 3] = 0;
+			}
+			displacementTexture.needsUpdate = true;
+			prevX = pointer.x;
+			prevY = pointer.y;
+		});
+		onCleanup(() => {
+			cellTexture.dispose();
+			displacementTexture.dispose();
+		});
+		if (!childNode) return vec4(0, 0, 0, 0);
+		const childTexture = convertToTexture(childNode);
+		onCleanup(() => {
+			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();
+		});
+		const cellField = texture(cellTexture);
+		const dispField = texture(displacementTexture);
+		const cells = [];
+		for (let i = 0; i < SHARD_COUNT; i++) {
+			const u = (i % 4 + .5) / 4;
+			const v = (Math.floor(i / 4) + .5) / 4;
+			const cellPos = cellField.sample(vec2(u, v)).xy;
+			const dist = screenUV.sub(cellPos).length();
+			cells.push({
+				dist,
+				index: float(i)
+			});
+		}
+		let minDist1 = cells[0].dist;
+		let minDist2 = float(1e3);
+		let nearestIdx = cells[0].index;
+		for (let i = 1; i < SHARD_COUNT; i++) {
+			const dist = cells[i].dist;
+			const isNewNearest = dist.lessThan(minDist1);
+			const isNewSecond = dist.lessThan(minDist2).and(isNewNearest.not());
+			const nextMin2 = isNewNearest.select(minDist1, isNewSecond.select(dist, minDist2));
+			const nextMin1 = isNewNearest.select(dist, minDist1);
+			const nextIdx = isNewNearest.select(cells[i].index, nearestIdx);
+			minDist2 = nextMin2;
+			minDist1 = nextMin1;
+			nearestIdx = nextIdx;
+		}
+		const dispU = nearestIdx.mod(float(4)).add(.5).div(4);
+		const dispV = nearestIdx.div(float(4)).floor().add(.5).div(4);
+		const displacement = dispField.sample(vec2(dispU, dispV)).xy;
+		const displacementMag = displacement.length();
+		const edgeDiff = minDist2.sub(minDist1);
+		const crackThreshold = uniforms.crackWidth.uniform.mul(.005);
+		const baseCrackIntensity = float(1).sub(smoothstep(float(0), crackThreshold, edgeDiff));
+		const displacementFactor = smoothstep(float(0), float(.01), displacementMag);
+		const crackIntensity = baseCrackIntensity.mul(displacementFactor);
+		const nearestCellU = nearestIdx.mod(float(4)).add(.5).div(4);
+		const nearestCellV = nearestIdx.div(float(4)).floor().add(.5).div(4);
+		const nearestCellPos = cellField.sample(vec2(nearestCellU, nearestCellV)).xy;
+		const toNearest = screenUV.sub(nearestCellPos).normalize();
+		const edgeNormal = vec2(toNearest.y.negate(), toNearest.x);
+		const displacedUV = screenUV.sub(displacement);
+		const refractionOffset = edgeNormal.mul(uniforms.refractionStrength.uniform).mul(.01);
+		const chromaticOffset = uniforms.chromaticSplit.uniform.mul(.005);
+		const rOffset = refractionOffset.add(edgeNormal.mul(chromaticOffset));
+		const gOffset = refractionOffset;
+		const bOffset = refractionOffset.sub(edgeNormal.mul(chromaticOffset));
+		const rUV = displacedUV.add(rOffset.mul(crackIntensity));
+		const gUV = displacedUV.add(gOffset.mul(crackIntensity));
+		const bUV = displacedUV.add(bOffset.mul(crackIntensity));
+		const rSample = childTexture.sample(rUV);
+		const gSample = childTexture.sample(gUV);
+		const bSample = childTexture.sample(bUV);
+		const rFinal = applyEdgeHandling(rUV, rSample, childTexture, uniforms.edges.uniform);
+		const gFinal = applyEdgeHandling(gUV, gSample, childTexture, uniforms.edges.uniform);
+		const bFinal = applyEdgeHandling(bUV, bSample, childTexture, uniforms.edges.uniform);
+		const refractedColor = vec4(rFinal.r, gFinal.g, bFinal.b, gFinal.a);
+		const normalColor = applyEdgeHandling(displacedUV, childTexture.sample(displacedUV), childTexture, uniforms.edges.uniform);
+		let shadedRGB = normalColor.rgb.mul(float(1).sub(crackIntensity)).add(refractedColor.rgb.mul(crackIntensity));
+		const displacementLength = displacement.length();
+		const tiltX = displacement.x.div(displacementLength.add(.001));
+		const tiltY = displacement.y.div(displacementLength.add(.001));
+		const lightDir3D = vec2(.3, .6).normalize();
+		const normalDot = tiltX.mul(lightDir3D.x).add(tiltY.mul(lightDir3D.y));
+		const lightingFactor = float(1).add(normalDot.mul(uniforms.shardLighting.uniform));
+		const lightingIntensity = smoothstep(float(0), float(.02), displacementLength);
+		const finalLighting = float(1).add(lightingFactor.sub(1).mul(lightingIntensity));
+		return vec4(shadedRGB.mul(finalLighting), normalColor.a);
+	}
+};
+var Shatter_default = componentDefinition;
+export { componentDefinition as n, Shatter_default as t };

package/dist/core/WebcamTexture-D4Uv7Plz.js

@@ -0,0 +1,168 @@
+import { SRGBColorSpace, VideoTexture } from "three/webgpu";
+import { float, max, min, or, screenUV, select, step, texture, uniform, vec2, vec4, viewportSize } from "three/tsl";
+const componentDefinition = {
+	name: "WebcamTexture",
+	category: "Base Layers",
+	description: "Display a live webcam feed with customizable object-fit modes",
+	props: {
+		objectFit: {
+			default: "cover",
+			description: "How the webcam feed should be sized within the viewport",
+			transform: (value) => {
+				return {
+					"cover": 0,
+					"contain": 1,
+					"fill": 2,
+					"scale-down": 3,
+					"none": 4
+				}[value] ?? 0;
+			},
+			ui: {
+				type: "select",
+				options: [
+					{
+						label: "Cover",
+						value: "cover"
+					},
+					{
+						label: "Contain",
+						value: "contain"
+					},
+					{
+						label: "Fill",
+						value: "fill"
+					},
+					{
+						label: "Scale Down",
+						value: "scale-down"
+					},
+					{
+						label: "None",
+						value: "none"
+					}
+				],
+				label: "Object Fit"
+			}
+		},
+		mirror: {
+			default: true,
+			description: "Mirror the webcam feed horizontally (selfie mode)",
+			ui: {
+				type: "checkbox",
+				label: "Mirror"
+			}
+		}
+	},
+	fragmentNode: ({ uniforms, onCleanup }) => {
+		const baseUV = screenUV;
+		let mediaStream = null;
+		let videoElement = null;
+		let videoTexture = null;
+		let isInitialized = false;
+		let isDisposed = false;
+		const videoAspectUniform = uniform(1);
+		const videoWidthUniform = uniform(640);
+		const videoHeightUniform = uniform(480);
+		const placeholderVideo = document.createElement("video");
+		placeholderVideo.playsInline = true;
+		placeholderVideo.muted = true;
+		videoTexture = new VideoTexture(placeholderVideo);
+		videoTexture.colorSpace = SRGBColorSpace;
+		const textureNode = texture(videoTexture);
+		const startWebcam = async () => {
+			if (isInitialized || isDisposed) return;
+			try {
+				mediaStream = await navigator.mediaDevices.getUserMedia({
+					video: {
+						width: { ideal: 1280 },
+						height: { ideal: 720 },
+						facingMode: "user"
+					},
+					audio: false
+				});
+				if (isDisposed) {
+					mediaStream.getTracks().forEach((track) => track.stop());
+					mediaStream = null;
+					return;
+				}
+				videoElement = document.createElement("video");
+				videoElement.srcObject = mediaStream;
+				videoElement.playsInline = true;
+				videoElement.muted = true;
+				await new Promise((resolve, reject) => {
+					if (!videoElement) return reject(/* @__PURE__ */ new Error("Video element not created"));
+					videoElement.onloadedmetadata = () => {
+						resolve();
+					};
+					videoElement.onerror = () => {
+						reject(/* @__PURE__ */ new Error("Failed to load video metadata"));
+					};
+				});
+				if (isDisposed) return;
+				await videoElement.play();
+				if (isDisposed) return;
+				const width = videoElement.videoWidth || 640;
+				const height = videoElement.videoHeight || 480;
+				videoAspectUniform.value = width / height;
+				videoWidthUniform.value = width;
+				videoHeightUniform.value = height;
+				if (videoTexture) videoTexture.dispose();
+				videoTexture = new VideoTexture(videoElement);
+				videoTexture.colorSpace = SRGBColorSpace;
+				textureNode.value = videoTexture;
+				isInitialized = true;
+				console.log(`[WebcamTexture] Webcam started: ${width}x${height}`);
+			} catch (error) {
+				if (error instanceof DOMException) if (error.name === "NotAllowedError") console.error("[WebcamTexture] Camera permission denied by user");
+				else if (error.name === "NotFoundError") console.error("[WebcamTexture] No camera found on this device");
+				else if (error.name === "NotReadableError") console.error("[WebcamTexture] Camera is already in use by another application");
+				else console.error("[WebcamTexture] Camera error:", error.message);
+				else console.error("[WebcamTexture] Failed to start webcam:", error);
+			}
+		};
+		startWebcam();
+		onCleanup(() => {
+			isDisposed = true;
+			if (mediaStream) {
+				mediaStream.getTracks().forEach((track) => track.stop());
+				mediaStream = null;
+			}
+			if (videoTexture) {
+				videoTexture.dispose();
+				videoTexture = null;
+			}
+			if (videoElement) {
+				videoElement.srcObject = null;
+				videoElement = null;
+			}
+			placeholderVideo.srcObject = null;
+			isInitialized = false;
+		});
+		const uv$1 = baseUV;
+		const viewportAspect = viewportSize.x.div(viewportSize.y);
+		const objectFitMode = uniforms.objectFit.uniform;
+		const coverScale = max(viewportAspect.div(videoAspectUniform), float(1));
+		const coverUVScale = vec2(videoAspectUniform.div(viewportAspect).mul(coverScale), coverScale);
+		const containScale = min(viewportAspect.div(videoAspectUniform), float(1));
+		const containUVScale = vec2(videoAspectUniform.div(viewportAspect).mul(containScale), containScale);
+		const fillUVScale = vec2(1, 1);
+		const scaleDownScale = min(min(viewportAspect.div(videoAspectUniform), float(1)), min(viewportSize.x.div(videoWidthUniform), viewportSize.y.div(videoHeightUniform)));
+		const scaleDownUVScale = vec2(videoAspectUniform.div(viewportAspect).mul(scaleDownScale), scaleDownScale);
+		const noneScale = min(viewportSize.x.div(videoWidthUniform), viewportSize.y.div(videoHeightUniform));
+		const noneUVScale = vec2(videoAspectUniform.div(viewportAspect).mul(noneScale), noneScale);
+		const isCover = step(objectFitMode, float(.5));
+		const isContain = step(float(.5), objectFitMode).mul(step(objectFitMode, float(1.5)));
+		const isFill = step(float(1.5), objectFitMode).mul(step(objectFitMode, float(2.5)));
+		const isScaleDown = step(float(2.5), objectFitMode).mul(step(objectFitMode, float(3.5)));
+		const isNone = step(float(3.5), objectFitMode);
+		const uvScale = vec2(0).add(coverUVScale.mul(isCover)).add(containUVScale.mul(isContain)).add(fillUVScale.mul(isFill)).add(scaleDownUVScale.mul(isScaleDown)).add(noneUVScale.mul(isNone));
+		const adjustedUV = uv$1.sub(vec2(.5)).div(uvScale).add(vec2(.5));
+		const mirrorMode = uniforms.mirror.uniform;
+		const finalUV = vec2(select(mirrorMode, float(1).sub(adjustedUV.x), adjustedUV.x), float(1).sub(adjustedUV.y));
+		const sampledColor = textureNode.sample(finalUV);
+		const isOutOfBounds = or(or(finalUV.x.lessThan(0), finalUV.x.greaterThan(1)), or(finalUV.y.lessThan(0), finalUV.y.greaterThan(1)));
+		return vec4(sampledColor.rgb, select(isOutOfBounds, float(0), sampledColor.a));
+	}
+};
+var WebcamTexture_default = componentDefinition;
+export { componentDefinition as n, WebcamTexture_default as t };

package/dist/core/index.js

@@ -46,22 +46,24 @@ import { n as componentDefinition$40 } from "./RectangularCoordinates-CiW3J4UT.j
 import { n as componentDefinition$41 } from "./Ripples-DKBIp3Qq.js";
 import { n as componentDefinition$42 } from "./Saturation-DVVlpikK.js";
 import { n as componentDefinition$43 } from "./Sharpness-cw57bW0s.js";
-import { n as componentDefinition$44 } from "./SimplexNoise-CMMeggo6.js";
-import { n as componentDefinition$45 } from "./SineWave-DVVLqHPw.js";
-import { n as componentDefinition$46 } from "./SolidColor-zYROg_aE.js";
-import { n as componentDefinition$47 } from "./Spherize-tsKMpSaS.js";
-import { n as componentDefinition$48 } from "./Spiral-DDyVSeG_.js";
-import { n as componentDefinition$49 } from "./Strands-B9vY4uA7.js";
-import { n as componentDefinition$50 } from "./Stretch-BhHjbcqd.js";
-import { n as componentDefinition$51 } from "./Stripes-TdCUOh07.js";
-import { n as componentDefinition$52 } from "./Swirl-m1-Mnzj5.js";
-import { n as componentDefinition$53 } from "./TiltShift-C_NUqKZF.js";
-import { n as componentDefinition$54 } from "./Tint-ChKku9xR.js";
-import { n as componentDefinition$55 } from "./Tritone-D-NcV7N-.js";
-import { n as componentDefinition$56 } from "./Twirl-Cqzll6nW.js";
-import { n as componentDefinition$57 } from "./Vibrance-CxunJkcb.js";
-import { n as componentDefinition$58 } from "./WaveDistortion-UQZKCfKh.js";
-import { n as componentDefinition$59 } from "./ZoomBlur-DqKYdlmm.js";
+import { n as componentDefinition$44 } from "./Shatter-COjV2jLy.js";
+import { n as componentDefinition$45 } from "./SimplexNoise-Ce79jgYM.js";
+import { n as componentDefinition$46 } from "./SineWave-Cv2gOU8a.js";
+import { n as componentDefinition$47 } from "./SolidColor-DFkDBFq3.js";
+import { n as componentDefinition$48 } from "./Spherize-R-s4pX9t.js";
+import { n as componentDefinition$49 } from "./Spiral-W4dALX1z.js";
+import { n as componentDefinition$50 } from "./Strands-DtN5POfO.js";
+import { n as componentDefinition$51 } from "./Stretch-BzvP_hdu.js";
+import { n as componentDefinition$52 } from "./Stripes-BbNFX05u.js";
+import { n as componentDefinition$53 } from "./Swirl-CfsYsr4X.js";
+import { n as componentDefinition$54 } from "./TiltShift-B6gbm7Z8.js";
+import { n as componentDefinition$55 } from "./Tint-CpnitsHw.js";
+import { n as componentDefinition$56 } from "./Tritone-DzvSKVfR.js";
+import { n as componentDefinition$57 } from "./Twirl-BXH4uAd6.js";
+import { n as componentDefinition$58 } from "./Vibrance-ByN9bRgU.js";
+import { n as componentDefinition$59 } from "./WaveDistortion-BA1PyqYH.js";
+import { n as componentDefinition$60 } from "./WebcamTexture-D4Uv7Plz.js";
+import { n as componentDefinition$61 } from "./ZoomBlur-CIkkDBIo.js";
 import { Material, Mesh, MeshBasicNodeMaterial, OrthographicCamera, PlaneGeometry, SRGBColorSpace, Scene, WebGPURenderer } from "three/webgpu";
 import { WebGLRenderer } from "three";
 import { PI, abs, add, atan, convertToTexture, cos, div, dot, float, fract, max, min, mix, mul, pow, screenUV, sin, smoothstep, sqrt, step, sub, time, uniform, uv, vec2, vec3, vec4 } from "three/tsl";
@@ -1088,7 +1090,7 @@ function shaderRenderer() {
 			}
 		}
 	};
-	const registerNode = (id, fragmentNodeFunc, parentId, metadata, uniforms = {}, componentDefinition$60) => {
+	const registerNode = (id, fragmentNodeFunc, parentId, metadata, uniforms = {}, componentDefinition$62) => {
 		if (fragmentNodeFunc === null) {
 			const queueIndex = pendingRegistrationQueue.findIndex((item) => item.id === id);
 			if (queueIndex !== -1) {
@@ -1106,7 +1108,7 @@ function shaderRenderer() {
 				parentId,
 				metadata,
 				uniforms,
-				componentDefinition: componentDefinition$60
+				componentDefinition: componentDefinition$62
 			};
 			else pendingRegistrationQueue.push({
 				id,
@@ -1114,7 +1116,7 @@ function shaderRenderer() {
 				parentId,
 				metadata,
 				uniforms,
-				componentDefinition: componentDefinition$60
+				componentDefinition: componentDefinition$62
 			});
 			return;
 		}
@@ -1147,11 +1149,11 @@ function shaderRenderer() {
 		}
 		const nodeInfo = {
 			id,
-			componentName: componentDefinition$60?.name || "Unknown",
+			componentName: componentDefinition$62?.name || "Unknown",
 			fragmentNodeFunc,
 			parentId,
-			requiresRTT: componentDefinition$60?.requiresRTT || false,
-			requiresChild: componentDefinition$60?.requiresChild || false,
+			requiresRTT: componentDefinition$62?.requiresRTT || false,
+			requiresChild: componentDefinition$62?.requiresChild || false,
 			opacityUniform,
 			metadata: {
 				blendMode: metadata?.blendMode || "normal",
@@ -1467,7 +1469,7 @@ function shaderRenderer() {
 		if (pendingRegistrationQueue.length === 0) return;
 		const queue = [...pendingRegistrationQueue];
 		pendingRegistrationQueue = [];
-		for (const { id, fragmentNodeFunc, parentId, metadata, uniforms, componentDefinition: componentDefinition$60 } of queue) if (fragmentNodeFunc) registerNode(id, fragmentNodeFunc, parentId, metadata, uniforms, componentDefinition$60);
+		for (const { id, fragmentNodeFunc, parentId, metadata, uniforms, componentDefinition: componentDefinition$62 } of queue) if (fragmentNodeFunc) registerNode(id, fragmentNodeFunc, parentId, metadata, uniforms, componentDefinition$62);
 	};
 	const initialize = async ({ canvas, enablePerformanceTracking: enableTracking = false }) => {
 		if (isInitialized || isInitializing) return;
@@ -1806,22 +1808,24 @@ var createShaderRegistry = () => {
 		Ripples: componentDefinition$41,
 		Saturation: componentDefinition$42,
 		Sharpness: componentDefinition$43,
-		SimplexNoise: componentDefinition$44,
-		SineWave: componentDefinition$45,
-		SolidColor: componentDefinition$46,
-		Spherize: componentDefinition$47,
-		Spiral: componentDefinition$48,
-		Strands: componentDefinition$49,
-		Stretch: componentDefinition$50,
-		Stripes: componentDefinition$51,
-		Swirl: componentDefinition$52,
-		TiltShift: componentDefinition$53,
-		Tint: componentDefinition$54,
-		Tritone: componentDefinition$55,
-		Twirl: componentDefinition$56,
-		Vibrance: componentDefinition$57,
-		WaveDistortion: componentDefinition$58,
-		ZoomBlur: componentDefinition$59
+		Shatter: componentDefinition$44,
+		SimplexNoise: componentDefinition$45,
+		SineWave: componentDefinition$46,
+		SolidColor: componentDefinition$47,
+		Spherize: componentDefinition$48,
+		Spiral: componentDefinition$49,
+		Strands: componentDefinition$50,
+		Stretch: componentDefinition$51,
+		Stripes: componentDefinition$52,
+		Swirl: componentDefinition$53,
+		TiltShift: componentDefinition$54,
+		Tint: componentDefinition$55,
+		Tritone: componentDefinition$56,
+		Twirl: componentDefinition$57,
+		Vibrance: componentDefinition$58,
+		WaveDistortion: componentDefinition$59,
+		WebcamTexture: componentDefinition$60,
+		ZoomBlur: componentDefinition$61
 	};
 	Object.entries(shaderDefinitions).forEach(([fileName, def]) => {
 		const propsMetadata = {};

package/dist/core/shaderRegistry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shaderRegistry.d.ts","sourceRoot":"","sources":["../src/shaderRegistry.ts"],"names":[],"mappings":"AA+DA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAA;AAElD,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,UAAU,EAAE,mBAAmB,CAAC,GAAG,CAAC,CAAA;IACpC,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE;QAC5B,EAAE,CAAC,EAAE,GAAG,CAAA;QACR,OAAO,CAAC,EAAE,GAAG,CAAA;QACb,WAAW,CAAC,EAAE,MAAM,CAAA;KACrB,CAAC,CAAA;CACH;AAgGD,eAAO,MAAM,cAAc,qCAAyB,CAAA;AAGpD,wBAAgB,aAAa,IAAI,mBAAmB,EAAE,CAErD;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS,CAE7E;AAED,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,mBAAmB,EAAE,CAE5E;AAED,wBAAgB,mBAAmB,IAAI,MAAM,EAAE,CAG9C"}
+{"version":3,"file":"shaderRegistry.d.ts","sourceRoot":"","sources":["../src/shaderRegistry.ts"],"names":[],"mappings":"AAiEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAA;AAElD,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,UAAU,EAAE,mBAAmB,CAAC,GAAG,CAAC,CAAA;IACpC,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE;QAC5B,EAAE,CAAC,EAAE,GAAG,CAAA;QACR,OAAO,CAAC,EAAE,GAAG,CAAA;QACb,WAAW,CAAC,EAAE,MAAM,CAAA;KACrB,CAAC,CAAA;CACH;AAkGD,eAAO,MAAM,cAAc,qCAAyB,CAAA;AAGpD,wBAAgB,aAAa,IAAI,mBAAmB,EAAE,CAErD;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS,CAE7E;AAED,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,mBAAmB,EAAE,CAE5E;AAED,wBAAgB,mBAAmB,IAAI,MAAM,EAAE,CAG9C"}

package/dist/core/shaders/Shatter/index.d.ts

@@ -0,0 +1,70 @@
+import { ComponentDefinition } from '../../types';
+
+export interface ComponentProps {
+    /**
+     * Thickness of crack lines
+     *
+     * Accepts a number between 0.5 and 5.
+     * @default 1
+     */
+    crackWidth: number;
+    /**
+     * How much shards shift
+     *
+     * Accepts a number between 0 and 20.
+     * @default 4
+     */
+    intensity: number;
+    /**
+     * Cursor influence radius
+     *
+     * Accepts a number between 0.1 and 1.
+     * @default 0.4
+     */
+    radius: number;
+    /**
+     * How fast shards return to rest
+     *
+     * Accepts a number between 0.1 and 10.
+     * @default 1
+     */
+    decay: number;
+    /**
+     * Random seed for pattern
+     *
+     * Accepts a number between 0 and 50.
+     * @default 2
+     */
+    seed: number;
+    /**
+     * RGB separation for prismatic glass effect
+     *
+     * Accepts a number between 0 and 5.
+     * @default 1
+     */
+    chromaticSplit: number;
+    /**
+     * How much cracks bend/distort the underlying image
+     *
+     * Accepts a number between 0 and 10.
+     * @default 5
+     */
+    refractionStrength: number;
+    /**
+     * Subtle lighting on tilted shards for 3D depth
+     *
+     * Accepts a number between 0 and 0.5.
+     * @default 0.1
+     */
+    shardLighting: number;
+    /**
+     * How to handle edges when displacement pushes content out of bounds
+     *
+     * Accepts one of: `"stretch"`, `"transparent"`, `"mirror"`, `"wrap"`.
+     * @default "mirror"
+     */
+    edges: string;
+}
+export declare const componentDefinition: ComponentDefinition<ComponentProps>;
+export default componentDefinition;
+//# sourceMappingURL=index.d.ts.map

package/dist/core/shaders/Shatter/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/shaders/Shatter/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,mBAAmB,EAAqB,MAAM,iBAAiB,CAAA;AAQvE,MAAM,WAAW,cAAc;IAC3B,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,cAAc,EAAE,MAAM,CAAA;IACtB,kBAAkB,EAAE,MAAM,CAAA;IAC1B,aAAa,EAAE,MAAM,CAAA;IACrB,KAAK,EAAE,MAAM,CAAA;CAChB;AAQD,eAAO,MAAM,mBAAmB,EAAE,mBAAmB,CAAC,cAAc,CAqXnE,CAAA;AAED,eAAe,mBAAmB,CAAA"}

package/dist/core/shaders/Shatter/index.js

@@ -0,0 +1,4 @@
+import "../../edges-Bd7GP4s2.js";
+import "../../transformations-YbhRK-rd.js";
+import { n as componentDefinition, t as Shatter_default } from "../../Shatter-COjV2jLy.js";
+export { componentDefinition, Shatter_default as default };