shaders 2.5.135 → 3.0.437

package/dist/core/CornerPin-ecpjb9do.js

@@ -0,0 +1,1946 @@
+import { At as call, It as vec4, Ot as ZERO, R as std, Wt as unpremultiplyAlpha, bt as applyEdgeHandlingExpr, n as tgpu, on as d, xt as composeEdgeRemapExpr } from "./coords-BlwgBpJf.js";
+import { c as transformPosition, s as transformEdges } from "./transformations-fqzznt4g.js";
+var EPS = 1e-8;
+const cornerPinSafeDiv = tgpu.fn([d.f32, d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((n, dv) => {
+	"use gpu";
+	return __tsover_div(n, std.select(dv, EPS, std.abs(dv) < EPS));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "n"
+		}, {
+			"type": "i",
+			"name": "dv"
+		}],
+		"body": [0, [[10, [
+			1,
+			"n",
+			"/",
+			[
+				6,
+				[
+					7,
+					"std",
+					"select"
+				],
+				[
+					"dv",
+					"EPS",
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"std",
+								"abs"
+							],
+							["dv"]
+						],
+						"<",
+						"EPS"
+					]
+				]
+			]
+		]]]],
+		"externalNames": ["std", "EPS"]
+	},
+	externals: () => ({
+		std,
+		EPS
+	})
+}) && $.f)({}));
+const cornerSideOf = tgpu.fn([
+	d.vec2f,
+	d.vec2f,
+	d.vec2f
+], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p, a, b) => {
+	"use gpu";
+	const bax = __tsover_sub(b.x, a.x);
+	const bay = __tsover_sub(b.y, a.y);
+	const pax = __tsover_sub(p.x, a.x);
+	const pay = __tsover_sub(p.y, a.y);
+	return __tsover_sub(__tsover_mul(bax, pay), __tsover_mul(bay, pax));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "p"
+			},
+			{
+				"type": "i",
+				"name": "a"
+			},
+			{
+				"type": "i",
+				"name": "b"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"bax",
+				[
+					1,
+					[
+						7,
+						"b",
+						"x"
+					],
+					"-",
+					[
+						7,
+						"a",
+						"x"
+					]
+				]
+			],
+			[
+				13,
+				"bay",
+				[
+					1,
+					[
+						7,
+						"b",
+						"y"
+					],
+					"-",
+					[
+						7,
+						"a",
+						"y"
+					]
+				]
+			],
+			[
+				13,
+				"pax",
+				[
+					1,
+					[
+						7,
+						"p",
+						"x"
+					],
+					"-",
+					[
+						7,
+						"a",
+						"x"
+					]
+				]
+			],
+			[
+				13,
+				"pay",
+				[
+					1,
+					[
+						7,
+						"p",
+						"y"
+					],
+					"-",
+					[
+						7,
+						"a",
+						"y"
+					]
+				]
+			],
+			[10, [
+				1,
+				[
+					1,
+					"bax",
+					"*",
+					"pay"
+				],
+				"-",
+				[
+					1,
+					"bay",
+					"*",
+					"pax"
+				]
+			]]
+		]],
+		"externalNames": []
+	},
+	externals: () => ({})
+}) && $.f)({}));
+const cornerInsideTri = tgpu.fn([
+	d.vec2f,
+	d.vec2f,
+	d.vec2f,
+	d.vec2f
+], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p, a, b, c) => {
+	"use gpu";
+	const d1 = cornerSideOf(p, a, b);
+	const d2 = cornerSideOf(p, b, c);
+	const d3 = cornerSideOf(p, c, a);
+	const allPos = __tsover_mul(__tsover_mul(std.step(d.f32(0), d1), std.step(d.f32(0), d2)), std.step(d.f32(0), d3));
+	const allNeg = __tsover_mul(__tsover_mul(std.step(d1, d.f32(0)), std.step(d2, d.f32(0))), std.step(d3, d.f32(0)));
+	return __tsover_add(allPos, allNeg);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "p"
+			},
+			{
+				"type": "i",
+				"name": "a"
+			},
+			{
+				"type": "i",
+				"name": "b"
+			},
+			{
+				"type": "i",
+				"name": "c"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"d1",
+				[
+					6,
+					"cornerSideOf",
+					[
+						"p",
+						"a",
+						"b"
+					]
+				]
+			],
+			[
+				13,
+				"d2",
+				[
+					6,
+					"cornerSideOf",
+					[
+						"p",
+						"b",
+						"c"
+					]
+				]
+			],
+			[
+				13,
+				"d3",
+				[
+					6,
+					"cornerSideOf",
+					[
+						"p",
+						"c",
+						"a"
+					]
+				]
+			],
+			[
+				13,
+				"allPos",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"std",
+								"step"
+							],
+							[[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[5, "0"]]
+							], "d1"]
+						],
+						"*",
+						[
+							6,
+							[
+								7,
+								"std",
+								"step"
+							],
+							[[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[5, "0"]]
+							], "d2"]
+						]
+					],
+					"*",
+					[
+						6,
+						[
+							7,
+							"std",
+							"step"
+						],
+						[[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "0"]]
+						], "d3"]
+					]
+				]
+			],
+			[
+				13,
+				"allNeg",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"std",
+								"step"
+							],
+							["d1", [
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[5, "0"]]
+							]]
+						],
+						"*",
+						[
+							6,
+							[
+								7,
+								"std",
+								"step"
+							],
+							["d2", [
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[5, "0"]]
+							]]
+						]
+					],
+					"*",
+					[
+						6,
+						[
+							7,
+							"std",
+							"step"
+						],
+						["d3", [
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "0"]]
+						]]
+					]
+				]
+			],
+			[10, [
+				1,
+				"allPos",
+				"+",
+				"allNeg"
+			]]
+		]],
+		"externalNames": [
+			"cornerSideOf",
+			"std",
+			"d"
+		]
+	},
+	externals: () => ({
+		cornerSideOf,
+		std,
+		d
+	})
+}) && $.f)({}));
+const cornerProjectToDiagonal = tgpu.fn([
+	d.vec2f,
+	d.vec2f,
+	d.vec2f,
+	d.f32
+], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p, a, b, refSide) => {
+	"use gpu";
+	const ab = b.sub(a);
+	const t = std.clamp(__tsover_div(std.dot(p.sub(a), ab), std.max(std.dot(ab, ab), EPS)), 0, 1);
+	const foot = a.add(ab.mul(t));
+	const perp = d.vec2f(__tsover_mul(ab.y, -1), ab.x).div(std.max(std.length(ab), EPS));
+	const nudge = __tsover_mul(__tsover_mul(std.sign(refSide), -1), .004);
+	return foot.add(perp.mul(nudge));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "p"
+			},
+			{
+				"type": "i",
+				"name": "a"
+			},
+			{
+				"type": "i",
+				"name": "b"
+			},
+			{
+				"type": "i",
+				"name": "refSide"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"ab",
+				[
+					6,
+					[
+						7,
+						"b",
+						"sub"
+					],
+					["a"]
+				]
+			],
+			[
+				13,
+				"t",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"std",
+									"dot"
+								],
+								[[
+									6,
+									[
+										7,
+										"p",
+										"sub"
+									],
+									["a"]
+								], "ab"]
+							],
+							"/",
+							[
+								6,
+								[
+									7,
+									"std",
+									"max"
+								],
+								[[
+									6,
+									[
+										7,
+										"std",
+										"dot"
+									],
+									["ab", "ab"]
+								], "EPS"]
+							]
+						],
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"foot",
+				[
+					6,
+					[
+						7,
+						"a",
+						"add"
+					],
+					[[
+						6,
+						[
+							7,
+							"ab",
+							"mul"
+						],
+						["t"]
+					]]
+				]
+			],
+			[
+				13,
+				"perp",
+				[
+					6,
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec2f"
+							],
+							[[
+								1,
+								[
+									7,
+									"ab",
+									"y"
+								],
+								"*",
+								[
+									4,
+									"-",
+									[5, "1"]
+								]
+							], [
+								7,
+								"ab",
+								"x"
+							]]
+						],
+						"div"
+					],
+					[[
+						6,
+						[
+							7,
+							"std",
+							"max"
+						],
+						[[
+							6,
+							[
+								7,
+								"std",
+								"length"
+							],
+							["ab"]
+						], "EPS"]
+					]]
+				]
+			],
+			[
+				13,
+				"nudge",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"std",
+								"sign"
+							],
+							["refSide"]
+						],
+						"*",
+						[
+							4,
+							"-",
+							[5, "1"]
+						]
+					],
+					"*",
+					[5, "0.004"]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"foot",
+					"add"
+				],
+				[[
+					6,
+					[
+						7,
+						"perp",
+						"mul"
+					],
+					["nudge"]
+				]]
+			]]
+		]],
+		"externalNames": [
+			"std",
+			"EPS",
+			"d"
+		]
+	},
+	externals: () => ({
+		std,
+		EPS,
+		d
+	})
+}) && $.f)({}));
+const cornerConvexify = tgpu.fn([
+	d.vec2f,
+	d.vec2f,
+	d.vec2f,
+	d.vec2f
+], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p, a, b, o) => {
+	"use gpu";
+	const inside = cornerInsideTri(p, a, b, o) > .5;
+	const proj = cornerProjectToDiagonal(p, a, b, cornerSideOf(o, a, b));
+	return std.select(p, proj, inside);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "p"
+			},
+			{
+				"type": "i",
+				"name": "a"
+			},
+			{
+				"type": "i",
+				"name": "b"
+			},
+			{
+				"type": "i",
+				"name": "o"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"inside",
+				[
+					1,
+					[
+						6,
+						"cornerInsideTri",
+						[
+							"p",
+							"a",
+							"b",
+							"o"
+						]
+					],
+					">",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"proj",
+				[
+					6,
+					"cornerProjectToDiagonal",
+					[
+						"p",
+						"a",
+						"b",
+						[
+							6,
+							"cornerSideOf",
+							[
+								"o",
+								"a",
+								"b"
+							]
+						]
+					]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"std",
+					"select"
+				],
+				[
+					"p",
+					"proj",
+					"inside"
+				]
+			]]
+		]],
+		"externalNames": [
+			"cornerInsideTri",
+			"cornerProjectToDiagonal",
+			"cornerSideOf",
+			"std"
+		]
+	},
+	externals: () => ({
+		cornerInsideTri,
+		cornerProjectToDiagonal,
+		cornerSideOf,
+		std
+	})
+}) && $.f)({}));
+const cornerPinSample = tgpu.fn([
+	d.vec2f,
+	d.f32,
+	d.vec2f,
+	d.vec2f,
+	d.vec2f,
+	d.vec2f
+], d.vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((coord, amount, c0, c1, c2, c3) => {
+	"use gpu";
+	const amt = d.vec2f(amount, amount);
+	const r0 = std.mix(d.vec2f(0, 0), d.vec2f(c0.x, __tsover_sub(1, c0.y)), amt);
+	const r1 = std.mix(d.vec2f(1, 0), d.vec2f(c1.x, __tsover_sub(1, c1.y)), amt);
+	const r2 = std.mix(d.vec2f(1, 1), d.vec2f(c2.x, __tsover_sub(1, c2.y)), amt);
+	const r3 = std.mix(d.vec2f(0, 1), d.vec2f(c3.x, __tsover_sub(1, c3.y)), amt);
+	const q0 = cornerConvexify(r0, r1, r3, r2);
+	const q1 = cornerConvexify(r1, r0, r2, r3);
+	const q2 = cornerConvexify(r2, r1, r3, r0);
+	const q3 = cornerConvexify(r3, r0, r2, r1);
+	const dx1 = __tsover_sub(q1.x, q2.x);
+	const dx2 = __tsover_sub(q3.x, q2.x);
+	const dx3 = __tsover_sub(__tsover_add(__tsover_sub(q0.x, q1.x), q2.x), q3.x);
+	const dy1 = __tsover_sub(q1.y, q2.y);
+	const dy2 = __tsover_sub(q3.y, q2.y);
+	const dy3 = __tsover_sub(__tsover_add(__tsover_sub(q0.y, q1.y), q2.y), q3.y);
+	const denA = __tsover_sub(__tsover_mul(dx1, dy2), __tsover_mul(dx2, dy1));
+	const a13 = cornerPinSafeDiv(__tsover_sub(__tsover_mul(dx3, dy2), __tsover_mul(dx2, dy3)), denA);
+	const a23 = cornerPinSafeDiv(__tsover_sub(__tsover_mul(dx1, dy3), __tsover_mul(dx3, dy1)), denA);
+	const a11 = __tsover_add(__tsover_sub(q1.x, q0.x), __tsover_mul(a13, q1.x));
+	const a21 = __tsover_add(__tsover_sub(q3.x, q0.x), __tsover_mul(a23, q3.x));
+	const a31 = q0.x;
+	const a12 = __tsover_add(__tsover_sub(q1.y, q0.y), __tsover_mul(a13, q1.y));
+	const a22 = __tsover_add(__tsover_sub(q3.y, q0.y), __tsover_mul(a23, q3.y));
+	const a32 = q0.y;
+	const c00 = __tsover_sub(a22, __tsover_mul(a32, a23));
+	const c10 = __tsover_mul(__tsover_sub(a21, __tsover_mul(a31, a23)), -1);
+	const c20 = __tsover_sub(__tsover_mul(a21, a32), __tsover_mul(a31, a22));
+	const c01 = __tsover_mul(__tsover_sub(a12, __tsover_mul(a32, a13)), -1);
+	const c11 = __tsover_sub(a11, __tsover_mul(a31, a13));
+	const c21 = __tsover_mul(__tsover_sub(__tsover_mul(a11, a32), __tsover_mul(a31, a12)), -1);
+	const c02 = __tsover_sub(__tsover_mul(a12, a23), __tsover_mul(a22, a13));
+	const c12 = __tsover_mul(__tsover_sub(__tsover_mul(a11, a23), __tsover_mul(a21, a13)), -1);
+	const c22 = __tsover_sub(__tsover_mul(a11, a22), __tsover_mul(a21, a12));
+	const px = coord.x;
+	const py = coord.y;
+	const den = __tsover_add(__tsover_add(__tsover_mul(c02, px), __tsover_mul(c12, py)), c22);
+	const su = cornerPinSafeDiv(__tsover_add(__tsover_add(__tsover_mul(c00, px), __tsover_mul(c10, py)), c20), den);
+	const sv = cornerPinSafeDiv(__tsover_add(__tsover_add(__tsover_mul(c01, px), __tsover_mul(c11, py)), c21), den);
+	const det = __tsover_add(__tsover_add(__tsover_mul(a11, c00), __tsover_mul(a21, c01)), __tsover_mul(a31, c02));
+	const front = std.step(d.f32(0), __tsover_mul(den, det));
+	return d.vec3f(su, sv, front);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "coord"
+			},
+			{
+				"type": "i",
+				"name": "amount"
+			},
+			{
+				"type": "i",
+				"name": "c0"
+			},
+			{
+				"type": "i",
+				"name": "c1"
+			},
+			{
+				"type": "i",
+				"name": "c2"
+			},
+			{
+				"type": "i",
+				"name": "c3"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"amt",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec2f"
+					],
+					["amount", "amount"]
+				]
+			],
+			[
+				13,
+				"r0",
+				[
+					6,
+					[
+						7,
+						"std",
+						"mix"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec2f"
+							],
+							[[5, "0"], [5, "0"]]
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec2f"
+							],
+							[[
+								7,
+								"c0",
+								"x"
+							], [
+								1,
+								[5, "1"],
+								"-",
+								[
+									7,
+									"c0",
+									"y"
+								]
+							]]
+						],
+						"amt"
+					]
+				]
+			],
+			[
+				13,
+				"r1",
+				[
+					6,
+					[
+						7,
+						"std",
+						"mix"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec2f"
+							],
+							[[5, "1"], [5, "0"]]
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec2f"
+							],
+							[[
+								7,
+								"c1",
+								"x"
+							], [
+								1,
+								[5, "1"],
+								"-",
+								[
+									7,
+									"c1",
+									"y"
+								]
+							]]
+						],
+						"amt"
+					]
+				]
+			],
+			[
+				13,
+				"r2",
+				[
+					6,
+					[
+						7,
+						"std",
+						"mix"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec2f"
+							],
+							[[5, "1"], [5, "1"]]
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec2f"
+							],
+							[[
+								7,
+								"c2",
+								"x"
+							], [
+								1,
+								[5, "1"],
+								"-",
+								[
+									7,
+									"c2",
+									"y"
+								]
+							]]
+						],
+						"amt"
+					]
+				]
+			],
+			[
+				13,
+				"r3",
+				[
+					6,
+					[
+						7,
+						"std",
+						"mix"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec2f"
+							],
+							[[5, "0"], [5, "1"]]
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec2f"
+							],
+							[[
+								7,
+								"c3",
+								"x"
+							], [
+								1,
+								[5, "1"],
+								"-",
+								[
+									7,
+									"c3",
+									"y"
+								]
+							]]
+						],
+						"amt"
+					]
+				]
+			],
+			[
+				13,
+				"q0",
+				[
+					6,
+					"cornerConvexify",
+					[
+						"r0",
+						"r1",
+						"r3",
+						"r2"
+					]
+				]
+			],
+			[
+				13,
+				"q1",
+				[
+					6,
+					"cornerConvexify",
+					[
+						"r1",
+						"r0",
+						"r2",
+						"r3"
+					]
+				]
+			],
+			[
+				13,
+				"q2",
+				[
+					6,
+					"cornerConvexify",
+					[
+						"r2",
+						"r1",
+						"r3",
+						"r0"
+					]
+				]
+			],
+			[
+				13,
+				"q3",
+				[
+					6,
+					"cornerConvexify",
+					[
+						"r3",
+						"r0",
+						"r2",
+						"r1"
+					]
+				]
+			],
+			[
+				13,
+				"dx1",
+				[
+					1,
+					[
+						7,
+						"q1",
+						"x"
+					],
+					"-",
+					[
+						7,
+						"q2",
+						"x"
+					]
+				]
+			],
+			[
+				13,
+				"dx2",
+				[
+					1,
+					[
+						7,
+						"q3",
+						"x"
+					],
+					"-",
+					[
+						7,
+						"q2",
+						"x"
+					]
+				]
+			],
+			[
+				13,
+				"dx3",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								7,
+								"q0",
+								"x"
+							],
+							"-",
+							[
+								7,
+								"q1",
+								"x"
+							]
+						],
+						"+",
+						[
+							7,
+							"q2",
+							"x"
+						]
+					],
+					"-",
+					[
+						7,
+						"q3",
+						"x"
+					]
+				]
+			],
+			[
+				13,
+				"dy1",
+				[
+					1,
+					[
+						7,
+						"q1",
+						"y"
+					],
+					"-",
+					[
+						7,
+						"q2",
+						"y"
+					]
+				]
+			],
+			[
+				13,
+				"dy2",
+				[
+					1,
+					[
+						7,
+						"q3",
+						"y"
+					],
+					"-",
+					[
+						7,
+						"q2",
+						"y"
+					]
+				]
+			],
+			[
+				13,
+				"dy3",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								7,
+								"q0",
+								"y"
+							],
+							"-",
+							[
+								7,
+								"q1",
+								"y"
+							]
+						],
+						"+",
+						[
+							7,
+							"q2",
+							"y"
+						]
+					],
+					"-",
+					[
+						7,
+						"q3",
+						"y"
+					]
+				]
+			],
+			[
+				13,
+				"denA",
+				[
+					1,
+					[
+						1,
+						"dx1",
+						"*",
+						"dy2"
+					],
+					"-",
+					[
+						1,
+						"dx2",
+						"*",
+						"dy1"
+					]
+				]
+			],
+			[
+				13,
+				"a13",
+				[
+					6,
+					"cornerPinSafeDiv",
+					[[
+						1,
+						[
+							1,
+							"dx3",
+							"*",
+							"dy2"
+						],
+						"-",
+						[
+							1,
+							"dx2",
+							"*",
+							"dy3"
+						]
+					], "denA"]
+				]
+			],
+			[
+				13,
+				"a23",
+				[
+					6,
+					"cornerPinSafeDiv",
+					[[
+						1,
+						[
+							1,
+							"dx1",
+							"*",
+							"dy3"
+						],
+						"-",
+						[
+							1,
+							"dx3",
+							"*",
+							"dy1"
+						]
+					], "denA"]
+				]
+			],
+			[
+				13,
+				"a11",
+				[
+					1,
+					[
+						1,
+						[
+							7,
+							"q1",
+							"x"
+						],
+						"-",
+						[
+							7,
+							"q0",
+							"x"
+						]
+					],
+					"+",
+					[
+						1,
+						"a13",
+						"*",
+						[
+							7,
+							"q1",
+							"x"
+						]
+					]
+				]
+			],
+			[
+				13,
+				"a21",
+				[
+					1,
+					[
+						1,
+						[
+							7,
+							"q3",
+							"x"
+						],
+						"-",
+						[
+							7,
+							"q0",
+							"x"
+						]
+					],
+					"+",
+					[
+						1,
+						"a23",
+						"*",
+						[
+							7,
+							"q3",
+							"x"
+						]
+					]
+				]
+			],
+			[
+				13,
+				"a31",
+				[
+					7,
+					"q0",
+					"x"
+				]
+			],
+			[
+				13,
+				"a12",
+				[
+					1,
+					[
+						1,
+						[
+							7,
+							"q1",
+							"y"
+						],
+						"-",
+						[
+							7,
+							"q0",
+							"y"
+						]
+					],
+					"+",
+					[
+						1,
+						"a13",
+						"*",
+						[
+							7,
+							"q1",
+							"y"
+						]
+					]
+				]
+			],
+			[
+				13,
+				"a22",
+				[
+					1,
+					[
+						1,
+						[
+							7,
+							"q3",
+							"y"
+						],
+						"-",
+						[
+							7,
+							"q0",
+							"y"
+						]
+					],
+					"+",
+					[
+						1,
+						"a23",
+						"*",
+						[
+							7,
+							"q3",
+							"y"
+						]
+					]
+				]
+			],
+			[
+				13,
+				"a32",
+				[
+					7,
+					"q0",
+					"y"
+				]
+			],
+			[
+				13,
+				"c00",
+				[
+					1,
+					"a22",
+					"-",
+					[
+						1,
+						"a32",
+						"*",
+						"a23"
+					]
+				]
+			],
+			[
+				13,
+				"c10",
+				[
+					1,
+					[
+						1,
+						"a21",
+						"-",
+						[
+							1,
+							"a31",
+							"*",
+							"a23"
+						]
+					],
+					"*",
+					[
+						4,
+						"-",
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"c20",
+				[
+					1,
+					[
+						1,
+						"a21",
+						"*",
+						"a32"
+					],
+					"-",
+					[
+						1,
+						"a31",
+						"*",
+						"a22"
+					]
+				]
+			],
+			[
+				13,
+				"c01",
+				[
+					1,
+					[
+						1,
+						"a12",
+						"-",
+						[
+							1,
+							"a32",
+							"*",
+							"a13"
+						]
+					],
+					"*",
+					[
+						4,
+						"-",
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"c11",
+				[
+					1,
+					"a11",
+					"-",
+					[
+						1,
+						"a31",
+						"*",
+						"a13"
+					]
+				]
+			],
+			[
+				13,
+				"c21",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							"a11",
+							"*",
+							"a32"
+						],
+						"-",
+						[
+							1,
+							"a31",
+							"*",
+							"a12"
+						]
+					],
+					"*",
+					[
+						4,
+						"-",
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"c02",
+				[
+					1,
+					[
+						1,
+						"a12",
+						"*",
+						"a23"
+					],
+					"-",
+					[
+						1,
+						"a22",
+						"*",
+						"a13"
+					]
+				]
+			],
+			[
+				13,
+				"c12",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							"a11",
+							"*",
+							"a23"
+						],
+						"-",
+						[
+							1,
+							"a21",
+							"*",
+							"a13"
+						]
+					],
+					"*",
+					[
+						4,
+						"-",
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"c22",
+				[
+					1,
+					[
+						1,
+						"a11",
+						"*",
+						"a22"
+					],
+					"-",
+					[
+						1,
+						"a21",
+						"*",
+						"a12"
+					]
+				]
+			],
+			[
+				13,
+				"px",
+				[
+					7,
+					"coord",
+					"x"
+				]
+			],
+			[
+				13,
+				"py",
+				[
+					7,
+					"coord",
+					"y"
+				]
+			],
+			[
+				13,
+				"den",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							"c02",
+							"*",
+							"px"
+						],
+						"+",
+						[
+							1,
+							"c12",
+							"*",
+							"py"
+						]
+					],
+					"+",
+					"c22"
+				]
+			],
+			[
+				13,
+				"su",
+				[
+					6,
+					"cornerPinSafeDiv",
+					[[
+						1,
+						[
+							1,
+							[
+								1,
+								"c00",
+								"*",
+								"px"
+							],
+							"+",
+							[
+								1,
+								"c10",
+								"*",
+								"py"
+							]
+						],
+						"+",
+						"c20"
+					], "den"]
+				]
+			],
+			[
+				13,
+				"sv",
+				[
+					6,
+					"cornerPinSafeDiv",
+					[[
+						1,
+						[
+							1,
+							[
+								1,
+								"c01",
+								"*",
+								"px"
+							],
+							"+",
+							[
+								1,
+								"c11",
+								"*",
+								"py"
+							]
+						],
+						"+",
+						"c21"
+					], "den"]
+				]
+			],
+			[
+				13,
+				"det",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							"a11",
+							"*",
+							"c00"
+						],
+						"+",
+						[
+							1,
+							"a21",
+							"*",
+							"c01"
+						]
+					],
+					"+",
+					[
+						1,
+						"a31",
+						"*",
+						"c02"
+					]
+				]
+			],
+			[
+				13,
+				"front",
+				[
+					6,
+					[
+						7,
+						"std",
+						"step"
+					],
+					[[
+						6,
+						[
+							7,
+							"d",
+							"f32"
+						],
+						[[5, "0"]]
+					], [
+						1,
+						"den",
+						"*",
+						"det"
+					]]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"d",
+					"vec3f"
+				],
+				[
+					"su",
+					"sv",
+					"front"
+				]
+			]]
+		]],
+		"externalNames": [
+			"d",
+			"std",
+			"cornerConvexify",
+			"cornerPinSafeDiv"
+		]
+	},
+	externals: () => ({
+		d,
+		std,
+		cornerConvexify,
+		cornerPinSafeDiv
+	})
+}) && $.f)({}));
+const componentDefinition = {
+	name: "CornerPin",
+	category: "Distortions",
+	description: "Pin each corner of the content to an arbitrary position for a free perspective warp",
+	requiresRTT: true,
+	requiresChild: true,
+	boundingBoxDeclaration: { aspectRatio: null },
+	props: {
+		topLeft: {
+			default: {
+				x: 0,
+				y: 0
+			},
+			transform: transformPosition,
+			description: "Position of the top-left corner",
+			ui: {
+				type: "position",
+				label: "Top Left",
+				group: "Corners"
+			}
+		},
+		topRight: {
+			default: {
+				x: 1,
+				y: 0
+			},
+			transform: transformPosition,
+			description: "Position of the top-right corner",
+			ui: {
+				type: "position",
+				label: "Top Right",
+				group: "Corners"
+			}
+		},
+		bottomLeft: {
+			default: {
+				x: 0,
+				y: 1
+			},
+			transform: transformPosition,
+			description: "Position of the bottom-left corner",
+			ui: {
+				type: "position",
+				label: "Bottom Left",
+				group: "Corners"
+			}
+		},
+		bottomRight: {
+			default: {
+				x: 1,
+				y: 1
+			},
+			transform: transformPosition,
+			description: "Position of the bottom-right corner",
+			ui: {
+				type: "position",
+				label: "Bottom Right",
+				group: "Corners"
+			}
+		},
+		amount: {
+			default: 1,
+			description: "Blends the warp in and out — 0 returns the content to its original rectangle, 1 fully pins the corners",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Amount",
+				group: "Effect"
+			}
+		},
+		edges: {
+			default: "transparent",
+			description: "How to handle areas outside the pinned quad",
+			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: ({ childNode, ctx, uniforms, propValues, convertToTexture }) => {
+		if (!childNode) return ZERO;
+		const texture = convertToTexture(childNode);
+		const edgeMode = propValues.edges ?? 0;
+		const packed = call(cornerPinSample, "cornerPinSample", [
+			ctx.uv,
+			uniforms.amount,
+			uniforms.topLeft,
+			uniforms.topRight,
+			uniforms.bottomRight,
+			uniforms.bottomLeft
+		]);
+		const front = packed.member("z");
+		const edged = applyEdgeHandlingExpr(packed.member("xy"), (uv) => texture.sample(uv), edgeMode);
+		return call(unpremultiplyAlpha, "unpremultiplyAlpha", [vec4(edged.member("rgb"), edged.member("a").mul(front))]);
+	},
+	uvRemap: ({ uv, mask, uniforms, propValues }) => {
+		const edgeMode = propValues.edges ?? 0;
+		const packed = call(cornerPinSample, "cornerPinSample", [
+			uv,
+			uniforms.amount,
+			uniforms.topLeft,
+			uniforms.topRight,
+			uniforms.bottomRight,
+			uniforms.bottomLeft
+		]);
+		const front = packed.member("z");
+		const composed = composeEdgeRemapExpr(packed.member("xy"), mask, edgeMode);
+		return {
+			uv: composed.uv,
+			mask: composed.mask.mul(front)
+		};
+	}
+};
+var CornerPin_default = componentDefinition;
+export { cornerPinSafeDiv as a, cornerSideOf as c, cornerInsideTri as i, componentDefinition as n, cornerPinSample as o, cornerConvexify as r, cornerProjectToDiagonal as s, CornerPin_default as t };