shaders 3.0.442 → 3.0.444

package/dist/core/{Marble-BJp6F6BF.js → Marble-CD5fqEce.js}

@@ -1,6 +1,6 @@
-import { $t as mixColorsVariants, Qt as mixColorsLinear, it as noise_exports, jt as call, n as tgpu, sn as d, tt as mxNoiseFloat2, z as std } from "./coords-DLZT4HVT.js";
-import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-P50Uo_Ju.js";
-import { t as animatedTime } from "./porters-DdcOi7BN.js";
+import { Bt as call, J as std, bn as d, dn as mixColorsVariants, n as tgpu, pt as noise_exports, un as mixColorsLinear, ut as mxNoiseFloat2 } from "./coords-CLqRuQwC.js";
+import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-t0d2-uSX.js";
+import { t as animatedTime } from "./porters-u50QU6Yv.js";
 var PI = Math.PI;
 const marbleFactors = tgpu.fn([
 	d.vec2f,

package/dist/core/{Mirror-9fC_SqqB.js → Mirror-QJoYnzu6.js}

@@ -1,5 +1,5 @@
-import { Gt as unpremultiplyAlpha, It as mixExpr, St as composeEdgeRemapExpr, jt as call, kt as ZERO, n as tgpu, sn as d, xt as applyEdgeHandlingExpr, z as std } from "./coords-DLZT4HVT.js";
-import { c as transformPosition, s as transformEdges } from "./transformations-P50Uo_Ju.js";
+import { At as applyEdgeHandlingExpr, Bt as call, Gt as mixExpr, J as std, Rt as ZERO, bn as d, jt as composeEdgeRemapExpr, n as tgpu, rn as unpremultiplyAlpha } from "./coords-CLqRuQwC.js";
+import { c as transformPosition, s as transformEdges } from "./transformations-t0d2-uSX.js";
 var DEG_TO_RAD = Math.PI / 180;
 const mirrorReflect = tgpu.fn([
 	d.vec2f,

package/dist/core/{MultiPointGradient-BuDBY6Ax.js → MultiPointGradient-CLRPS8u7.js}

@@ -1,5 +1,5 @@
-import { $t as mixColorsVariants, Qt as mixColorsLinear, jt as call, n as tgpu, sn as d, z as std } from "./coords-DLZT4HVT.js";
-import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-P50Uo_Ju.js";
+import { Bt as call, J as std, bn as d, dn as mixColorsVariants, n as tgpu, un as mixColorsLinear } from "./coords-CLqRuQwC.js";
+import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-t0d2-uSX.js";
 var mpgWeight = tgpu.fn([
 	d.vec2f,
 	d.vec2f,

package/dist/core/{Neon-CgA9zX4Y.js → Neon-DAPbLlBN.js}

@@ -1,7 +1,7 @@
-import { E as sdf_exports, Ft as floatE, d as sdf3d_exports, jt as call, ln as __export, n as tgpu, sn as d, z as std } from "./coords-DLZT4HVT.js";
-import { i as sdfSpaceUV, r as offsetUV } from "./glass-CGThMEIa.js";
-import { a as transformColor, c as transformPosition } from "./transformations-P50Uo_Ju.js";
-import { t as shapeEffectBoundingBoxDeclaration } from "./shapeEffectBounds-BglTGD4B.js";
+import { Bt as call, F as sdf_exports, J as std, Sn as __export, Wt as floatE, bn as d, n as tgpu, y as sdf3d_exports } from "./coords-CLqRuQwC.js";
+import { i as sdfSpaceUV, r as offsetUV } from "./glass-BLc74dQi.js";
+import { a as transformColor, c as transformPosition } from "./transformations-t0d2-uSX.js";
+import { t as shapeEffectBoundingBoxDeclaration } from "./shapeEffectBounds-DIjA_-15.js";
 var neon_exports = /* @__PURE__ */ __export({
 	applyNeonEffect: () => applyNeonEffect$1,
 	neonComposite: () => neonComposite,

package/dist/core/NoiseDissolve-jdMIvdYS.js

@@ -0,0 +1,533 @@
+import { Bt as call, J as std, Rt as ZERO, bn as d, n as tgpu, pt as noise_exports, ut as mxNoiseFloat2 } from "./coords-CLqRuQwC.js";
+import { i as transformBoolean } from "./transformations-t0d2-uSX.js";
+const noiseDissolveMask = tgpu.fn([
+	d.vec4f,
+	d.vec2f,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32
+], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, uv, aspect, scale, softness, seed, progress, invert) => {
+	"use gpu";
+	const p = d.vec2f(__tsover_add(__tsover_mul(__tsover_mul(uv.x, aspect), scale), __tsover_mul(seed, 13.7)), __tsover_add(__tsover_mul(uv.y, scale), __tsover_mul(seed, 7.9)));
+	const n1 = mxNoiseFloat2(p);
+	const n2 = __tsover_mul(mxNoiseFloat2(d.vec2f(__tsover_add(__tsover_add(__tsover_mul(p.x, 2), 17.3), __tsover_mul(seed, 3.1)), __tsover_add(__tsover_mul(p.y, 2), 9.1))), .5);
+	const n3 = __tsover_mul(mxNoiseFloat2(d.vec2f(__tsover_add(__tsover_mul(p.x, 4), 41.7), __tsover_add(__tsover_add(__tsover_mul(p.y, 4), 27.9), __tsover_mul(seed, 5.3)))), .25);
+	const n = __tsover_div(__tsover_add(__tsover_add(n1, n2), n3), 1.75);
+	let r = std.clamp(__tsover_add(.5, __tsover_mul(n, .9)), 0, 1);
+	r = std.select(r, __tsover_sub(1, r), invert > 0);
+	const f = std.max(softness, 1e-4);
+	const front = __tsover_sub(__tsover_mul(progress, __tsover_add(1, __tsover_mul(2, f))), f);
+	const reveal = std.smoothstep(__tsover_sub(front, f), __tsover_add(front, f), r);
+	return d.vec4f(color.x, color.y, color.z, __tsover_mul(color.w, reveal));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "color"
+			},
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "aspect"
+			},
+			{
+				"type": "i",
+				"name": "scale"
+			},
+			{
+				"type": "i",
+				"name": "softness"
+			},
+			{
+				"type": "i",
+				"name": "seed"
+			},
+			{
+				"type": "i",
+				"name": "progress"
+			},
+			{
+				"type": "i",
+				"name": "invert"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"p",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec2f"
+					],
+					[[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									"uv",
+									"x"
+								],
+								"*",
+								"aspect"
+							],
+							"*",
+							"scale"
+						],
+						"+",
+						[
+							1,
+							"seed",
+							"*",
+							[5, "13.7"]
+						]
+					], [
+						1,
+						[
+							1,
+							[
+								7,
+								"uv",
+								"y"
+							],
+							"*",
+							"scale"
+						],
+						"+",
+						[
+							1,
+							"seed",
+							"*",
+							[5, "7.9"]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"n1",
+				[
+					6,
+					[
+						7,
+						"noise",
+						"mxNoiseFloat2"
+					],
+					["p"]
+				]
+			],
+			[
+				13,
+				"n2",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"noise",
+							"mxNoiseFloat2"
+						],
+						[[
+							6,
+							[
+								7,
+								"d",
+								"vec2f"
+							],
+							[[
+								1,
+								[
+									1,
+									[
+										1,
+										[
+											7,
+											"p",
+											"x"
+										],
+										"*",
+										[5, "2"]
+									],
+									"+",
+									[5, "17.3"]
+								],
+								"+",
+								[
+									1,
+									"seed",
+									"*",
+									[5, "3.1"]
+								]
+							], [
+								1,
+								[
+									1,
+									[
+										7,
+										"p",
+										"y"
+									],
+									"*",
+									[5, "2"]
+								],
+								"+",
+								[5, "9.1"]
+							]]
+						]]
+					],
+					"*",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"n3",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"noise",
+							"mxNoiseFloat2"
+						],
+						[[
+							6,
+							[
+								7,
+								"d",
+								"vec2f"
+							],
+							[[
+								1,
+								[
+									1,
+									[
+										7,
+										"p",
+										"x"
+									],
+									"*",
+									[5, "4"]
+								],
+								"+",
+								[5, "41.7"]
+							], [
+								1,
+								[
+									1,
+									[
+										1,
+										[
+											7,
+											"p",
+											"y"
+										],
+										"*",
+										[5, "4"]
+									],
+									"+",
+									[5, "27.9"]
+								],
+								"+",
+								[
+									1,
+									"seed",
+									"*",
+									[5, "5.3"]
+								]
+							]]
+						]]
+					],
+					"*",
+					[5, "0.25"]
+				]
+			],
+			[
+				13,
+				"n",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							"n1",
+							"+",
+							"n2"
+						],
+						"+",
+						"n3"
+					],
+					"/",
+					[5, "1.75"]
+				]
+			],
+			[
+				12,
+				"r",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[5, "0.5"],
+							"+",
+							[
+								1,
+								"n",
+								"*",
+								[5, "0.9"]
+							]
+						],
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				2,
+				"r",
+				"=",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"r",
+						[
+							1,
+							[5, "1"],
+							"-",
+							"r"
+						],
+						[
+							1,
+							"invert",
+							">",
+							[5, "0"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"f",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					["softness", [5, "0.0001"]]
+				]
+			],
+			[
+				13,
+				"front",
+				[
+					1,
+					[
+						1,
+						"progress",
+						"*",
+						[
+							1,
+							[5, "1"],
+							"+",
+							[
+								1,
+								[5, "2"],
+								"*",
+								"f"
+							]
+						]
+					],
+					"-",
+					"f"
+				]
+			],
+			[
+				13,
+				"reveal",
+				[
+					6,
+					[
+						7,
+						"std",
+						"smoothstep"
+					],
+					[
+						[
+							1,
+							"front",
+							"-",
+							"f"
+						],
+						[
+							1,
+							"front",
+							"+",
+							"f"
+						],
+						"r"
+					]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"d",
+					"vec4f"
+				],
+				[
+					[
+						7,
+						"color",
+						"x"
+					],
+					[
+						7,
+						"color",
+						"y"
+					],
+					[
+						7,
+						"color",
+						"z"
+					],
+					[
+						1,
+						[
+							7,
+							"color",
+							"w"
+						],
+						"*",
+						"reveal"
+					]
+				]
+			]]
+		]],
+		"externalNames": [
+			"d",
+			"noise",
+			"std"
+		]
+	},
+	externals: () => ({
+		d,
+		noise: noise_exports,
+		std
+	})
+}) && $.f)({}));
+const componentDefinition = {
+	name: "NoiseDissolve",
+	boundingBoxDeclaration: { aspectRatio: null },
+	category: "Transitions",
+	description: "Dissolve the content away through an organic noise pattern",
+	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"
+			}
+		},
+		scale: {
+			default: 3,
+			description: "Frequency of the dissolve pattern (higher = smaller blobs)",
+			ui: {
+				type: ["range", "map"],
+				min: .5,
+				max: 20,
+				step: .1,
+				label: "Scale",
+				group: "Transition"
+			}
+		},
+		softness: {
+			default: .25,
+			description: "How softly the erosion edge fades out (0 = hard-edged blobs)",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Softness",
+				group: "Transition"
+			}
+		},
+		seed: {
+			default: 0,
+			description: "Random seed for pattern variation",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 100,
+				step: 1,
+				label: "Seed",
+				group: "Transition"
+			}
+		},
+		invert: {
+			default: false,
+			transform: transformBoolean,
+			description: "Reverse the order the pattern dissolves in",
+			ui: {
+				type: "checkbox",
+				label: "Invert",
+				group: "Transition"
+			}
+		}
+	},
+	fragment: ({ uniforms, childNode, ctx }) => {
+		if (!childNode) {
+			console.error("You must pass a child component into the Noise Dissolve shader.");
+			return ZERO;
+		}
+		return call(noiseDissolveMask, "noiseDissolveMask", [
+			childNode,
+			ctx.uv,
+			ctx.aspect,
+			uniforms.scale,
+			uniforms.softness,
+			uniforms.seed,
+			uniforms.progress,
+			uniforms.invert
+		]);
+	}
+};
+var NoiseDissolve_default = componentDefinition;
+export { componentDefinition as n, noiseDissolveMask as r, NoiseDissolve_default as t };

