shaders 3.1.463 → 3.2.465

package/dist/core/BlockDissolve-UfOKRmLl.js

@@ -1,163 +0,0 @@
-import { Lt as vec4f, Mt as vec2f, d as ZERO, et as typegpu_default, m as call, sn as f32 } from "./edges-CV-BHMpI.js";
-import { s as hash12 } from "./noise-eXd1Bfrw.js";
-import { n as applyReveal, r as cellGrid, s as revealMask } from "./reveal-B6lBXQJl.js";
-import { i as transformBoolean } from "./transformations-u-UZrXjj.js";
-const blockDissolveMask = typegpu_default.fn([
-	vec4f,
-	vec2f,
-	f32,
-	f32,
-	f32,
-	f32,
-	f32
-], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, uv, aspect, blockSize, softness, progress, invert) => {
-	"use gpu";
-	return applyReveal(color, revealMask(hash12(cellGrid(uv, aspect, blockSize).cell), progress, softness, invert));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "color"
-			},
-			{
-				"type": "i",
-				"name": "uv"
-			},
-			{
-				"type": "i",
-				"name": "aspect"
-			},
-			{
-				"type": "i",
-				"name": "blockSize"
-			},
-			{
-				"type": "i",
-				"name": "softness"
-			},
-			{
-				"type": "i",
-				"name": "progress"
-			},
-			{
-				"type": "i",
-				"name": "invert"
-			}
-		],
-		"body": [0, [[
-			13,
-			"r",
-			[
-				6,
-				"noise.hash12",
-				[[
-					7,
-					[
-						6,
-						"reveal.cellGrid",
-						[
-							"uv",
-							"aspect",
-							"blockSize"
-						]
-					],
-					"cell"
-				]]
-			]
-		], [10, [
-			6,
-			"reveal.applyReveal",
-			["color", [
-				6,
-				"reveal.revealMask",
-				[
-					"r",
-					"progress",
-					"softness",
-					"invert"
-				]
-			]]
-		]]]]
-	},
-	externals: {
-		"noise.hash12": () => hash12,
-		"reveal.cellGrid": () => cellGrid,
-		"reveal.applyReveal": () => applyReveal,
-		"reveal.revealMask": () => revealMask
-	}
-}) && $.f)({}));
-const componentDefinition = {
-	name: "BlockDissolve",
-	boundingBoxDeclaration: { aspectRatio: null },
-	category: "Transitions",
-	description: "Dissolve the content away as a grid of blocks vanishing in random order",
-	requiresChild: true,
-	props: {
-		progress: {
-			default: .5,
-			description: "How far the dissolve has progressed (0 = fully visible, 1 = fully wiped away)",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Progress",
-				group: "Transition"
-			}
-		},
-		blockSize: {
-			default: .08,
-			description: "Size of each block as a fraction of the frame width",
-			ui: {
-				type: ["range", "map"],
-				min: .01,
-				max: .5,
-				step: .01,
-				label: "Block Size",
-				group: "Transition"
-			}
-		},
-		softness: {
-			default: .15,
-			description: "How softly each block fades out (0 = hard-edged blocks)",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Softness",
-				group: "Transition"
-			}
-		},
-		invert: {
-			default: false,
-			transform: transformBoolean,
-			description: "Reverse the order blocks dissolve in",
-			ui: {
-				type: "checkbox",
-				label: "Invert",
-				group: "Transition"
-			}
-		}
-	},
-	fragment: ({ uniforms, childNode, ctx }) => {
-		if (!childNode) {
-			console.error("You must pass a child component into the Block Dissolve shader.");
-			return ZERO;
-		}
-		return call(blockDissolveMask, "blockDissolveMask", [
-			childNode,
-			ctx.uv,
-			ctx.aspect,
-			uniforms.blockSize,
-			uniforms.softness,
-			uniforms.progress,
-			uniforms.invert
-		]);
-	}
-};
-var BlockDissolve_default = componentDefinition;
-export { blockDissolveMask as n, componentDefinition as r, BlockDissolve_default as t };

package/dist/core/BlockNoise-CjbdsEFZ.js

