shaders 3.1.462 → 3.2.464

package/dist/core/DiamondGradient-BjqWyhxG.js

@@ -1,355 +0,0 @@
-import { Dt as sin, Mt as vec2f, _t as max, ct as clamp, et as typegpu_default, ht as fract, it as abs, lt as cos, m as call, rt as select, sn as f32, yt as mix } from "./edges-CV-BHMpI.js";
-import { t as DEG_TO_RAD$1 } from "./constants-BKlzQFdJ.js";
-import { r as geom_exports } from "./geom-BS390xIn.js";
-import { V as colorStopsPropConfig } from "./porters-j7yWJYy2.js";
-import { t as mixStopsOrColorsExpr } from "./noiseColor-DEQWYLVu.js";
-import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-u-UZrXjj.js";
-var DEG_TO_RAD = DEG_TO_RAD$1;
-var { aspectCenteredDelta, rotate2 } = geom_exports;
-const diamondFinalT = typegpu_default.fn([
-	vec2f,
-	f32,
-	f32,
-	f32,
-	f32,
-	vec2f,
-	vec2f
-], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, size, rotation, repeat, roundness, uv, viewport) => {
-	"use gpu";
-	const delta = aspectCenteredDelta(uv, center, viewport);
-	const rotRad = __tsover_mul(rotation, DEG_TO_RAD);
-	const rotated = rotate2(delta, cos(rotRad), -sin(rotRad));
-	const absDx = abs(rotated.x);
-	const absDy = abs(rotated.y);
-	const dist = mix(__tsover_add(absDx, absDy), max(absDx, absDy), roundness);
-	const t = __tsover_mul(__tsover_div(dist, size), repeat);
-	return select(clamp(t, 0, 1), fract(t), repeat > 1.0001);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "center"
-			},
-			{
-				"type": "i",
-				"name": "size"
-			},
-			{
-				"type": "i",
-				"name": "rotation"
-			},
-			{
-				"type": "i",
-				"name": "repeat"
-			},
-			{
-				"type": "i",
-				"name": "roundness"
-			},
-			{
-				"type": "i",
-				"name": "uv"
-			},
-			{
-				"type": "i",
-				"name": "viewport"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"delta",
-				[
-					6,
-					"aspectCenteredDelta",
-					[
-						"uv",
-						"center",
-						"viewport"
-					]
-				]
-			],
-			[
-				13,
-				"rotRad",
-				[
-					1,
-					"rotation",
-					"*",
-					"DEG_TO_RAD"
-				]
-			],
-			[
-				13,
-				"cosR",
-				[
-					6,
-					"std.cos",
-					["rotRad"]
-				]
-			],
-			[
-				13,
-				"sinR",
-				[
-					6,
-					"std.sin",
-					["rotRad"]
-				]
-			],
-			[
-				13,
-				"rotated",
-				[
-					6,
-					"rotate2",
-					[
-						"delta",
-						"cosR",
-						[
-							4,
-							"-",
-							"sinR"
-						]
-					]
-				]
-			],
-			[
-				13,
-				"absDx",
-				[
-					6,
-					"std.abs",
-					[[
-						7,
-						"rotated",
-						"x"
-					]]
-				]
-			],
-			[
-				13,
-				"absDy",
-				[
-					6,
-					"std.abs",
-					[[
-						7,
-						"rotated",
-						"y"
-					]]
-				]
-			],
-			[
-				13,
-				"l1",
-				[
-					1,
-					"absDx",
-					"+",
-					"absDy"
-				]
-			],
-			[
-				13,
-				"linf",
-				[
-					6,
-					"std.max",
-					["absDx", "absDy"]
-				]
-			],
-			[
-				13,
-				"dist",
-				[
-					6,
-					"std.mix",
-					[
-						"l1",
-						"linf",
-						"roundness"
-					]
-				]
-			],
-			[
-				13,
-				"t",
-				[
-					1,
-					[
-						1,
-						"dist",
-						"/",
-						"size"
-					],
-					"*",
-					"repeat"
-				]
-			],
-			[10, [
-				6,
-				"std.select",
-				[
-					[
-						6,
-						"std.clamp",
-						[
-							"t",
-							[5, "0"],
-							[5, "1"]
-						]
-					],
-					[
-						6,
-						"std.fract",
-						["t"]
-					],
-					[
-						1,
-						"repeat",
-						">",
-						[5, "1.0001"]
-					]
-				]
-			]]
-		]]
-	},
-	externals: {
-		"aspectCenteredDelta": () => aspectCenteredDelta,
-		"DEG_TO_RAD": () => DEG_TO_RAD,
-		"std.cos": () => cos,
-		"std.sin": () => sin,
-		"rotate2": () => rotate2,
-		"std.abs": () => abs,
-		"std.max": () => max,
-		"std.mix": () => mix,
-		"std.select": () => select,
-		"std.clamp": () => clamp,
-		"std.fract": () => fract
-	}
-}) && $.f)({}));
-const componentDefinition = {
-	name: "DiamondGradient",
-	boundingBoxDeclaration: {
-		aspectRatio: null,
-		supportsResizeFit: true
-	},
-	category: "Textures",
-	description: "Diamond-shaped gradient radiating from a center point using Manhattan distance",
-	acceptsUVContext: true,
-	props: {
-		colorA: {
-			default: "#4ffb4a",
-			transform: transformColor,
-			description: "Color at the center of the diamond",
-			ui: {
-				type: "color",
-				label: "Color A (Center)",
-				group: "Colors"
-			}
-		},
-		colorB: {
-			default: "#4f1238",
-			transform: transformColor,
-			description: "Color at the outer edges of the diamond",
-			ui: {
-				type: "color",
-				label: "Color B (Edge)",
-				group: "Colors"
-			}
-		},
-		stops: colorStopsPropConfig(),
-		center: {
-			default: {
-				x: .5,
-				y: .5
-			},
-			transform: transformPosition,
-			description: "Center point of the diamond",
-			ui: {
-				type: "position",
-				label: "Center",
-				group: "Position"
-			}
-		},
-		size: {
-			default: .7,
-			description: "Extent of the gradient — controls how far Color A reaches before transitioning to Color B",
-			ui: {
-				type: ["range", "map"],
-				min: .01,
-				max: 2,
-				step: .01,
-				label: "Size",
-				group: "Effect"
-			}
-		},
-		rotation: {
-			default: 0,
-			description: "Rotation in degrees — tilts the diamond into a rhombus",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 360,
-				step: 1,
-				label: "Rotation",
-				group: "Effect"
-			}
-		},
-		repeat: {
-			default: 1,
-			description: "Number of times the gradient repeats outward. Values above 1 create concentric diamond or square bands.",
-			ui: {
-				type: ["range", "map"],
-				min: 1,
-				max: 16,
-				step: .5,
-				label: "Repeat",
-				group: "Effect"
-			}
-		},
-		roundness: {
-			default: 0,
-			description: "Morphs from a sharp diamond (0) to a square (1)",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Roundness",
-				group: "Effect"
-			}
-		},
-		colorSpace: {
-			default: "linear",
-			transform: transformColorSpace,
-			compileTime: true,
-			description: "Color space for color interpolation",
-			ui: {
-				type: "select",
-				options: colorSpaceOptions,
-				label: "Color Space",
-				group: "Colors"
-			}
-		}
-	},
-	fragment: (params) => {
-		const uv = params.uvContext ?? params.ctx.uv;
-		const viewport = params.effectiveViewportSize ?? params.ctx.viewportSize;
-		return mixStopsOrColorsExpr(params, call(diamondFinalT, "diamondFinalT", [
-			params.uniforms.center,
-			params.uniforms.size,
-			params.uniforms.rotation,
-			params.uniforms.repeat,
-			params.uniforms.roundness,
-			uv,
-			viewport
-		]));
-	}
-};
-var DiamondGradient_default = componentDefinition;
-export { componentDefinition as n, diamondFinalT as r, DiamondGradient_default as t };

