shaders 3.0.441 → 3.0.443

package/dist/core/{Blob-BnBDJJ84.js → Blob-CRJ5N0hK.js}

@@ -1,6 +1,6 @@
-import { $t as mixColorsVariants, Qt as mixColorsLinear, _t as mixColorStopsRuntime, jt as call, n as tgpu, sn as d, z as std } from "./coords-DLZT4HVT.js";
+import { Bt as call, Et as mixColorStopsRuntime, J as std, bn as d, dn as mixColorsVariants, n as tgpu, un as mixColorsLinear } from "./coords-0A7CojvN.js";
 import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-P50Uo_Ju.js";
-import { m as colorStopsPropConfig, t as animatedTime } from "./porters-DdcOi7BN.js";
+import { m as colorStopsPropConfig, t as animatedTime } from "./porters-B1jqpcE3.js";
 const blobOrganicRadius = tgpu.fn([
 	d.vec2f,
 	d.f32,

package/dist/core/BlockDissolve-D-6Wy66g.js

@@ -0,0 +1,364 @@
+import { Bt as call, J as std, Rt as ZERO, bn as d, n as tgpu, pt as noise_exports, st as hash12 } from "./coords-0A7CojvN.js";
+import { i as transformBoolean } from "./transformations-P50Uo_Ju.js";
+const blockDissolveMask = tgpu.fn([
+	d.vec4f,
+	d.vec2f,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32
+], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, uv, aspect, blockSize, softness, progress, invert) => {
+	"use gpu";
+	const gridX = __tsover_div(1, std.max(blockSize, .001));
+	const gridY = std.max(__tsover_div(gridX, aspect), 1);
+	let r = hash12(d.vec2f(std.floor(__tsover_mul(uv.x, gridX)), std.floor(__tsover_mul(uv.y, gridY))));
+	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": "blockSize"
+			},
+			{
+				"type": "i",
+				"name": "softness"
+			},
+			{
+				"type": "i",
+				"name": "progress"
+			},
+			{
+				"type": "i",
+				"name": "invert"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"gridX",
+				[
+					1,
+					[5, "1"],
+					"/",
+					[
+						6,
+						[
+							7,
+							"std",
+							"max"
+						],
+						["blockSize", [5, "0.001"]]
+					]
+				]
+			],
+			[
+				13,
+				"gridY",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					[[
+						1,
+						"gridX",
+						"/",
+						"aspect"
+					], [5, "1"]]
+				]
+			],
+			[
+				13,
+				"cell",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec2f"
+					],
+					[[
+						6,
+						[
+							7,
+							"std",
+							"floor"
+						],
+						[[
+							1,
+							[
+								7,
+								"uv",
+								"x"
+							],
+							"*",
+							"gridX"
+						]]
+					], [
+						6,
+						[
+							7,
+							"std",
+							"floor"
+						],
+						[[
+							1,
+							[
+								7,
+								"uv",
+								"y"
+							],
+							"*",
+							"gridY"
+						]]
+					]]
+				]
+			],
+			[
+				12,
+				"r",
+				[
+					6,
+					[
+						7,
+						"noise",
+						"hash12"
+					],
+					["cell"]
+				]
+			],
+			[
+				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": [
+			"std",
+			"d",
+			"noise"
+		]
+	},
+	externals: () => ({
+		std,
+		d,
+		noise: noise_exports
+	})
+}) && $.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-DINAV0qg.js → BlockNoise-Ct9Fae_7.js}

@@ -1,6 +1,6 @@
-import { G as toneAndColorExpr, dt as value13, it as noise_exports, jt as call, n as tgpu, sn as d, z as std } from "./coords-DLZT4HVT.js";
-import { t as animatedTime } from "./porters-DdcOi7BN.js";
-import { i as noiseToneProps, r as noiseSpeedProp, t as noiseColorProps } from "./noiseColor-kVjc2DJn.js";
+import { Bt as call, J as std, bn as d, bt as value13, et as toneAndColorExpr, n as tgpu, pt as noise_exports } from "./coords-0A7CojvN.js";
+import { t as animatedTime } from "./porters-B1jqpcE3.js";
+import { i as noiseToneProps, r as noiseSpeedProp, t as noiseColorProps } from "./noiseColor-w3B94vmT.js";
 const blockNoiseField = tgpu.fn([
 	d.vec2f,
 	d.vec2f,

package/dist/core/{BlueNoise-B9jPJ1s5.js → BlueNoise-Cu7rJuP0.js}

@@ -1,5 +1,5 @@
-import { G as toneAndColorExpr, K as blue12, it as noise_exports, jt as call, n as tgpu, sn as d, z as std } from "./coords-DLZT4HVT.js";
-import { i as noiseToneProps, t as noiseColorProps } from "./noiseColor-kVjc2DJn.js";
+import { Bt as call, J as std, bn as d, et as toneAndColorExpr, n as tgpu, pt as noise_exports, tt as blue12 } from "./coords-0A7CojvN.js";
+import { i as noiseToneProps, t as noiseColorProps } from "./noiseColor-w3B94vmT.js";
 const blueNoiseField = tgpu.fn([
 	d.vec2f,
 	d.vec2f,

package/dist/core/{Blur-DDWaY0Ld.js → Blur-BrdVVSPq.js}

@@ -1,4 +1,4 @@
-import { Gt as unpremultiplyAlpha, L as createGaussianBlurCompute, Lt as vec4, P as BLUR_MAP_FORMAT, R as createVariableGaussianBlurCompute, V as createGuardedCompute, 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, K as createGaussianBlurCompute, Kt as vec4, Rt as ZERO, U as BLUR_MAP_FORMAT, X as createGuardedCompute, bn as d, n as tgpu, q as createVariableGaussianBlurCompute, rn as unpremultiplyAlpha } from "./coords-0A7CojvN.js";
 const INTENSITY_TO_RADIUS = .36;
 const intensityToRadius = (intensity) => intensity * INTENSITY_TO_RADIUS;
 function fillMapParams() {