@@ -1,116 +0,0 @@
-import { Mt as vec2f, et as typegpu_default, m as call, sn as f32 } from "./edges-CV-BHMpI.js";
-import { a as timeAxisDomain, t as aspectScaledDomain } from "./fields-Ch0s1PTq.js";
-import { t as animatedTime } from "./porters-j7yWJYy2.js";
-import { b as value13 } from "./noise-eXd1Bfrw.js";
-import { n as toneAndColorExpr } from "./noiseColor-DEQWYLVu.js";
-import { i as noiseToneProps, r as noiseSpeedProp, t as noiseColorProps } from "./noiseColor-D0ZXkiHX.js";
-const blockNoiseField = typegpu_default.fn([
-	vec2f,
-	vec2f,
-	f32,
-	f32,
-	f32
-], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, scale, seed, animTime) => {
-	"use gpu";
-	return value13(timeAxisDomain(aspectScaledDomain(uv, viewport, scale, seed), animTime, .3));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "uv"
-			},
-			{
-				"type": "i",
-				"name": "viewport"
-			},
-			{
-				"type": "i",
-				"name": "scale"
-			},
-			{
-				"type": "i",
-				"name": "seed"
-			},
-			{
-				"type": "i",
-				"name": "animTime"
-			}
-		],
-		"body": [0, [[
-			13,
-			"pos",
-			[
-				6,
-				"fields.aspectScaledDomain",
-				[
-					"uv",
-					"viewport",
-					"scale",
-					"seed"
-				]
-			]
-		], [10, [
-			6,
-			"noise.value13",
-			[[
-				6,
-				"fields.timeAxisDomain",
-				[
-					"pos",
-					"animTime",
-					[5, "0.3"]
-				]
-			]]
-		]]]]
-	},
-	externals: {
-		"fields.aspectScaledDomain": () => aspectScaledDomain,
-		"noise.value13": () => value13,
-		"fields.timeAxisDomain": () => timeAxisDomain
-	}
-}) && $.f)({}));
-const componentDefinition = {
-	name: "BlockNoise",
-	boundingBoxDeclaration: {
-		aspectRatio: null,
-		supportsResizeFit: true
-	},
-	category: "Textures",
-	description: "Blocky value noise with soft cells that morph over time",
-	acceptsUVContext: true,
-	animatedTime: { speed: "speed" },
-	props: {
-		...noiseColorProps(),
-		scale: {
-			default: 2,
-			description: "Pattern scale (higher = larger patterns)",
-			ui: {
-				type: "range",
-				min: -2,
-				max: 5,
-				step: .1,
-				label: "Scale",
-				group: "Effect"
-			}
-		},
-		...noiseToneProps(),
-		...noiseSpeedProp()
-	},
-	fragment: (params) => {
-		const uv = params.uvContext ?? params.ctx.uv;
-		const viewport = params.effectiveViewportSize ?? params.ctx.viewportSize;
-		const t = animatedTime(params);
-		return toneAndColorExpr(params, call(blockNoiseField, "blockNoiseField", [
-			uv,
-			viewport,
-			params.uniforms.scale,
-			params.uniforms.seed,
-			t
-		]));
-	}
-};
-var BlockNoise_default = componentDefinition;
-export { blockNoiseField as n, componentDefinition as r, BlockNoise_default as t };

package/dist/core/BlueNoise-CWEODGh_.js

@@ -1,91 +0,0 @@
-import { Mt as vec2f, et as typegpu_default, m as call, sn as f32 } from "./edges-CV-BHMpI.js";
-import { i as pixelGridDomain } from "./fields-Ch0s1PTq.js";
-import { t as blue12 } from "./noise-eXd1Bfrw.js";
-import { n as toneAndColorExpr } from "./noiseColor-DEQWYLVu.js";
-import { i as noiseToneProps, t as noiseColorProps } from "./noiseColor-D0ZXkiHX.js";
-const blueNoiseField = typegpu_default.fn([
-	vec2f,
-	vec2f,
-	f32,
-	f32
-], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, grain, seed) => {
-	"use gpu";
-	return blue12(pixelGridDomain(uv, viewport, grain, seed));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "uv"
-			},
-			{
-				"type": "i",
-				"name": "viewport"
-			},
-			{
-				"type": "i",
-				"name": "grain"
-			},
-			{
-				"type": "i",
-				"name": "seed"
-			}
-		],
-		"body": [0, [[10, [
-			6,
-			"noise.blue12",
-			[[
-				6,
-				"fields.pixelGridDomain",
-				[
-					"uv",
-					"viewport",
-					"grain",
-					"seed"
-				]
-			]]
-		]]]]
-	},
-	externals: {
-		"noise.blue12": () => blue12,
-		"fields.pixelGridDomain": () => pixelGridDomain
-	}
-}) && $.f)({}));
-const componentDefinition = {
-	name: "BlueNoise",
-	boundingBoxDeclaration: {
-		aspectRatio: null,
-		supportsResizeFit: true
-	},
-	category: "Textures",
-	description: "High-frequency blue noise — even, grainy speckle ideal for dithering",
-	acceptsUVContext: true,
-	props: {
-		...noiseColorProps(),
-		grain: {
-			default: 1,
-			description: "Grain size in pixels (1 = per-pixel, higher = chunkier speckle)",
-			ui: {
-				type: "range",
-				min: 1,
-				max: 32,
-				step: 1,
-				label: "Grain Size",
-				group: "Effect"
-			}
-		},
-		...noiseToneProps()
-	},
-	fragment: (params) => {
-		return toneAndColorExpr(params, call(blueNoiseField, "blueNoiseField", [
-			params.uvContext ?? params.ctx.uv,
-			params.effectiveViewportSize ?? params.ctx.viewportSize,
-			params.uniforms.grain,
-			params.uniforms.seed
-		]));
-	}
-};
-var BlueNoise_default = componentDefinition;
-export { blueNoiseField as n, componentDefinition as r, BlueNoise_default as t };