package/dist/core/DiamondWipe-KFEhDDoA.js

@@ -1,202 +0,0 @@
-import { Lt as vec4f, Mt as vec2f, d as ZERO, et as typegpu_default, it as abs, m as call, sn as f32 } from "./edges-CV-BHMpI.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 diamondWipeMask = typegpu_default.fn([
-	vec4f,
-	vec2f,
-	f32,
-	f32,
-	f32,
-	f32,
-	f32
-], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, uv, aspect, size, feather, progress, invert) => {
-	"use gpu";
-	const g = cellGrid(uv, aspect, size);
-	return applyReveal(color, revealMask(__tsover_add(abs(__tsover_sub(g.local.x, .5)), abs(__tsover_sub(g.local.y, .5))), progress, feather, invert));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "color"
-			},
-			{
-				"type": "i",
-				"name": "uv"
-			},
-			{
-				"type": "i",
-				"name": "aspect"
-			},
-			{
-				"type": "i",
-				"name": "size"
-			},
-			{
-				"type": "i",
-				"name": "feather"
-			},
-			{
-				"type": "i",
-				"name": "progress"
-			},
-			{
-				"type": "i",
-				"name": "invert"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"g",
-				[
-					6,
-					"reveal.cellGrid",
-					[
-						"uv",
-						"aspect",
-						"size"
-					]
-				]
-			],
-			[
-				13,
-				"coord",
-				[
-					1,
-					[
-						6,
-						"std.abs",
-						[[
-							1,
-							[
-								7,
-								[
-									7,
-									"g",
-									"local"
-								],
-								"x"
-							],
-							"-",
-							[5, "0.5"]
-						]]
-					],
-					"+",
-					[
-						6,
-						"std.abs",
-						[[
-							1,
-							[
-								7,
-								[
-									7,
-									"g",
-									"local"
-								],
-								"y"
-							],
-							"-",
-							[5, "0.5"]
-						]]
-					]
-				]
-			],
-			[10, [
-				6,
-				"reveal.applyReveal",
-				["color", [
-					6,
-					"reveal.revealMask",
-					[
-						"coord",
-						"progress",
-						"feather",
-						"invert"
-					]
-				]]
-			]]
-		]]
-	},
-	externals: {
-		"reveal.cellGrid": () => cellGrid,
-		"std.abs": () => abs,
-		"reveal.applyReveal": () => applyReveal,
-		"reveal.revealMask": () => revealMask
-	}
-}) && $.f)({}));
-const componentDefinition = {
-	name: "DiamondWipe",
-	boundingBoxDeclaration: { aspectRatio: null },
-	category: "Transitions",
-	description: "Wipe the content away through a lattice of growing diamonds",
-	requiresChild: true,
-	props: {
-		progress: {
-			default: .5,
-			description: "How far the diamonds have grown (0 = fully visible, 1 = fully wiped away)",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Progress",
-				group: "Transition"
-			}
-		},
-		size: {
-			default: .15,
-			description: "Size of each diamond cell as a fraction of the frame width",
-			ui: {
-				type: ["range", "map"],
-				min: .02,
-				max: .5,
-				step: .01,
-				label: "Size",
-				group: "Transition"
-			}
-		},
-		feather: {
-			default: .1,
-			description: "Softness of each diamond edge",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Feather",
-				group: "Transition"
-			}
-		},
-		invert: {
-			default: false,
-			transform: transformBoolean,
-			description: "Wipe from the cell corners inward instead",
-			ui: {
-				type: "checkbox",
-				label: "Invert",
-				group: "Transition"
-			}
-		}
-	},
-	fragment: ({ uniforms, childNode, ctx }) => {
-		if (!childNode) {
-			console.error("You must pass a child component into the Diamond Wipe shader.");
-			return ZERO;
-		}
-		return call(diamondWipeMask, "diamondWipeMask", [
-			childNode,
-			ctx.uv,
-			ctx.aspect,
-			uniforms.size,
-			uniforms.feather,
-			uniforms.progress,
-			uniforms.invert
-		]);
-	}
-};
-var DiamondWipe_default = componentDefinition;
-export { componentDefinition as n, diamondWipeMask as r, DiamondWipe_default as t };

