shaders 3.0.441 → 3.0.443

package/dist/core/Bend-B7PMQ3T5.js

@@ -0,0 +1,848 @@
+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-0A7CojvN.js";
+import { s as transformEdges } from "./transformations-P50Uo_Ju.js";
+var DEG_TO_RAD = Math.PI / 180;
+var CAMERA_D = 2;
+var B_MAX = 1.2;
+const bendRemap = tgpu.fn([
+	d.f32,
+	d.f32,
+	d.f32,
+	d.vec2f,
+	d.f32
+], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((strength, falloff, angle, uv, aspect) => {
+	"use gpu";
+	const angleRad = __tsover_mul(angle, DEG_TO_RAD);
+	const dir = d.vec2f(std.cos(angleRad), std.sin(angleRad));
+	const perp = d.vec2f(__tsover_mul(dir.y, -1), dir.x);
+	const p = d.vec2f(__tsover_mul(__tsover_sub(uv.x, .5), aspect), __tsover_sub(uv.y, .5));
+	const sScreen = std.dot(p, dir);
+	const tScreen = std.dot(p, perp);
+	const sHalf = std.max(__tsover_mul(__tsover_add(__tsover_mul(std.abs(dir.x), aspect), std.abs(dir.y)), .5), .001);
+	const snScreen = __tsover_div(sScreen, sHalf);
+	const b = __tsover_mul(strength, B_MAX);
+	const f = __tsover_mul(std.clamp(falloff, 0, 1), .9);
+	const fSpan = __tsover_sub(1, f);
+	const m = std.abs(snScreen);
+	const sig = std.select(d.f32(-1), d.f32(1), snScreen >= 0);
+	const a2 = __tsover_mul(b, m);
+	const disc = __tsover_add(__tsover_mul(__tsover_mul(__tsover_mul(CAMERA_D, CAMERA_D), fSpan), fSpan), __tsover_mul(__tsover_mul(__tsover_mul(4, a2), CAMERA_D), __tsover_sub(m, f)));
+	const nearZero = std.abs(a2) < 1e-5;
+	const denom = std.select(__tsover_mul(a2, 2), d.f32(1), nearZero);
+	const uQuad = __tsover_div(__tsover_sub(std.sqrt(std.max(disc, 0)), __tsover_mul(CAMERA_D, fSpan)), denom);
+	const uOn = std.select(uQuad, __tsover_div(__tsover_sub(m, f), fSpan), nearZero);
+	const u = std.select(d.f32(6), std.max(uOn, 0), disc >= 0);
+	const snBend = __tsover_mul(sig, __tsover_add(f, __tsover_mul(u, fSpan)));
+	const inFlat = m <= f;
+	const sn = std.select(snBend, snScreen, inFlat);
+	const z = std.select(__tsover_mul(__tsover_mul(b, u), u), d.f32(0), inFlat);
+	const tSrc = __tsover_div(__tsover_mul(tScreen, __tsover_sub(CAMERA_D, z)), CAMERA_D);
+	const srcP = dir.mul(__tsover_mul(sn, sHalf)).add(perp.mul(tSrc));
+	return d.vec2f(__tsover_add(__tsover_div(srcP.x, aspect), .5), __tsover_add(srcP.y, .5));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "strength"
+			},
+			{
+				"type": "i",
+				"name": "falloff"
+			},
+			{
+				"type": "i",
+				"name": "angle"
+			},
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "aspect"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"angleRad",
+				[
+					1,
+					"angle",
+					"*",
+					"DEG_TO_RAD"
+				]
+			],
+			[
+				13,
+				"dir",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec2f"
+					],
+					[[
+						6,
+						[
+							7,
+							"std",
+							"cos"
+						],
+						["angleRad"]
+					], [
+						6,
+						[
+							7,
+							"std",
+							"sin"
+						],
+						["angleRad"]
+					]]
+				]
+			],
+			[
+				13,
+				"perp",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec2f"
+					],
+					[[
+						1,
+						[
+							7,
+							"dir",
+							"y"
+						],
+						"*",
+						[
+							4,
+							"-",
+							[5, "1"]
+						]
+					], [
+						7,
+						"dir",
+						"x"
+					]]
+				]
+			],
+			[
+				13,
+				"p",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec2f"
+					],
+					[[
+						1,
+						[
+							1,
+							[
+								7,
+								"uv",
+								"x"
+							],
+							"-",
+							[5, "0.5"]
+						],
+						"*",
+						"aspect"
+					], [
+						1,
+						[
+							7,
+							"uv",
+							"y"
+						],
+						"-",
+						[5, "0.5"]
+					]]
+				]
+			],
+			[
+				13,
+				"sScreen",
+				[
+					6,
+					[
+						7,
+						"std",
+						"dot"
+					],
+					["p", "dir"]
+				]
+			],
+			[
+				13,
+				"tScreen",
+				[
+					6,
+					[
+						7,
+						"std",
+						"dot"
+					],
+					["p", "perp"]
+				]
+			],
+			[
+				13,
+				"sHalf",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					[[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									6,
+									[
+										7,
+										"std",
+										"abs"
+									],
+									[[
+										7,
+										"dir",
+										"x"
+									]]
+								],
+								"*",
+								"aspect"
+							],
+							"+",
+							[
+								6,
+								[
+									7,
+									"std",
+									"abs"
+								],
+								[[
+									7,
+									"dir",
+									"y"
+								]]
+							]
+						],
+						"*",
+						[5, "0.5"]
+					], [5, "0.001"]]
+				]
+			],
+			[
+				13,
+				"snScreen",
+				[
+					1,
+					"sScreen",
+					"/",
+					"sHalf"
+				]
+			],
+			[
+				13,
+				"b",
+				[
+					1,
+					"strength",
+					"*",
+					"B_MAX"
+				]
+			],
+			[
+				13,
+				"f",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"std",
+							"clamp"
+						],
+						[
+							"falloff",
+							[5, "0"],
+							[5, "1"]
+						]
+					],
+					"*",
+					[5, "0.9"]
+				]
+			],
+			[
+				13,
+				"fSpan",
+				[
+					1,
+					[5, "1"],
+					"-",
+					"f"
+				]
+			],
+			[
+				13,
+				"m",
+				[
+					6,
+					[
+						7,
+						"std",
+						"abs"
+					],
+					["snScreen"]
+				]
+			],
+			[
+				13,
+				"sig",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[
+								4,
+								"-",
+								[5, "1"]
+							]]
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "1"]]
+						],
+						[
+							1,
+							"snScreen",
+							">=",
+							[5, "0"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"a2",
+				[
+					1,
+					"b",
+					"*",
+					"m"
+				]
+			],
+			[
+				13,
+				"disc",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								"CAMERA_D",
+								"*",
+								"CAMERA_D"
+							],
+							"*",
+							"fSpan"
+						],
+						"*",
+						"fSpan"
+					],
+					"+",
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								[5, "4"],
+								"*",
+								"a2"
+							],
+							"*",
+							"CAMERA_D"
+						],
+						"*",
+						[
+							1,
+							"m",
+							"-",
+							"f"
+						]
+					]
+				]
+			],
+			[
+				13,
+				"nearZero",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"std",
+							"abs"
+						],
+						["a2"]
+					],
+					"<",
+					[5, "0.00001"]
+				]
+			],
+			[
+				13,
+				"denom",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						[
+							1,
+							"a2",
+							"*",
+							[5, "2"]
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "1"]]
+						],
+						"nearZero"
+					]
+				]
+			],
+			[
+				13,
+				"uQuad",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"std",
+								"sqrt"
+							],
+							[[
+								6,
+								[
+									7,
+									"std",
+									"max"
+								],
+								["disc", [5, "0"]]
+							]]
+						],
+						"-",
+						[
+							1,
+							"CAMERA_D",
+							"*",
+							"fSpan"
+						]
+					],
+					"/",
+					"denom"
+				]
+			],
+			[
+				13,
+				"uOn",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"uQuad",
+						[
+							1,
+							[
+								1,
+								"m",
+								"-",
+								"f"
+							],
+							"/",
+							"fSpan"
+						],
+						"nearZero"
+					]
+				]
+			],
+			[
+				13,
+				"u",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "6"]]
+						],
+						[
+							6,
+							[
+								7,
+								"std",
+								"max"
+							],
+							["uOn", [5, "0"]]
+						],
+						[
+							1,
+							"disc",
+							">=",
+							[5, "0"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"snBend",
+				[
+					1,
+					"sig",
+					"*",
+					[
+						1,
+						"f",
+						"+",
+						[
+							1,
+							"u",
+							"*",
+							"fSpan"
+						]
+					]
+				]
+			],
+			[
+				13,
+				"inFlat",
+				[
+					1,
+					"m",
+					"<=",
+					"f"
+				]
+			],
+			[
+				13,
+				"sn",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"snBend",
+						"snScreen",
+						"inFlat"
+					]
+				]
+			],
+			[
+				13,
+				"z",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						[
+							1,
+							[
+								1,
+								"b",
+								"*",
+								"u"
+							],
+							"*",
+							"u"
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "0"]]
+						],
+						"inFlat"
+					]
+				]
+			],
+			[
+				13,
+				"tSrc",
+				[
+					1,
+					[
+						1,
+						"tScreen",
+						"*",
+						[
+							1,
+							"CAMERA_D",
+							"-",
+							"z"
+						]
+					],
+					"/",
+					"CAMERA_D"
+				]
+			],
+			[
+				13,
+				"srcP",
+				[
+					6,
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								"dir",
+								"mul"
+							],
+							[[
+								1,
+								"sn",
+								"*",
+								"sHalf"
+							]]
+						],
+						"add"
+					],
+					[[
+						6,
+						[
+							7,
+							"perp",
+							"mul"
+						],
+						["tSrc"]
+					]]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"d",
+					"vec2f"
+				],
+				[[
+					1,
+					[
+						1,
+						[
+							7,
+							"srcP",
+							"x"
+						],
+						"/",
+						"aspect"
+					],
+					"+",
+					[5, "0.5"]
+				], [
+					1,
+					[
+						7,
+						"srcP",
+						"y"
+					],
+					"+",
+					[5, "0.5"]
+				]]
+			]]
+		]],
+		"externalNames": [
+			"DEG_TO_RAD",
+			"d",
+			"std",
+			"B_MAX",
+			"CAMERA_D"
+		]
+	},
+	externals: () => ({
+		DEG_TO_RAD,
+		d,
+		std,
+		B_MAX,
+		CAMERA_D
+	})
+}) && $.f)({}));
+const componentDefinition = {
+	name: "Bend",
+	category: "Distortions",
+	description: "Bends the ends of the frame toward you like a curved display — content at the edges swells closer under real perspective, or curls away when the strength goes negative",
+	requiresRTT: true,
+	requiresChild: true,
+	boundingBoxDeclaration: { aspectRatio: null },
+	props: {
+		strength: {
+			default: .5,
+			description: "How hard the ends bend — positive curls them toward you (edges magnify), negative curls them away (edges recede into the frame)",
+			ui: {
+				type: ["range", "map"],
+				min: -1,
+				max: 1,
+				step: .01,
+				label: "Strength",
+				group: "Effect"
+			}
+		},
+		falloff: {
+			default: 0,
+			description: "Concentrates the bend toward the ends — 0 curves the whole frame, higher keeps the middle flat and bends only near the edges",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Falloff",
+				group: "Effect"
+			}
+		},
+		angle: {
+			default: 0,
+			description: "Direction of the bend axis in degrees — 0 bends the left/right ends, 90 bends the top/bottom",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Angle",
+				group: "Effect"
+			}
+		},
+		edges: {
+			default: "transparent",
+			description: "How to handle edges when the bend pulls content away from the frame border",
+			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: ({ uniforms, childNode, ctx, propValues, convertToTexture }) => {
+		if (!childNode) {
+			console.error("You must pass a child component into the Bend shader.");
+			return ZERO;
+		}
+		const texture = convertToTexture(childNode);
+		const edgeMode = propValues.edges ?? 0;
+		return call(unpremultiplyAlpha, "unpremultiplyAlpha", [applyEdgeHandlingExpr(call(bendRemap, "bendRemap", [
+			uniforms.strength,
+			uniforms.falloff,
+			uniforms.angle,
+			ctx.uv,
+			ctx.aspect
+		]), (uv) => texture.sample(uv), edgeMode)]);
+	},
+	uvRemap: ({ uv, mask, uniforms, aspect, propValues }) => {
+		const edgeMode = propValues.edges ?? 0;
+		return composeEdgeRemapExpr(call(bendRemap, "bendRemap", [
+			uniforms.strength,
+			uniforms.falloff,
+			uniforms.angle,
+			uv,
+			aspect
+		]), mask, edgeMode);
+	}
+};
+var Bend_default = componentDefinition;
+export { bendRemap as n, componentDefinition as r, Bend_default as t };