package/dist/core/Blur-Dx2gGvc1.js

@@ -1,355 +0,0 @@
-import { Gt as textureStorage2d, Lt as vec4f, Pt as vec2u, Tt as round, Wt as texture2d, b as vec4, cn as i32, ct as clamp, et as typegpu_default, ln as u32, qt as struct, sn as f32 } from "./edges-CV-BHMpI.js";
-import { I as textureLoad, R as textureStore } from "./device-DKcu50_C.js";
-import { _ as withVariableBlurCompute, a as REMAP_WINDOW_FIELDS, f as mapSourceScalar, g as withFixedBlurCompute, i as MAP_SOURCE_DIM_FIELDS, l as composeBlurredOverSharp, o as applyRemapWindow, p as remapWindowValues, t as BLUR_MAP_FORMAT } from "./blur-CXouokcq.js";
-const INTENSITY_TO_RADIUS = .36;
-const intensityToRadius = (intensity) => intensity * INTENSITY_TO_RADIUS;
-function fillMapParams() {
-	return struct({
-		...MAP_SOURCE_DIM_FIELDS,
-		...REMAP_WINDOW_FIELDS
-	});
-}
-function buildFillBlurMapGraph(computeWidth, computeHeight, channel) {
-	const Params = fillMapParams();
-	const layout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_default.bindGroupLayout({
-		source: { texture: texture2d(f32) },
-		blurMap: { storageTexture: textureStorage2d(BLUR_MAP_FORMAT, "write-only") },
-		params: { uniform: Params }
-	}), "layout");
-	const channelScalar = mapSourceScalar(channel);
-	return {
-		layout,
-		kernel: typegpu_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-			"use gpu";
-			const p = layout.$.params;
-			const u = __tsover_div(__tsover_add(f32(cx), .5), computeWidth);
-			const v = __tsover_div(__tsover_add(f32(cy), .5), computeHeight);
-			const srcX = clamp(i32(round(__tsover_mul(u, p.inputWidth))), 0, i32(__tsover_sub(p.inputWidth, 1)));
-			const srcY = clamp(i32(round(__tsover_mul(v, p.inputHeight))), 0, i32(__tsover_sub(p.inputHeight, 1)));
-			const remapped = applyRemapWindow(channelScalar(textureLoad(layout.$.source, vec2u(u32(srcX), u32(srcY)), 0)), p.inputMin, p.inputMax, p.outputMin, p.outputMax, p.curve);
-			const radius = __tsover_mul(remapped, .36);
-			textureStore(layout.$.blurMap, vec2u(cx, cy), vec4f(radius, 0, 0, 1));
-		}), {
-			v: 2,
-			name: void 0,
-			ast: {
-				"params": [{
-					"type": "i",
-					"name": "cx"
-				}, {
-					"type": "i",
-					"name": "cy"
-				}],
-				"body": [0, [
-					[
-						13,
-						"p",
-						[
-							7,
-							[
-								7,
-								"layout",
-								"$"
-							],
-							"params"
-						]
-					],
-					[
-						13,
-						"u",
-						[
-							1,
-							[
-								1,
-								[
-									6,
-									"d.f32",
-									["cx"]
-								],
-								"+",
-								[5, "0.5"]
-							],
-							"/",
-							"computeWidth"
-						]
-					],
-					[
-						13,
-						"v",
-						[
-							1,
-							[
-								1,
-								[
-									6,
-									"d.f32",
-									["cy"]
-								],
-								"+",
-								[5, "0.5"]
-							],
-							"/",
-							"computeHeight"
-						]
-					],
-					[
-						13,
-						"srcX",
-						[
-							6,
-							"std.clamp",
-							[
-								[
-									6,
-									"d.i32",
-									[[
-										6,
-										"std.round",
-										[[
-											1,
-											"u",
-											"*",
-											[
-												7,
-												"p",
-												"inputWidth"
-											]
-										]]
-									]]
-								],
-								[5, "0"],
-								[
-									6,
-									"d.i32",
-									[[
-										1,
-										[
-											7,
-											"p",
-											"inputWidth"
-										],
-										"-",
-										[5, "1"]
-									]]
-								]
-							]
-						]
-					],
-					[
-						13,
-						"srcY",
-						[
-							6,
-							"std.clamp",
-							[
-								[
-									6,
-									"d.i32",
-									[[
-										6,
-										"std.round",
-										[[
-											1,
-											"v",
-											"*",
-											[
-												7,
-												"p",
-												"inputHeight"
-											]
-										]]
-									]]
-								],
-								[5, "0"],
-								[
-									6,
-									"d.i32",
-									[[
-										1,
-										[
-											7,
-											"p",
-											"inputHeight"
-										],
-										"-",
-										[5, "1"]
-									]]
-								]
-							]
-						]
-					],
-					[
-						13,
-						"sample",
-						[
-							6,
-							"std.textureLoad",
-							[
-								[
-									7,
-									[
-										7,
-										"layout",
-										"$"
-									],
-									"source"
-								],
-								[
-									6,
-									"d.vec2u",
-									[[
-										6,
-										"d.u32",
-										["srcX"]
-									], [
-										6,
-										"d.u32",
-										["srcY"]
-									]]
-								],
-								[5, "0"]
-							]
-						]
-					],
-					[
-						13,
-						"remapped",
-						[
-							6,
-							"blur.applyRemapWindow",
-							[
-								[
-									6,
-									"channelScalar",
-									["sample"]
-								],
-								[
-									7,
-									"p",
-									"inputMin"
-								],
-								[
-									7,
-									"p",
-									"inputMax"
-								],
-								[
-									7,
-									"p",
-									"outputMin"
-								],
-								[
-									7,
-									"p",
-									"outputMax"
-								],
-								[
-									7,
-									"p",
-									"curve"
-								]
-							]
-						]
-					],
-					[
-						13,
-						"radius",
-						[
-							1,
-							"remapped",
-							"*",
-							[5, "0.36"]
-						]
-					],
-					[
-						6,
-						"std.textureStore",
-						[
-							[
-								7,
-								[
-									7,
-									"layout",
-									"$"
-								],
-								"blurMap"
-							],
-							[
-								6,
-								"d.vec2u",
-								["cx", "cy"]
-							],
-							[
-								6,
-								"d.vec4f",
-								[
-									"radius",
-									[5, "0"],
-									[5, "0"],
-									[5, "1"]
-								]
-							]
-						]
-					]
-				]]
-			},
-			externals: {
-				"layout": () => layout,
-				"d.f32": () => f32,
-				"computeWidth": () => computeWidth,
-				"computeHeight": () => computeHeight,
-				"std.clamp": () => clamp,
-				"d.i32": () => i32,
-				"std.round": () => round,
-				"std.textureLoad": () => textureLoad,
-				"d.vec2u": () => vec2u,
-				"d.u32": () => u32,
-				"blur.applyRemapWindow": () => applyRemapWindow,
-				"channelScalar": () => channelScalar,
-				"std.textureStore": () => textureStore,
-				"d.vec4f": () => vec4f
-			}
-		}) && $.f)({})).$name("fillBlurMap"),
-		Params
-	};
-}
-const componentDefinition = {
-	name: "Blur",
-	boundingBoxDeclaration: { aspectRatio: null },
-	category: "Blurs",
-	description: "A simple Gaussian blur effect",
-	requiresRTT: true,
-	requiresChild: true,
-	props: { intensity: {
-		default: 50,
-		description: "Intensity of the blur effect",
-		ui: {
-			type: ["range", "map"],
-			min: 0,
-			max: 200,
-			step: 1,
-			label: "Intensity",
-			group: "Effect"
-		}
-	} },
-	compute: (params) => {
-		const { getCpuValue, getMapInfo } = params;
-		const mapInfo = getMapInfo("intensity");
-		if (mapInfo) return withVariableBlurCompute(params, {
-			source: mapInfo,
-			buildFill: (cw, ch) => buildFillBlurMapGraph(cw, ch, mapInfo.channel),
-			fillValues: (dims, window) => ({
-				inputWidth: dims.width,
-				inputHeight: dims.height,
-				...remapWindowValues(window)
-			})
-		});
-		return withFixedBlurCompute(params, { radius: () => {
-			const raw = getCpuValue("intensity");
-			return typeof raw === "number" ? intensityToRadius(raw) : 4;
-		} });
-	},
-	fragment: (params) => composeBlurredOverSharp(params, (blurred, sharp) => vec4(blurred.member("rgb"), sharp.member("a")))
-};
-var Blur_default = componentDefinition;
-export { intensityToRadius as a, componentDefinition as i, INTENSITY_TO_RADIUS as n, buildFillBlurMapGraph as r, Blur_default as t };