package/dist/core/DiffuseBlur-I5qOL2SL.js

@@ -1,169 +0,0 @@
-import { Mt as vec2f, et as typegpu_default, m as call, sn as f32, t as applyEdgeHandlingExpr } from "./edges-CV-BHMpI.js";
-import { x as defineRttFilter } from "./porters-j7yWJYy2.js";
-import { l as hash22 } from "./noise-eXd1Bfrw.js";
-import { s as transformEdges } from "./transformations-u-UZrXjj.js";
-const diffuseBlurUV = typegpu_default.fn([
-	vec2f,
-	f32,
-	vec2f
-], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, intensity, viewport) => {
-	"use gpu";
-	const offset = hash22(uv.mul(1e3)).mul(2).sub(vec2f(1, 1)).mul(intensity).div(viewport);
-	return uv.add(offset);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "uv"
-			},
-			{
-				"type": "i",
-				"name": "intensity"
-			},
-			{
-				"type": "i",
-				"name": "viewport"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"seed",
-				[
-					6,
-					[
-						7,
-						"uv",
-						"mul"
-					],
-					[[5, "1000"]]
-				]
-			],
-			[
-				13,
-				"randVec",
-				[
-					6,
-					"noise.hash22",
-					["seed"]
-				]
-			],
-			[
-				13,
-				"offset",
-				[
-					6,
-					[
-						7,
-						[
-							6,
-							[
-								7,
-								[
-									6,
-									[
-										7,
-										[
-											6,
-											[
-												7,
-												"randVec",
-												"mul"
-											],
-											[[5, "2"]]
-										],
-										"sub"
-									],
-									[[
-										6,
-										"d.vec2f",
-										[[5, "1"], [5, "1"]]
-									]]
-								],
-								"mul"
-							],
-							["intensity"]
-						],
-						"div"
-					],
-					["viewport"]
-				]
-			],
-			[10, [
-				6,
-				[
-					7,
-					"uv",
-					"add"
-				],
-				["offset"]
-			]]
-		]]
-	},
-	externals: {
-		"noise.hash22": () => hash22,
-		"d.vec2f": () => vec2f
-	}
-}) && $.f)({}));
-const componentDefinition = defineRttFilter({
-	name: "DiffuseBlur",
-	boundingBoxDeclaration: { aspectRatio: null },
-	category: "Blurs",
-	description: "Grain-like pixel displacement at random",
-	props: {
-		intensity: {
-			default: 30,
-			description: "Intensity of the diffuse blur effect",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 100,
-				step: 1,
-				label: "Intensity",
-				group: "Effect"
-			}
-		},
-		edges: {
-			default: "stretch",
-			description: "How to handle edges when distortion pushes content out of bounds",
-			transform: transformEdges,
-			compileTime: true,
-			ui: {
-				type: "select",
-				options: [
-					{
-						label: "Stretch",
-						value: "stretch"
-					},
-					{
-						label: "Transparent",
-						value: "transparent"
-					},
-					{
-						label: "Mirror",
-						value: "mirror"
-					},
-					{
-						label: "Wrap",
-						value: "wrap"
-					}
-				],
-				label: "Edges",
-				group: "Effect"
-			}
-		}
-	},
-	build: ({ uniforms, texture, ctx, propValues }) => {
-		const edgeMode = propValues.edges ?? 0;
-		return applyEdgeHandlingExpr(call(diffuseBlurUV, "diffuseBlurUV", [
-			ctx.uv,
-			uniforms.intensity,
-			ctx.viewportSize
-		]), (uv) => texture.sample(uv), edgeMode);
-	}
-});
-var DiffuseBlur_default = componentDefinition;
-export { componentDefinition as n, diffuseBlurUV as r, DiffuseBlur_default as t };