package/dist/core/{ObjectTracker-D1qrJe0c.js → ObjectTracker-BD_l_g6R.js}

@@ -1,6 +1,6 @@
-import { Gt as unpremultiplyAlpha, Rt as Expr, kt as ZERO, zt as formatFloat } from "./coords-DLZT4HVT.js";
-import { a as transformColor, i as transformBoolean } from "./transformations-P50Uo_Ju.js";
-import { n as loadGoogleFont } from "./fonts-3F3pIODs.js";
+import { Jt as formatFloat, Rt as ZERO, qt as Expr, rn as unpremultiplyAlpha } from "./coords-CLqRuQwC.js";
+import { a as transformColor, i as transformBoolean } from "./transformations-t0d2-uSX.js";
+import { n as loadGoogleFont } from "./fonts-BtGjHq1w.js";
 var ATLAS_GLYPHS = "0123456789x%";
 var ATLAS_SLOTS = 16;
 var ATLAS_CELL_W = 64;

package/dist/core/{PagePeel-YA6Q8kM0.js → PagePeel-YyWAE0am.js}

@@ -1,4 +1,4 @@
-import { Ft as floatE, Gt as unpremultiplyAlpha, jt as call, kt as ZERO, n as tgpu, sn as d, z as std } from "./coords-DLZT4HVT.js";
+import { Bt as call, J as std, Rt as ZERO, Wt as floatE, bn as d, n as tgpu, rn as unpremultiplyAlpha } from "./coords-CLqRuQwC.js";
 var transformCorner = (value) => {
 	switch (value) {
 		case "top-left": return 0;
@@ -1184,7 +1184,7 @@ const pagePeelCompose = tgpu.fn([
 }) && $.f)({}));
 const componentDefinition = {
 	name: "PagePeel",
-	category: "Distortions",
+	category: "Transitions",
 	description: "Curl the content up from a corner like a peeling page",
 	requiresRTT: true,
 	requiresChild: true,

package/dist/core/{Paper-Bu3J7_h8.js → Paper-DOFhG3gq.js}

@@ -1,4 +1,4 @@
-import { Gt as unpremultiplyAlpha, Lt as vec4, at as paper12, it as noise_exports, jt as call, kt as ZERO, n as tgpu, q as curl22, sn as d, z as std } from "./coords-DLZT4HVT.js";
+import { Bt as call, J as std, Kt as vec4, Rt as ZERO, bn as d, mt as paper12, n as tgpu, nt as curl22, pt as noise_exports, rn as unpremultiplyAlpha } from "./coords-CLqRuQwC.js";
 const paperSurface = tgpu.fn([
 	d.vec2f,
 	d.f32,

package/dist/core/{Parallelogram-8VWcTkAt.js → Parallelogram-CKlvs9a_.js}

@@ -1,5 +1,5 @@
-import { $t as mixColorsVariants, D as shapeLocalCoords, E as sdf_exports, Lt as vec4, Qt as mixColorsLinear, S as parallelogramSdf, jt as call, k as strokeMaskFromSdf, m as ShapeMask, n as tgpu, sn as d } from "./coords-DLZT4HVT.js";
-import { a as transformColor, c as transformPosition, l as transformStrokePosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-P50Uo_Ju.js";
+import { Bt as call, C as ShapeMask, F as sdf_exports, I as shapeLocalCoords, Kt as vec4, R as strokeMaskFromSdf, bn as d, dn as mixColorsVariants, j as parallelogramSdf, n as tgpu, un as mixColorsLinear } from "./coords-CLqRuQwC.js";
+import { a as transformColor, c as transformPosition, l as transformStrokePosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-t0d2-uSX.js";
 const parallelogramShape = tgpu.fn([
 	d.vec2f,
 	d.f32,