shaders 3.0.441 → 3.0.443

package/dist/core/DisplacementMap-JV_CNJfU.js

@@ -0,0 +1,536 @@
+import { At as applyEdgeHandlingExpr, Bt as call, J as std, Rt as ZERO, bn as d, n as tgpu, rn as unpremultiplyAlpha } from "./coords-0A7CojvN.js";
+import { s as transformEdges } from "./transformations-P50Uo_Ju.js";
+var DEG_TO_RAD = Math.PI / 180;
+const dmDisplaceRG = tgpu.fn([
+	d.vec2f,
+	d.vec4f,
+	d.f32,
+	d.f32
+], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, src, aspect, amount) => {
+	"use gpu";
+	const a = std.max(src.w, 1e-4);
+	const dx = __tsover_div(__tsover_mul(__tsover_mul(__tsover_mul(__tsover_sub(__tsover_div(src.x, a), .5), 2), src.w), amount), aspect);
+	const dy = __tsover_mul(__tsover_mul(__tsover_mul(__tsover_sub(__tsover_div(src.y, a), .5), 2), src.w), amount);
+	return d.vec2f(__tsover_add(uv.x, dx), __tsover_add(uv.y, dy));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "src"
+			},
+			{
+				"type": "i",
+				"name": "aspect"
+			},
+			{
+				"type": "i",
+				"name": "amount"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"a",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					[[
+						7,
+						"src",
+						"w"
+					], [5, "0.0001"]]
+				]
+			],
+			[
+				13,
+				"dx",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									[
+										1,
+										[
+											7,
+											"src",
+											"x"
+										],
+										"/",
+										"a"
+									],
+									"-",
+									[5, "0.5"]
+								],
+								"*",
+								[5, "2"]
+							],
+							"*",
+							[
+								7,
+								"src",
+								"w"
+							]
+						],
+						"*",
+						"amount"
+					],
+					"/",
+					"aspect"
+				]
+			],
+			[
+				13,
+				"dy",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									[
+										7,
+										"src",
+										"y"
+									],
+									"/",
+									"a"
+								],
+								"-",
+								[5, "0.5"]
+							],
+							"*",
+							[5, "2"]
+						],
+						"*",
+						[
+							7,
+							"src",
+							"w"
+						]
+					],
+					"*",
+					"amount"
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"d",
+					"vec2f"
+				],
+				[[
+					1,
+					[
+						7,
+						"uv",
+						"x"
+					],
+					"+",
+					"dx"
+				], [
+					1,
+					[
+						7,
+						"uv",
+						"y"
+					],
+					"+",
+					"dy"
+				]]
+			]]
+		]],
+		"externalNames": ["std", "d"]
+	},
+	externals: () => ({
+		std,
+		d
+	})
+}) && $.f)({}));
+const dmDisplaceLuminance = tgpu.fn([
+	d.vec2f,
+	d.vec4f,
+	d.f32,
+	d.f32,
+	d.f32
+], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, src, aspect, amount, angleDeg) => {
+	"use gpu";
+	const a = std.max(src.w, 1e-4);
+	const lum = std.dot(d.vec3f(__tsover_div(src.x, a), __tsover_div(src.y, a), __tsover_div(src.z, a)), d.vec3f(.2126, .7152, .0722));
+	const scalar = __tsover_mul(__tsover_mul(__tsover_mul(__tsover_sub(lum, .5), 2), src.w), amount);
+	const angleRad = __tsover_mul(angleDeg, DEG_TO_RAD);
+	const dx = __tsover_div(__tsover_mul(scalar, std.cos(angleRad)), aspect);
+	const dy = __tsover_mul(scalar, std.sin(angleRad));
+	return d.vec2f(__tsover_add(uv.x, dx), __tsover_add(uv.y, dy));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "src"
+			},
+			{
+				"type": "i",
+				"name": "aspect"
+			},
+			{
+				"type": "i",
+				"name": "amount"
+			},
+			{
+				"type": "i",
+				"name": "angleDeg"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"a",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					[[
+						7,
+						"src",
+						"w"
+					], [5, "0.0001"]]
+				]
+			],
+			[
+				13,
+				"lum",
+				[
+					6,
+					[
+						7,
+						"std",
+						"dot"
+					],
+					[[
+						6,
+						[
+							7,
+							"d",
+							"vec3f"
+						],
+						[
+							[
+								1,
+								[
+									7,
+									"src",
+									"x"
+								],
+								"/",
+								"a"
+							],
+							[
+								1,
+								[
+									7,
+									"src",
+									"y"
+								],
+								"/",
+								"a"
+							],
+							[
+								1,
+								[
+									7,
+									"src",
+									"z"
+								],
+								"/",
+								"a"
+							]
+						]
+					], [
+						6,
+						[
+							7,
+							"d",
+							"vec3f"
+						],
+						[
+							[5, "0.2126"],
+							[5, "0.7152"],
+							[5, "0.0722"]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"scalar",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								"lum",
+								"-",
+								[5, "0.5"]
+							],
+							"*",
+							[5, "2"]
+						],
+						"*",
+						[
+							7,
+							"src",
+							"w"
+						]
+					],
+					"*",
+					"amount"
+				]
+			],
+			[
+				13,
+				"angleRad",
+				[
+					1,
+					"angleDeg",
+					"*",
+					"DEG_TO_RAD"
+				]
+			],
+			[
+				13,
+				"dx",
+				[
+					1,
+					[
+						1,
+						"scalar",
+						"*",
+						[
+							6,
+							[
+								7,
+								"std",
+								"cos"
+							],
+							["angleRad"]
+						]
+					],
+					"/",
+					"aspect"
+				]
+			],
+			[
+				13,
+				"dy",
+				[
+					1,
+					"scalar",
+					"*",
+					[
+						6,
+						[
+							7,
+							"std",
+							"sin"
+						],
+						["angleRad"]
+					]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"d",
+					"vec2f"
+				],
+				[[
+					1,
+					[
+						7,
+						"uv",
+						"x"
+					],
+					"+",
+					"dx"
+				], [
+					1,
+					[
+						7,
+						"uv",
+						"y"
+					],
+					"+",
+					"dy"
+				]]
+			]]
+		]],
+		"externalNames": [
+			"std",
+			"d",
+			"DEG_TO_RAD"
+		]
+	},
+	externals: () => ({
+		std,
+		d,
+		DEG_TO_RAD
+	})
+}) && $.f)({}));
+var CHANNEL_MODES = {
+	twoAxis: 0,
+	directional: 1
+};
+function channelModeOf(raw) {
+	if (typeof raw === "number") return raw;
+	return CHANNEL_MODES[raw] ?? 0;
+}
+const componentDefinition = {
+	name: "DisplacementMap",
+	category: "Distortions",
+	description: "Distorts child content using another layer's pixels as a displacement map",
+	requiresRTT: true,
+	requiresChild: true,
+	boundingBoxDeclaration: { aspectRatio: null },
+	props: {
+		source: {
+			default: "",
+			description: "The layer whose pixels drive the displacement — its red/green (or luminance) push the content around",
+			compileTime: true,
+			ui: {
+				type: "layer",
+				label: "Source Layer",
+				group: "Effect"
+			}
+		},
+		amount: {
+			default: .3,
+			description: "Overall displacement strength",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Amount",
+				group: "Effect"
+			}
+		},
+		channelMode: {
+			default: "twoAxis",
+			description: "How the source drives the push — red→X / green→Y, or luminance along a fixed angle",
+			compileTime: true,
+			transform: (value) => CHANNEL_MODES[value] ?? 0,
+			ui: {
+				type: "select",
+				options: [{
+					label: "Red / Green",
+					value: "twoAxis"
+				}, {
+					label: "Luminance",
+					value: "directional"
+				}],
+				label: "Channels",
+				group: "Effect"
+			}
+		},
+		angle: {
+			default: 0,
+			description: "Push direction in degrees (used by the Luminance channel mode)",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Angle",
+				group: "Effect",
+				condition: { channelMode: "directional" }
+			}
+		},
+		edges: {
+			default: "mirror",
+			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"
+			}
+		}
+	},
+	fragment: (params) => {
+		const { uniforms, childNode, ctx, propValues, convertToTexture, getLayerTexture } = params;
+		if (!childNode) return ZERO;
+		const texture = convertToTexture(childNode);
+		const source = getLayerTexture("source");
+		if (!source) return call(unpremultiplyAlpha, "unpremultiplyAlpha", [texture.sample(ctx.uv)]);
+		const edgeMode = propValues.edges ?? 0;
+		const src = source.sample(ctx.uv);
+		return call(unpremultiplyAlpha, "unpremultiplyAlpha", [applyEdgeHandlingExpr(channelModeOf(propValues.channelMode) === 1 ? call(dmDisplaceLuminance, "dmDisplaceLuminance", [
+			ctx.uv,
+			src,
+			ctx.aspect,
+			uniforms.amount,
+			uniforms.angle
+		]) : call(dmDisplaceRG, "dmDisplaceRG", [
+			ctx.uv,
+			src,
+			ctx.aspect,
+			uniforms.amount
+		]), (uv) => texture.sample(uv), edgeMode)]);
+	}
+};
+var DisplacementMap_default = componentDefinition;
+export { dmDisplaceRG as i, componentDefinition as n, dmDisplaceLuminance as r, DisplacementMap_default as t };

