shaders 3.0.453 → 3.1.455

package/dist/core/WebcamTexture-DauLQjCl.js

@@ -0,0 +1,130 @@
+import { Gt as data_exports, at as std_exports, gt as select, h as call, rn as vec2f, rt as src_default, un as f32 } from "./edges-CD7gCAto.js";
+import { t as mediaSurface } from "./media-fQMXfvXd.js";
+import { r as createVideoElementSource } from "./mediaLifecycle-yHZ8w5aj.js";
+import { r as objectFitProp } from "./propConfigs-k3hs8KYL.js";
+const applyMirror = src_default.fn([vec2f, f32], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, mirror) => {
+	"use gpu";
+	return vec2f(select(uv.x, __tsover_sub(1, uv.x), mirror > 0), uv.y);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "uv"
+		}, {
+			"type": "i",
+			"name": "mirror"
+		}],
+		"body": [0, [[
+			13,
+			"mirroredX",
+			[
+				6,
+				[
+					7,
+					"std",
+					"select"
+				],
+				[
+					[
+						7,
+						"uv",
+						"x"
+					],
+					[
+						1,
+						[5, "1"],
+						"-",
+						[
+							7,
+							"uv",
+							"x"
+						]
+					],
+					[
+						1,
+						"mirror",
+						">",
+						[5, "0"]
+					]
+				]
+			]
+		], [10, [
+			6,
+			[
+				7,
+				"d",
+				"vec2f"
+			],
+			["mirroredX", [
+				7,
+				"uv",
+				"y"
+			]]
+		]]]],
+		"externalNames": ["std", "d"]
+	},
+	externals: () => ({
+		std: std_exports,
+		d: data_exports
+	})
+}) && $.f)({}));
+const componentDefinition = {
+	name: "WebcamTexture",
+	boundingBoxDeclaration: {
+		aspectRatio: null,
+		supportsResizeFit: true
+	},
+	category: "Textures",
+	description: "Display a live webcam feed with customizable object-fit modes",
+	acceptsUVContext: true,
+	naturalSizeKey: { fixed: "webcam" },
+	props: {
+		objectFit: objectFitProp("cover", "How the webcam feed should be sized within the viewport", { allowNone: true }),
+		mirror: {
+			default: true,
+			description: "Mirror the webcam feed horizontally (selfie mode)",
+			ui: {
+				type: "checkbox",
+				label: "Mirror",
+				group: "Effect"
+			}
+		}
+	},
+	fragment: (params) => {
+		const { ctx, propValues, uniforms, uvContext, effectiveViewportSize, registerExternalTexture } = params;
+		return mediaSurface({
+			texture: registerExternalTexture(createVideoElementSource(params, {
+				source: {
+					kind: "webcam",
+					constraints: {
+						video: {
+							width: { ideal: 1280 },
+							height: { ideal: 720 },
+							facingMode: "user"
+						},
+						audio: false
+					}
+				},
+				naturalSizeKey: "webcam",
+				autoplayRequired: true,
+				onError: (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);
+				}
+			}).getSource),
+			uv: uvContext ?? ctx.uv,
+			viewport: effectiveViewportSize ?? ctx.viewportSize,
+			fit: propValues.objectFit,
+			allowNone: true,
+			uvPostProcess: (uv) => call(applyMirror, "applyMirror", [uv, uniforms.mirror]),
+			decode: "srgb-linear-alpha-cut"
+		});
+	}
+};
+var WebcamTexture_default = componentDefinition;
+export { applyMirror as n, componentDefinition as r, WebcamTexture_default as t };

package/dist/core/{Wool-uy61uieK.js → Wool-CEaWGZB1.js}

