shaders 3.0.442 → 3.0.444

package/dist/core/{PerlinNoise-gV2dOb_o.js → PerlinNoise-DKBJst5k.js}

@@ -1,6 +1,6 @@
-import { G as toneAndColorExpr, it as noise_exports, jt as call, n as tgpu, sn as d, st as perlin13, 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, et as toneAndColorExpr, gt as perlin13, n as tgpu, pt as noise_exports } from "./coords-CLqRuQwC.js";
+import { t as animatedTime } from "./porters-u50QU6Yv.js";
+import { i as noiseToneProps, r as noiseSpeedProp, t as noiseColorProps } from "./noiseColor-CFYtKwDd.js";
 const perlinNoiseField = tgpu.fn([
 	d.vec2f,
 	d.vec2f,

package/dist/core/{Perspective-m70JnY4Z.js → Perspective-DH5aV7fh.js}

@@ -1,5 +1,5 @@
-import { Gt as unpremultiplyAlpha, 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, 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 perspectiveUV = tgpu.fn([
 	d.vec2f,

package/dist/core/{PixelSort-tKcoDnMz.js → PixelSort-DRd4GE4_.js}

@@ -1,4 +1,4 @@
-import { Gt as unpremultiplyAlpha, H as createStateBuffer, V as createGuardedCompute, Wt as blend_exports, 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, X as createGuardedCompute, Z as createStateBuffer, bn as d, n as tgpu, nn as blend_exports, rn as unpremultiplyAlpha } from "./coords-CLqRuQwC.js";
 var WORK = 512;
 var CELL_COUNT = WORK * WORK;
 var WORK_F = WORK;

package/dist/core/{PixelThrow-CzelDKa4.js → PixelThrow-CRizzpOr.js}

@@ -1,5 +1,5 @@
-import { Ft as floatE, Gt as unpremultiplyAlpha, N as toHalfFloat, jt as call, kt as ZERO, n as tgpu, sn as d, xt as applyEdgeHandlingExpr, z as std } from "./coords-DLZT4HVT.js";
-import { s as transformEdges } from "./transformations-P50Uo_Ju.js";
+import { At as applyEdgeHandlingExpr, Bt as call, H as toHalfFloat, J as std, Rt as ZERO, Wt as floatE, bn as d, n as tgpu, rn as unpremultiplyAlpha } from "./coords-CLqRuQwC.js";
+import { s as transformEdges } from "./transformations-t0d2-uSX.js";
 var transformThrowKey = (value) => {
 	return {
 		luminance: 0,

package/dist/core/{Pixelate-CcBgoqXj.js → Pixelate-DgPtCErp.js}

@@ -1,4 +1,4 @@
-import { Gt as unpremultiplyAlpha, Lt as vec4, 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, Kt as vec4, Rt as ZERO, bn as d, n as tgpu, rn as unpremultiplyAlpha } from "./coords-CLqRuQwC.js";
 const pixelateSample = tgpu.fn([
 	d.vec2f,
 	d.f32,

package/dist/core/{Plasma-Bsei8uLa.js → Plasma-8zXLjhIr.js}

@@ -1,6 +1,6 @@
-import { $t as mixColorsVariants, Qt as mixColorsLinear, _t as mixColorStopsRuntime, it as noise_exports, jt as call, n as tgpu, nt as mxNoiseFloat3, sn as d, z as std } from "./coords-DLZT4HVT.js";
-import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-P50Uo_Ju.js";
-import { m as colorStopsPropConfig, t as animatedTime } from "./porters-DdcOi7BN.js";
+import { Bt as call, Et as mixColorStopsRuntime, J as std, bn as d, dn as mixColorsVariants, dt as mxNoiseFloat3, n as tgpu, pt as noise_exports, un as mixColorsLinear } from "./coords-CLqRuQwC.js";
+import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-t0d2-uSX.js";
+import { m as colorStopsPropConfig, t as animatedTime } from "./porters-u50QU6Yv.js";
 const plasmaTone = tgpu.fn([
 	d.f32,
 	d.f32,

package/dist/core/{Plastic-D9qe3OWm.js → Plastic-Dv-N6_Nv.js}

@@ -1,8 +1,8 @@
-import { $t as mixColorsVariants, E as sdf_exports, Ft as floatE, Lt as vec4, Qt as mixColorsLinear, _t as mixColorStopsRuntime, d as sdf3d_exports, it as noise_exports, jt as call, n as tgpu, sn as d, tt as mxNoiseFloat2, z as std } from "./coords-DLZT4HVT.js";
-import { n as glass_exports } from "./glass-CGThMEIa.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 { t as shapeEffectBoundingBoxDeclaration } from "./shapeEffectBounds-BglTGD4B.js";
+import { Bt as call, Et as mixColorStopsRuntime, F as sdf_exports, J as std, Kt as vec4, Wt as floatE, bn as d, dn as mixColorsVariants, n as tgpu, pt as noise_exports, un as mixColorsLinear, ut as mxNoiseFloat2, y as sdf3d_exports } from "./coords-CLqRuQwC.js";
+import { n as glass_exports } from "./glass-BLc74dQi.js";
+import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-t0d2-uSX.js";
+import { m as colorStopsPropConfig, t as animatedTime } from "./porters-u50QU6Yv.js";
+import { t as shapeEffectBoundingBoxDeclaration } from "./shapeEffectBounds-DIjA_-15.js";
 var { sdfSpaceUV, offsetUV } = glass_exports;
 var { createSvgSdfSampler, createAnalyticSdfSampler, driveAnalyticSubProps, ANALYTIC_SDF_EXTRA_FIELDS } = sdf_exports;
 var { createVolumetricFieldComputeNode, buildVolumetricFieldSampler, VOLUMETRIC_FIELD_EXTRA_FIELDS, is3dShapeType, isVolumetricShapeType } = sdf3d_exports;

package/dist/core/{PolarCoordinates-C9WxI22k.js → PolarCoordinates-lw0yBeJq.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 PI = Math.PI;
 var TAU = Math.PI * 2;
 const polarCoordsUV = tgpu.fn([

package/dist/core/{Polygon-D58HZRzJ.js → Polygon-DQxmxfqr.js}

@@ -1,5 +1,5 @@
-import { $t as mixColorsVariants, C as polygonSdf, D as shapeLocalCoords, E as sdf_exports, Lt as vec4, Qt as mixColorsLinear, g as circleSdf, jt as call, k as strokeMaskFromSdf, m as ShapeMask, n as tgpu, sn as d, z as std } 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, J as std, Kt as vec4, M as polygonSdf, R as strokeMaskFromSdf, T as circleSdf, bn as d, dn as mixColorsVariants, 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 polygonShape = tgpu.fn([
 	d.vec2f,
 	d.f32,

package/dist/core/{Posterize-DxR6F30M.js → Posterize-C4qpmou-.js}

@@ -1,4 +1,4 @@
-import { 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, bn as d, n as tgpu } from "./coords-CLqRuQwC.js";
 const posterizeColor = tgpu.fn([d.vec4f, d.f32], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, steps) => {
 	"use gpu";
 	const r = __tsover_div(std.floor(__tsover_mul(color.x, steps)), steps);

package/dist/core/{Prism-JLQP5dhZ.js → Prism-C0qW3WgL.js}

@@ -1,6 +1,6 @@
-import { jt as call, n as tgpu, sn as d, z as std } from "./coords-DLZT4HVT.js";
-import { a as transformColor, c as transformPosition } from "./transformations-P50Uo_Ju.js";
-import { t as animatedTime } from "./porters-DdcOi7BN.js";
+import { Bt as call, J as std, bn as d, n as tgpu } from "./coords-CLqRuQwC.js";
+import { a as transformColor, c as transformPosition } from "./transformations-t0d2-uSX.js";
+import { t as animatedTime } from "./porters-u50QU6Yv.js";
 const prismHue2Rgb = tgpu.fn([d.f32], d.vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((h) => {
 	"use gpu";
 	const x = __tsover_mul(std.fract(h), 6);

package/dist/core/{ProgressiveBlur-DpERTuHY.js → ProgressiveBlur-C_xtFzmP.js}

@@ -1,5 +1,5 @@
-import { Gt as unpremultiplyAlpha, 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 { c as transformPosition, r as transformAngle } from "./transformations-P50Uo_Ju.js";
+import { Bt as call, J as std, 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-CLqRuQwC.js";
+import { c as transformPosition, r as transformAngle } from "./transformations-t0d2-uSX.js";
 var DEG_TO_RAD = Math.PI / 180;
 const INTENSITY_TO_RADIUS = .36;
 const intensityToRadius = (intensity) => intensity * INTENSITY_TO_RADIUS;

package/dist/core/{RadialGradient-N4mHVX7b.js → RadialGradient-DetBcKps.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 { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-P50Uo_Ju.js";
-import { m as colorStopsPropConfig } from "./porters-DdcOi7BN.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-CLqRuQwC.js";
+import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-t0d2-uSX.js";
+import { m as colorStopsPropConfig } from "./porters-u50QU6Yv.js";
 var DEG_TO_RAD = .017453292519943295;
 const radialFinalT = tgpu.fn([
 	d.vec2f,

package/dist/core/RadialWipe-Cmv05uxE.js

@@ -0,0 +1,528 @@
+import { Bt as call, J as std, Rt as ZERO, Wt as floatE, bn as d, n as tgpu } from "./coords-CLqRuQwC.js";
+import { c as transformPosition, i as transformBoolean } from "./transformations-t0d2-uSX.js";
+var DEG_TO_RAD = Math.PI / 180;
+var TWO_PI = Math.PI * 2;
+var transformDirection = (value) => {
+	switch (value) {
+		case "cw": return 0;
+		case "ccw": return 1;
+		case "both": return 2;
+		default: return 0;
+	}
+};
+const radialWipeMask = tgpu.fn([
+	d.vec4f,
+	d.vec2f,
+	d.f32,
+	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, center, startDeg, progress, feather, mode, invert) => {
+	"use gpu";
+	const rel = d.vec2f(__tsover_mul(__tsover_sub(uv.x, center.x), aspect), __tsover_sub(uv.y, __tsover_sub(1, center.y)));
+	const ang = std.atan2(rel.y, rel.x);
+	const start = __tsover_mul(startDeg, DEG_TO_RAD);
+	let frac = __tsover_div(__tsover_sub(ang, start), TWO_PI);
+	frac = __tsover_sub(frac, std.floor(frac));
+	const ccwCoord = __tsover_sub(1, frac);
+	const bothCoord = __tsover_mul(std.min(frac, __tsover_sub(1, frac)), 2);
+	let coord = std.select(frac, ccwCoord, mode > .5);
+	coord = std.select(coord, bothCoord, mode > 1.5);
+	coord = std.select(coord, __tsover_sub(1, coord), invert > 0);
+	const f = std.max(feather, 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), coord);
+	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": "center"
+			},
+			{
+				"type": "i",
+				"name": "startDeg"
+			},
+			{
+				"type": "i",
+				"name": "progress"
+			},
+			{
+				"type": "i",
+				"name": "feather"
+			},
+			{
+				"type": "i",
+				"name": "mode"
+			},
+			{
+				"type": "i",
+				"name": "invert"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"rel",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec2f"
+					],
+					[[
+						1,
+						[
+							1,
+							[
+								7,
+								"uv",
+								"x"
+							],
+							"-",
+							[
+								7,
+								"center",
+								"x"
+							]
+						],
+						"*",
+						"aspect"
+					], [
+						1,
+						[
+							7,
+							"uv",
+							"y"
+						],
+						"-",
+						[
+							1,
+							[5, "1"],
+							"-",
+							[
+								7,
+								"center",
+								"y"
+							]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"ang",
+				[
+					6,
+					[
+						7,
+						"std",
+						"atan2"
+					],
+					[[
+						7,
+						"rel",
+						"y"
+					], [
+						7,
+						"rel",
+						"x"
+					]]
+				]
+			],
+			[
+				13,
+				"start",
+				[
+					1,
+					"startDeg",
+					"*",
+					"DEG_TO_RAD"
+				]
+			],
+			[
+				12,
+				"frac",
+				[
+					1,
+					[
+						1,
+						"ang",
+						"-",
+						"start"
+					],
+					"/",
+					"TWO_PI"
+				]
+			],
+			[
+				2,
+				"frac",
+				"=",
+				[
+					1,
+					"frac",
+					"-",
+					[
+						6,
+						[
+							7,
+							"std",
+							"floor"
+						],
+						["frac"]
+					]
+				]
+			],
+			[
+				13,
+				"ccwCoord",
+				[
+					1,
+					[5, "1"],
+					"-",
+					"frac"
+				]
+			],
+			[
+				13,
+				"bothCoord",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"std",
+							"min"
+						],
+						["frac", [
+							1,
+							[5, "1"],
+							"-",
+							"frac"
+						]]
+					],
+					"*",
+					[5, "2"]
+				]
+			],
+			[
+				12,
+				"coord",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"frac",
+						"ccwCoord",
+						[
+							1,
+							"mode",
+							">",
+							[5, "0.5"]
+						]
+					]
+				]
+			],
+			[
+				2,
+				"coord",
+				"=",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"coord",
+						"bothCoord",
+						[
+							1,
+							"mode",
+							">",
+							[5, "1.5"]
+						]
+					]
+				]
+			],
+			[
+				2,
+				"coord",
+				"=",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"coord",
+						[
+							1,
+							[5, "1"],
+							"-",
+							"coord"
+						],
+						[
+							1,
+							"invert",
+							">",
+							[5, "0"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"f",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					["feather", [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"
+						],
+						"coord"
+					]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"d",
+					"vec4f"
+				],
+				[
+					[
+						7,
+						"color",
+						"x"
+					],
+					[
+						7,
+						"color",
+						"y"
+					],
+					[
+						7,
+						"color",
+						"z"
+					],
+					[
+						1,
+						[
+							7,
+							"color",
+							"w"
+						],
+						"*",
+						"reveal"
+					]
+				]
+			]]
+		]],
+		"externalNames": [
+			"d",
+			"std",
+			"DEG_TO_RAD",
+			"TWO_PI"
+		]
+	},
+	externals: () => ({
+		d,
+		std,
+		DEG_TO_RAD,
+		TWO_PI
+	})
+}) && $.f)({}));
+const componentDefinition = {
+	name: "RadialWipe",
+	boundingBoxDeclaration: { aspectRatio: null },
+	category: "Transitions",
+	description: "Sweep the content away in a clock-hand arc around a center point",
+	requiresChild: true,
+	props: {
+		progress: {
+			default: .5,
+			description: "How far the sweep has travelled (0 = fully visible, 1 = fully wiped away)",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Progress",
+				group: "Transition"
+			}
+		},
+		startAngle: {
+			default: 0,
+			description: "Angle in degrees where the sweep begins",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Start Angle",
+				group: "Transition"
+			}
+		},
+		direction: {
+			default: "cw",
+			compileTime: true,
+			description: "Which way the sweep rotates",
+			ui: {
+				type: "select",
+				options: [
+					{
+						label: "Clockwise",
+						value: "cw"
+					},
+					{
+						label: "Counter-Clockwise",
+						value: "ccw"
+					},
+					{
+						label: "Both",
+						value: "both"
+					}
+				],
+				label: "Direction",
+				group: "Transition"
+			}
+		},
+		center: {
+			default: {
+				x: .5,
+				y: .5
+			},
+			transform: transformPosition,
+			description: "Point the sweep rotates around",
+			ui: {
+				type: "position",
+				label: "Center",
+				group: "Position"
+			}
+		},
+		feather: {
+			default: .1,
+			description: "Softness of the sweeping edge",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Feather",
+				group: "Transition"
+			}
+		},
+		invert: {
+			default: false,
+			transform: transformBoolean,
+			description: "Reverse which side of the sweep is wiped",
+			ui: {
+				type: "checkbox",
+				label: "Invert",
+				group: "Transition"
+			}
+		}
+	},
+	fragment: ({ uniforms, childNode, ctx, propValues }) => {
+		if (!childNode) {
+			console.error("You must pass a child component into the Radial Wipe shader.");
+			return ZERO;
+		}
+		const mode = transformDirection(propValues.direction ?? "cw");
+		return call(radialWipeMask, "radialWipeMask", [
+			childNode,
+			ctx.uv,
+			ctx.aspect,
+			uniforms.center,
+			uniforms.startAngle,
+			uniforms.progress,
+			uniforms.feather,
+			floatE(mode),
+			uniforms.invert
+		]);
+	}
+};
+var RadialWipe_default = componentDefinition;
+export { componentDefinition as n, radialWipeMask as r, RadialWipe_default as t };