package/dist/core/{Dither-B8yxWNxE.js → Dither-NJDWpGb3.js}

@@ -1,4 +1,4 @@
-import { At as arrayExpr, 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, zt as arrayExpr } from "./coords-0A7CojvN.js";
 import { a as transformColor } from "./transformations-P50Uo_Ju.js";
 var transformPattern = (value) => {
 	return {

package/dist/core/{DotGrid-Doh7yuqR.js → DotGrid-B2w7RFcv.js}

@@ -1,6 +1,6 @@
-import { Lt as vec4, jt as call, n as tgpu, sn as d, z as std } from "./coords-DLZT4HVT.js";
+import { Bt as call, J as std, Kt as vec4, bn as d, n as tgpu } from "./coords-0A7CojvN.js";
 import { a as transformColor } from "./transformations-P50Uo_Ju.js";
-import { t as animatedTime } from "./porters-DdcOi7BN.js";
+import { t as animatedTime } from "./porters-B1jqpcE3.js";
 const dotGridCellCenterUV = tgpu.fn([
 	d.vec2f,
 	d.vec2f,

package/dist/core/{DropShadow-DhHQBpiK.js → DropShadow-CLWp-bon.js}

@@ -1,4 +1,4 @@
-import { Ft as floatE, 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, Wt as floatE, bn as d, n as tgpu, rn as unpremultiplyAlpha } from "./coords-0A7CojvN.js";
 import { a as transformColor, i as transformBoolean } from "./transformations-P50Uo_Ju.js";
 var DEG_TO_RAD = .017453292519943295;
 var WEIGHTS = [

package/dist/core/{Duotone-DA3IudVy.js → Duotone-Be2jx-jZ.js}

@@ -1,4 +1,4 @@
-import { $t as mixColorsVariants, Lt as vec4, Qt as mixColorsLinear, 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, dn as mixColorsVariants, n as tgpu, un as mixColorsLinear } from "./coords-0A7CojvN.js";
 import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-P50Uo_Ju.js";
 const duotoneFactor = tgpu.fn([d.vec4f, d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, blend) => {
 	"use gpu";

package/dist/core/{Ellipse-m1D5EVjj.js → Ellipse-BR6qXidK.js}

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

package/dist/core/{Emboss-C3NBF44G.js → Emboss-C8ElxLo3.js}

@@ -1,7 +1,7 @@
-import { E as sdf_exports, Ft as floatE, Gt as unpremultiplyAlpha, d as sdf3d_exports, jt as call, kt as ZERO, 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 { Bt as call, F as sdf_exports, J as std, Rt as ZERO, Sn as __export, Wt as floatE, bn as d, n as tgpu, rn as unpremultiplyAlpha, y as sdf3d_exports } from "./coords-0A7CojvN.js";
+import { i as sdfSpaceUV, r as offsetUV } from "./glass-BjUqcmHP.js";
 import { c as transformPosition } from "./transformations-P50Uo_Ju.js";
-import { t as shapeEffectBoundingBoxDeclaration } from "./shapeEffectBounds-BglTGD4B.js";
+import { t as shapeEffectBoundingBoxDeclaration } from "./shapeEffectBounds-DRyn6AvG.js";
 var emboss_exports = /* @__PURE__ */ __export({
 	applyEmbossEffect: () => applyEmbossEffect$1,
 	embossComposite: () => embossComposite,

package/dist/core/{Engraving-Bz503L4R.js → Engraving-D67DM--1.js}

@@ -1,4 +1,4 @@
-import { Ft as floatE, Gt as unpremultiplyAlpha, Lt as vec4, it as noise_exports, jt as call, kt as ZERO, n as tgpu, sn as d, tt as mxNoiseFloat2, z as std } from "./coords-DLZT4HVT.js";
+import { Bt as call, J as std, Kt as vec4, Rt as ZERO, Wt as floatE, bn as d, n as tgpu, pt as noise_exports, rn as unpremultiplyAlpha, ut as mxNoiseFloat2 } from "./coords-0A7CojvN.js";
 import { a as transformColor, c as transformPosition, r as transformAngle } from "./transformations-P50Uo_Ju.js";
 var TAU = 6.283185307179586;
 var DEG_TO_RAD = .017453292519943295;

package/dist/core/{ErosionNoise-DOOt5U2Z.js → ErosionNoise-FeEMQOkR.js}

@@ -1,5 +1,5 @@
-import { G as toneAndColorExpr, Y as erosion12, 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, it as erosion12, n as tgpu, pt as noise_exports } from "./coords-0A7CojvN.js";
+import { i as noiseToneProps, t as noiseColorProps } from "./noiseColor-w3B94vmT.js";
 const erosionNoiseField = tgpu.fn([
 	d.vec2f,
 	d.vec2f,

package/dist/core/{Exposure-DkQ4kanv.js → Exposure-CZ1gfqpf.js}

@@ -1,4 +1,4 @@
-import { jt as call, kt as ZERO, n as tgpu, sn as d } from "./coords-DLZT4HVT.js";
+import { Bt as call, Rt as ZERO, bn as d, n as tgpu } from "./coords-0A7CojvN.js";
 const exposureColor = tgpu.fn([d.vec4f, d.f32], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, gain) => {
 	"use gpu";
 	const rgb = color.xyz.mul(gain);

package/dist/core/{FallingLines-BE6S1TUf.js → FallingLines-ifuQ01oA.js}

@@ -1,6 +1,6 @@
-import { $t as mixColorsVariants, Lt as vec4, Qt as mixColorsLinear, jt as call, n as tgpu, sn as d, z as std } from "./coords-DLZT4HVT.js";
+import { Bt as call, J as std, Kt as vec4, bn as d, dn as mixColorsVariants, n as tgpu, un as mixColorsLinear } from "./coords-0A7CojvN.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 { t as animatedTime } from "./porters-B1jqpcE3.js";
 var DEG_TO_RAD = Math.PI / 180;
 var colHash = tgpu.fn([d.f32], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((idx) => {
 	"use gpu";

package/dist/core/{FilmGrain-9-Mgc2Ri.js → FilmGrain-p5sawa_f.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-0A7CojvN.js";
 const filmGrainColor = tgpu.fn([
 	d.vec4f,
 	d.vec2f,