@@ -1,5 +1,5 @@
-import { S as wool12 } from "./noise-B-PI7JUx.js";
-import { n as applyNoiseReliefExpr, t as reliefStylizeProps } from "./noiseStylize-BN5zji1E.js";
+import { S as wool12 } from "./noise-Bd6IGS0W.js";
+import { n as applyNoiseReliefExpr, t as reliefStylizeProps } from "./noiseStylize-CkeVSB9C.js";
 const componentDefinition = {
 	name: "Wool",
 	boundingBoxDeclaration: { aspectRatio: null },

package/dist/core/WorleyNoise-CjRMr7xP.js

@@ -0,0 +1,558 @@
+import { At as max, Gt as data_exports, at as std_exports, h as call, on as vec3f, rn as vec2f, rt as src_default, un as f32, y as floatE } from "./edges-CD7gCAto.js";
+import { r as toneRemap } from "./tone-DPUvX6X0.js";
+import { r as geom_exports, t as aspectOf } from "./geom-90G-d_hc.js";
+import { r as fbmGated } from "./fields-CC0756V2.js";
+import { c as nearest2Cells, i as cellHash2, n as CELL_MODES, o as cellReduceSelectable, s as cellular_exports, t as CELL_METRICS } from "./cellular-qYnxKdPx.js";
+import { t as animatedTime } from "./porters-DUtQounc.js";
+import { t as mixStopsOrColorsExpr } from "./noiseColor-DYhX5Js1.js";
+import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-B-zNWNdd.js";
+const worleyHash = cellHash2;
+var transformMode = (value) => CELL_MODES[value] ?? 0;
+var transformDistance = (value) => CELL_METRICS[value] ?? 0;
+function worleyModeNum(raw) {
+	return typeof raw === "number" ? raw : transformMode(raw);
+}
+function worleyDistNum(raw) {
+	return typeof raw === "number" ? raw : transformDistance(raw);
+}
+var worleyNearest2 = nearest2Cells({
+	distance: "selectableSquared",
+	jitter: "mix",
+	name: "worleyNearest2"
+});
+const worleyEvalOctave = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((oUV, animT, seedOff, jitter, distNum, modeNum) => {
+	"use gpu";
+	const dd = worleyNearest2(oUV, animT, seedOff, jitter, distNum);
+	return cellReduceSelectable(dd.x, dd.y, distNum, modeNum);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "oUV"
+			},
+			{
+				"type": "i",
+				"name": "animT"
+			},
+			{
+				"type": "i",
+				"name": "seedOff"
+			},
+			{
+				"type": "i",
+				"name": "jitter"
+			},
+			{
+				"type": "i",
+				"name": "distNum"
+			},
+			{
+				"type": "i",
+				"name": "modeNum"
+			}
+		],
+		"body": [0, [[
+			13,
+			"dd",
+			[
+				6,
+				"worleyNearest2",
+				[
+					"oUV",
+					"animT",
+					"seedOff",
+					"jitter",
+					"distNum"
+				]
+			]
+		], [10, [
+			6,
+			[
+				7,
+				"cellular",
+				"cellReduceSelectable"
+			],
+			[
+				[
+					7,
+					"dd",
+					"x"
+				],
+				[
+					7,
+					"dd",
+					"y"
+				],
+				"distNum",
+				"modeNum"
+			]
+		]]]],
+		"externalNames": ["worleyNearest2", "cellular"]
+	},
+	externals: () => ({
+		worleyNearest2,
+		cellular: cellular_exports
+	})
+}) && $.f)({}));
+var worleyOctaveSum = fbmGated(worleyEvalOctave, {
+	maxOctaves: 4,
+	drift: "timeSeed",
+	name: "worleyOctaveSum"
+});
+const worleyNoiseField = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, scale, seed, jitter, lacunarity, persistence, animTime, octaves, distNum, modeNum, modeScale) => {
+	"use gpu";
+	const aspect = aspectOf(viewport);
+	const sum = worleyOctaveSum(vec2f(__tsover_mul(uv.x, aspect), uv.y), scale, lacunarity, persistence, animTime, seed, vec3f(jitter, distNum, modeNum), octaves);
+	return __tsover_mul(__tsover_div(sum.x, max(sum.y, 1e-4)), modeScale);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "viewport"
+			},
+			{
+				"type": "i",
+				"name": "scale"
+			},
+			{
+				"type": "i",
+				"name": "seed"
+			},
+			{
+				"type": "i",
+				"name": "jitter"
+			},
+			{
+				"type": "i",
+				"name": "lacunarity"
+			},
+			{
+				"type": "i",
+				"name": "persistence"
+			},
+			{
+				"type": "i",
+				"name": "animTime"
+			},
+			{
+				"type": "i",
+				"name": "octaves"
+			},
+			{
+				"type": "i",
+				"name": "distNum"
+			},
+			{
+				"type": "i",
+				"name": "modeNum"
+			},
+			{
+				"type": "i",
+				"name": "modeScale"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"aspect",
+				[
+					6,
+					[
+						7,
+						"geom",
+						"aspectOf"
+					],
+					["viewport"]
+				]
+			],
+			[
+				13,
+				"base",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec2f"
+					],
+					[[
+						1,
+						[
+							7,
+							"uv",
+							"x"
+						],
+						"*",
+						"aspect"
+					], [
+						7,
+						"uv",
+						"y"
+					]]
+				]
+			],
+			[
+				13,
+				"sum",
+				[
+					6,
+					"worleyOctaveSum",
+					[
+						"base",
+						"scale",
+						"lacunarity",
+						"persistence",
+						"animTime",
+						"seed",
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec3f"
+							],
+							[
+								"jitter",
+								"distNum",
+								"modeNum"
+							]
+						],
+						"octaves"
+					]
+				]
+			],
+			[10, [
+				1,
+				[
+					1,
+					[
+						7,
+						"sum",
+						"x"
+					],
+					"/",
+					[
+						6,
+						[
+							7,
+							"std",
+							"max"
+						],
+						[[
+							7,
+							"sum",
+							"y"
+						], [5, "0.0001"]]
+					]
+				],
+				"*",
+				"modeScale"
+			]]
+		]],
+		"externalNames": [
+			"geom",
+			"d",
+			"worleyOctaveSum",
+			"std"
+		]
+	},
+	externals: () => ({
+		geom: geom_exports,
+		d: data_exports,
+		worleyOctaveSum,
+		std: std_exports
+	})
+}) && $.f)({}));
+const worleyTone = toneRemap({
+	domain: "unit",
+	contrastMode: "multiplicative",
+	invert: false
+});
+const componentDefinition = {
+	name: "WorleyNoise",
+	boundingBoxDeclaration: {
+		aspectRatio: null,
+		supportsResizeFit: true
+	},
+	category: "Textures",
+	description: "Cellular noise field — distance-based, with selectable feature combinations and fractal octaves",
+	acceptsUVContext: true,
+	animatedTime: { speed: "speed" },
+	props: {
+		colorA: {
+			default: "#ffffff",
+			transform: transformColor,
+			description: "Color where the noise field is low (typically near cell centers)",
+			ui: {
+				type: "color",
+				label: "Color A (Low)",
+				group: "Colors"
+			}
+		},
+		colorB: {
+			default: "#000000",
+			transform: transformColor,
+			description: "Color where the noise field is high (typically near cell boundaries)",
+			ui: {
+				type: "color",
+				label: "Color B (High)",
+				group: "Colors"
+			}
+		},
+		colorSpace: {
+			default: "linear",
+			transform: transformColorSpace,
+			compileTime: true,
+			description: "Color space for color interpolation",
+			ui: {
+				type: "select",
+				options: colorSpaceOptions,
+				label: "Color Space",
+				group: "Colors"
+			}
+		},
+		scale: {
+			default: 6,
+			description: "Number of cells across the canvas at the base octave",
+			ui: {
+				type: ["range", "map"],
+				min: 1,
+				max: 30,
+				step: .5,
+				label: "Scale",
+				group: "Effect"
+			}
+		},
+		mode: {
+			default: "f1",
+			transform: transformMode,
+			compileTime: true,
+			description: "Field type. F1 = distance to nearest point. F2 = distance to second-nearest. F2 − F1 emphasises cell boundaries.",
+			ui: {
+				type: "select",
+				options: [
+					{
+						label: "F1 (Cells)",
+						value: "f1"
+					},
+					{
+						label: "F2 (Wider Cells)",
+						value: "f2"
+					},
+					{
+						label: "F2 − F1 (Edges)",
+						value: "f2MinusF1"
+					},
+					{
+						label: "F1 + F2",
+						value: "f1PlusF2"
+					},
+					{
+						label: "F1 × F2",
+						value: "f1TimesF2"
+					}
+				],
+				label: "Mode",
+				group: "Effect"
+			}
+		},
+		distance: {
+			default: "euclidean",
+			transform: transformDistance,
+			compileTime: true,
+			description: "Distance metric. Euclidean = round cells. Manhattan = diamond. Chebyshev = square.",
+			ui: {
+				type: "select",
+				options: [
+					{
+						label: "Euclidean",
+						value: "euclidean"
+					},
+					{
+						label: "Manhattan",
+						value: "manhattan"
+					},
+					{
+						label: "Chebyshev",
+						value: "chebyshev"
+					}
+				],
+				label: "Distance",
+				group: "Effect"
+			}
+		},
+		octaves: {
+			default: 1,
+			compileTime: true,
+			description: "Number of fractal layers stacked at progressively finer scales",
+			ui: {
+				type: "range",
+				min: 1,
+				max: 4,
+				step: 1,
+				label: "Octaves",
+				group: "Effect"
+			}
+		},
+		lacunarity: {
+			default: 2,
+			description: "Scale multiplier between octaves (only active when Octaves > 1)",
+			ui: {
+				type: ["range", "map"],
+				min: 1.5,
+				max: 4,
+				step: .1,
+				label: "Lacunarity",
+				group: "Effect",
+				condition: { octaves: [
+					2,
+					3,
+					4
+				] }
+			}
+		},
+		persistence: {
+			default: .5,
+			description: "Amplitude multiplier between octaves (only active when Octaves > 1)",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Persistence",
+				group: "Effect",
+				condition: { octaves: [
+					2,
+					3,
+					4
+				] }
+			}
+		},
+		jitter: {
+			default: 1,
+			description: "How much each cell's point drifts inside its cell. 0 = rigid grid (banded look), 1 = fully random.",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Jitter",
+				group: "Effect"
+			}
+		},
+		contrast: {
+			default: 1,
+			description: "Steepness of the gradient between low and high regions",
+			ui: {
+				type: ["range", "map"],
+				min: .25,
+				max: 4,
+				step: .01,
+				label: "Contrast",
+				group: "Effect"
+			}
+		},
+		balance: {
+			default: 0,
+			description: "Shifts the gradient midpoint. Negative pulls the field toward Color A, positive toward Color B.",
+			ui: {
+				type: ["range", "map"],
+				min: -1,
+				max: 1,
+				step: .01,
+				label: "Balance",
+				group: "Effect"
+			}
+		},
+		seed: {
+			default: 0,
+			description: "Random seed — shifts the cell pattern without changing its overall structure",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 100,
+				step: 1,
+				label: "Seed",
+				group: "Effect"
+			}
+		},
+		speed: {
+			default: .5,
+			description: "Animation speed — how fast each cell's point drifts",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 5,
+				step: .1,
+				label: "Speed",
+				group: "Animation"
+			}
+		}
+	},
+	fragment: (params) => {
+		const { uniforms, propValues } = params;
+		const uv = params.uvContext ?? params.ctx.uv;
+		const viewport = params.effectiveViewportSize ?? params.ctx.viewportSize;
+		const t = animatedTime(params);
+		const modeNum = worleyModeNum(propValues.mode);
+		const distNum = worleyDistNum(propValues.distance);
+		const octavesNum = Math.max(1, Math.min(4, Math.round(propValues.octaves ?? 1)));
+		let modeScale = 1.5;
+		if (modeNum === 1) modeScale = 1;
+		else if (modeNum === 2) modeScale = 2.5;
+		else if (modeNum === 3) modeScale = .6;
+		else if (modeNum === 4) modeScale = 2;
+		if (distNum === 1) modeScale *= .7;
+		else if (distNum === 2) modeScale *= 1.4;
+		return mixStopsOrColorsExpr(params, call(worleyTone, "worleyTone", [
+			call(worleyNoiseField, "worleyNoiseField", [
+				uv,
+				viewport,
+				uniforms.scale,
+				uniforms.seed,
+				uniforms.jitter,
+				uniforms.lacunarity,
+				uniforms.persistence,
+				t,
+				floatE(octavesNum),
+				floatE(distNum),
+				floatE(modeNum),
+				floatE(modeScale)
+			]),
+			uniforms.contrast,
+			uniforms.balance
+		]));
+	}
+};
+var WorleyNoise_default = componentDefinition;
+export { worleyNoiseField as a, worleyHash as i, componentDefinition as n, worleyTone as o, worleyEvalOctave as r, WorleyNoise_default as t };