shaders 3.1.461 → 3.1.463

package/dist/core/CursorTrail-CR8Yzb95.js

@@ -0,0 +1,1687 @@
+import { I as colorMixing_exports, Lt as vec4f, Mt as vec2f, Ot as smoothstep, Pt as vec2u, Wt as texture2d, _t as max, b as vec4, ct as clamp, d as ZERO, et as typegpu_default, ft as exp, gt as length, it as abs, ln as u32, m as call, rt as select, sn as f32, vt as min, yt as mix } from "./edges-CV-BHMpI.js";
+import { A as toHalfFloat, I as textureLoad } from "./device-DKcu50_C.js";
+import { V as colorStopsPropConfig, q as mixColorStopsRuntime } from "./porters-j7yWJYy2.js";
+import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-u-UZrXjj.js";
+import { n as createPointerVelocityTracker } from "./pointer-CdyEZBpL.js";
+var MAX_POINTS = 64;
+var HALF_ONE = toHalfFloat(1);
+var WIDTH_MIN = .2;
+var SPEED_FULL = 1.5;
+var BEZIER_SUBDIVISIONS = 3;
+const cursorTrailScan = typegpu_default.fn([
+	texture2d(f32),
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((pointsTex, uv, aspect, radius, shrink, softness, viewportH) => {
+	"use gpu";
+	const px = __tsover_mul(uv.x, aspect);
+	const py = uv.y;
+	const baseRadius = __tsover_mul(radius, .1);
+	const edgeW = __tsover_add(__tsover_div(1.5, max(viewportH, 1)), __tsover_mul(softness, baseRadius));
+	const sharp = __tsover_div(4, max(baseRadius, .005));
+	let minSdf = f32(100);
+	let ageSum = f32(0);
+	let wSum = f32(0);
+	let prev = vec4f(0, 0, 1, 0);
+	let prev2 = vec4f(0, 0, 1, 0);
+	for (let i = 0; i < MAX_POINTS; i++) {
+		const cur = textureLoad(pointsTex, vec2u(u32(i), 0), 0);
+		if (cur.z < 1) {
+			const cx = __tsover_mul(cur.x, aspect);
+			const cy = cur.y;
+			const linked = select(f32(0), f32(1), cur.w > 0);
+			const prevAlive = select(f32(0), f32(1), prev.z < 1);
+			if (__tsover_mul(linked, prevAlive) > .5) {
+				const usePrev2 = __tsover_mul(select(f32(0), f32(1), prev.w > 0), select(f32(0), f32(1), prev2.z < 1)) > .5;
+				const jx = __tsover_mul(prev.x, aspect);
+				const jy = prev.y;
+				const sx0 = select(jx, __tsover_mul(__tsover_add(__tsover_mul(prev2.x, aspect), jx), .5), usePrev2);
+				const sy0 = select(jy, __tsover_mul(__tsover_add(prev2.y, jy), .5), usePrev2);
+				const ageS = select(prev.z, __tsover_mul(__tsover_add(prev2.z, prev.z), .5), usePrev2);
+				const widPrev = abs(prev.w);
+				const widS = select(widPrev, __tsover_mul(__tsover_add(abs(prev2.w), widPrev), .5), usePrev2);
+				const ex = __tsover_mul(__tsover_add(jx, cx), .5);
+				const ey = __tsover_mul(__tsover_add(jy, cy), .5);
+				const ageE = __tsover_mul(__tsover_add(prev.z, cur.z), .5);
+				const widE = __tsover_mul(__tsover_add(widPrev, abs(cur.w)), .5);
+				let sx = sx0;
+				let sy = sy0;
+				let sAge = ageS;
+				let sWid = widS;
+				let jMin = f32(100);
+				let jAge = f32(1);
+				for (let k = 0; k < BEZIER_SUBDIVISIONS; k++) {
+					const t = __tsover_div(__tsover_add(f32(k), 1), BEZIER_SUBDIVISIONS);
+					const omt = __tsover_sub(1, t);
+					const bx = __tsover_add(__tsover_add(__tsover_mul(__tsover_mul(omt, omt), sx0), __tsover_mul(__tsover_mul(__tsover_mul(2, omt), t), jx)), __tsover_mul(__tsover_mul(t, t), ex));
+					const by = __tsover_add(__tsover_add(__tsover_mul(__tsover_mul(omt, omt), sy0), __tsover_mul(__tsover_mul(__tsover_mul(2, omt), t), jy)), __tsover_mul(__tsover_mul(t, t), ey));
+					const bAge = mix(ageS, ageE, t);
+					const bWid = mix(widS, widE, t);
+					const ra = __tsover_mul(__tsover_mul(baseRadius, sWid), __tsover_sub(1, __tsover_mul(sAge, shrink)));
+					const rb = __tsover_mul(__tsover_mul(baseRadius, bWid), __tsover_sub(1, __tsover_mul(bAge, shrink)));
+					const bax = __tsover_sub(bx, sx);
+					const bay = __tsover_sub(by, sy);
+					const tt = clamp(__tsover_div(__tsover_add(__tsover_mul(__tsover_sub(px, sx), bax), __tsover_mul(__tsover_sub(py, sy), bay)), max(__tsover_add(__tsover_mul(bax, bax), __tsover_mul(bay, bay)), 1e-8)), 0, 1);
+					const dist = __tsover_sub(length(vec2f(__tsover_sub(px, __tsover_add(sx, __tsover_mul(bax, tt))), __tsover_sub(py, __tsover_add(sy, __tsover_mul(bay, tt))))), mix(ra, rb, tt));
+					if (dist < jMin) {
+						jMin = dist;
+						jAge = mix(sAge, bAge, tt);
+					}
+					sx = bx;
+					sy = by;
+					sAge = bAge;
+					sWid = bWid;
+				}
+				minSdf = min(minSdf, jMin);
+				const w = exp(__tsover_mul(__tsover_mul(jMin, -1), sharp));
+				ageSum = __tsover_add(ageSum, __tsover_mul(jAge, w));
+				wSum = __tsover_add(wSum, w);
+			} else {
+				const dist = __tsover_sub(length(vec2f(__tsover_sub(px, cx), __tsover_sub(py, cy))), __tsover_mul(__tsover_mul(baseRadius, abs(cur.w)), __tsover_sub(1, __tsover_mul(cur.z, shrink))));
+				minSdf = min(minSdf, dist);
+				const w = exp(__tsover_mul(__tsover_mul(dist, -1), sharp));
+				ageSum = __tsover_add(ageSum, __tsover_mul(cur.z, w));
+				wSum = __tsover_add(wSum, w);
+			}
+		}
+		prev2 = vec4f(prev);
+		prev = vec4f(cur);
+	}
+	const age = __tsover_div(ageSum, max(wSum, 1e-20));
+	return vec2f(age, __tsover_mul(__tsover_sub(1, smoothstep(__tsover_mul(edgeW, -1), edgeW, minSdf)), __tsover_sub(1, smoothstep(.8, 1, age))));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "pointsTex"
+			},
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "aspect"
+			},
+			{
+				"type": "i",
+				"name": "radius"
+			},
+			{
+				"type": "i",
+				"name": "shrink"
+			},
+			{
+				"type": "i",
+				"name": "softness"
+			},
+			{
+				"type": "i",
+				"name": "viewportH"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"px",
+				[
+					1,
+					[
+						7,
+						"uv",
+						"x"
+					],
+					"*",
+					"aspect"
+				]
+			],
+			[
+				13,
+				"py",
+				[
+					7,
+					"uv",
+					"y"
+				]
+			],
+			[
+				13,
+				"baseRadius",
+				[
+					1,
+					"radius",
+					"*",
+					[5, "0.1"]
+				]
+			],
+			[
+				13,
+				"edgeW",
+				[
+					1,
+					[
+						1,
+						[5, "1.5"],
+						"/",
+						[
+							6,
+							"std.max",
+							["viewportH", [5, "1"]]
+						]
+					],
+					"+",
+					[
+						1,
+						"softness",
+						"*",
+						"baseRadius"
+					]
+				]
+			],
+			[
+				13,
+				"sharp",
+				[
+					1,
+					[5, "4"],
+					"/",
+					[
+						6,
+						"std.max",
+						["baseRadius", [5, "0.005"]]
+					]
+				]
+			],
+			[
+				12,
+				"minSdf",
+				[
+					6,
+					"d.f32",
+					[[5, "100"]]
+				]
+			],
+			[
+				12,
+				"ageSum",
+				[
+					6,
+					"d.f32",
+					[[5, "0"]]
+				]
+			],
+			[
+				12,
+				"wSum",
+				[
+					6,
+					"d.f32",
+					[[5, "0"]]
+				]
+			],
+			[
+				12,
+				"prev",
+				[
+					6,
+					"d.vec4f",
+					[
+						[5, "0"],
+						[5, "0"],
+						[5, "1"],
+						[5, "0"]
+					]
+				]
+			],
+			[
+				12,
+				"prev2",
+				[
+					6,
+					"d.vec4f",
+					[
+						[5, "0"],
+						[5, "0"],
+						[5, "1"],
+						[5, "0"]
+					]
+				]
+			],
+			[
+				14,
+				[
+					12,
+					"i",
+					[5, "0"]
+				],
+				[
+					1,
+					"i",
+					"<",
+					"MAX_POINTS"
+				],
+				[
+					102,
+					"++",
+					"i"
+				],
+				[0, [
+					[
+						13,
+						"cur",
+						[
+							6,
+							"std.textureLoad",
+							[
+								"pointsTex",
+								[
+									6,
+									"d.vec2u",
+									[[
+										6,
+										"d.u32",
+										["i"]
+									], [5, "0"]]
+								],
+								[5, "0"]
+							]
+						]
+					],
+					[
+						11,
+						[
+							1,
+							[
+								7,
+								"cur",
+								"z"
+							],
+							"<",
+							[5, "1"]
+						],
+						[0, [
+							[
+								13,
+								"cx",
+								[
+									1,
+									[
+										7,
+										"cur",
+										"x"
+									],
+									"*",
+									"aspect"
+								]
+							],
+							[
+								13,
+								"cy",
+								[
+									7,
+									"cur",
+									"y"
+								]
+							],
+							[
+								13,
+								"linked",
+								[
+									6,
+									"std.select",
+									[
+										[
+											6,
+											"d.f32",
+											[[5, "0"]]
+										],
+										[
+											6,
+											"d.f32",
+											[[5, "1"]]
+										],
+										[
+											1,
+											[
+												7,
+												"cur",
+												"w"
+											],
+											">",
+											[5, "0"]
+										]
+									]
+								]
+							],
+							[
+								13,
+								"prevAlive",
+								[
+									6,
+									"std.select",
+									[
+										[
+											6,
+											"d.f32",
+											[[5, "0"]]
+										],
+										[
+											6,
+											"d.f32",
+											[[5, "1"]]
+										],
+										[
+											1,
+											[
+												7,
+												"prev",
+												"z"
+											],
+											"<",
+											[5, "1"]
+										]
+									]
+								]
+							],
+							[
+								11,
+								[
+									1,
+									[
+										1,
+										"linked",
+										"*",
+										"prevAlive"
+									],
+									">",
+									[5, "0.5"]
+								],
+								[0, [
+									[
+										13,
+										"usePrev2",
+										[
+											1,
+											[
+												1,
+												[
+													6,
+													"std.select",
+													[
+														[
+															6,
+															"d.f32",
+															[[5, "0"]]
+														],
+														[
+															6,
+															"d.f32",
+															[[5, "1"]]
+														],
+														[
+															1,
+															[
+																7,
+																"prev",
+																"w"
+															],
+															">",
+															[5, "0"]
+														]
+													]
+												],
+												"*",
+												[
+													6,
+													"std.select",
+													[
+														[
+															6,
+															"d.f32",
+															[[5, "0"]]
+														],
+														[
+															6,
+															"d.f32",
+															[[5, "1"]]
+														],
+														[
+															1,
+															[
+																7,
+																"prev2",
+																"z"
+															],
+															"<",
+															[5, "1"]
+														]
+													]
+												]
+											],
+											">",
+											[5, "0.5"]
+										]
+									],
+									[
+										13,
+										"jx",
+										[
+											1,
+											[
+												7,
+												"prev",
+												"x"
+											],
+											"*",
+											"aspect"
+										]
+									],
+									[
+										13,
+										"jy",
+										[
+											7,
+											"prev",
+											"y"
+										]
+									],
+									[
+										13,
+										"sx0",
+										[
+											6,
+											"std.select",
+											[
+												"jx",
+												[
+													1,
+													[
+														1,
+														[
+															1,
+															[
+																7,
+																"prev2",
+																"x"
+															],
+															"*",
+															"aspect"
+														],
+														"+",
+														"jx"
+													],
+													"*",
+													[5, "0.5"]
+												],
+												"usePrev2"
+											]
+										]
+									],
+									[
+										13,
+										"sy0",
+										[
+											6,
+											"std.select",
+											[
+												"jy",
+												[
+													1,
+													[
+														1,
+														[
+															7,
+															"prev2",
+															"y"
+														],
+														"+",
+														"jy"
+													],
+													"*",
+													[5, "0.5"]
+												],
+												"usePrev2"
+											]
+										]
+									],
+									[
+										13,
+										"ageS",
+										[
+											6,
+											"std.select",
+											[
+												[
+													7,
+													"prev",
+													"z"
+												],
+												[
+													1,
+													[
+														1,
+														[
+															7,
+															"prev2",
+															"z"
+														],
+														"+",
+														[
+															7,
+															"prev",
+															"z"
+														]
+													],
+													"*",
+													[5, "0.5"]
+												],
+												"usePrev2"
+											]
+										]
+									],
+									[
+										13,
+										"widPrev",
+										[
+											6,
+											"std.abs",
+											[[
+												7,
+												"prev",
+												"w"
+											]]
+										]
+									],
+									[
+										13,
+										"widS",
+										[
+											6,
+											"std.select",
+											[
+												"widPrev",
+												[
+													1,
+													[
+														1,
+														[
+															6,
+															"std.abs",
+															[[
+																7,
+																"prev2",
+																"w"
+															]]
+														],
+														"+",
+														"widPrev"
+													],
+													"*",
+													[5, "0.5"]
+												],
+												"usePrev2"
+											]
+										]
+									],
+									[
+										13,
+										"ex",
+										[
+											1,
+											[
+												1,
+												"jx",
+												"+",
+												"cx"
+											],
+											"*",
+											[5, "0.5"]
+										]
+									],
+									[
+										13,
+										"ey",
+										[
+											1,
+											[
+												1,
+												"jy",
+												"+",
+												"cy"
+											],
+											"*",
+											[5, "0.5"]
+										]
+									],
+									[
+										13,
+										"ageE",
+										[
+											1,
+											[
+												1,
+												[
+													7,
+													"prev",
+													"z"
+												],
+												"+",
+												[
+													7,
+													"cur",
+													"z"
+												]
+											],
+											"*",
+											[5, "0.5"]
+										]
+									],
+									[
+										13,
+										"widE",
+										[
+											1,
+											[
+												1,
+												"widPrev",
+												"+",
+												[
+													6,
+													"std.abs",
+													[[
+														7,
+														"cur",
+														"w"
+													]]
+												]
+											],
+											"*",
+											[5, "0.5"]
+										]
+									],
+									[
+										12,
+										"sx",
+										"sx0"
+									],
+									[
+										12,
+										"sy",
+										"sy0"
+									],
+									[
+										12,
+										"sAge",
+										"ageS"
+									],
+									[
+										12,
+										"sWid",
+										"widS"
+									],
+									[
+										12,
+										"jMin",
+										[
+											6,
+											"d.f32",
+											[[5, "100"]]
+										]
+									],
+									[
+										12,
+										"jAge",
+										[
+											6,
+											"d.f32",
+											[[5, "1"]]
+										]
+									],
+									[
+										14,
+										[
+											12,
+											"k",
+											[5, "0"]
+										],
+										[
+											1,
+											"k",
+											"<",
+											"BEZIER_SUBDIVISIONS"
+										],
+										[
+											102,
+											"++",
+											"k"
+										],
+										[0, [
+											[
+												13,
+												"t",
+												[
+													1,
+													[
+														1,
+														[
+															6,
+															"d.f32",
+															["k"]
+														],
+														"+",
+														[5, "1"]
+													],
+													"/",
+													"BEZIER_SUBDIVISIONS"
+												]
+											],
+											[
+												13,
+												"omt",
+												[
+													1,
+													[5, "1"],
+													"-",
+													"t"
+												]
+											],
+											[
+												13,
+												"bx",
+												[
+													1,
+													[
+														1,
+														[
+															1,
+															[
+																1,
+																"omt",
+																"*",
+																"omt"
+															],
+															"*",
+															"sx0"
+														],
+														"+",
+														[
+															1,
+															[
+																1,
+																[
+																	1,
+																	[5, "2"],
+																	"*",
+																	"omt"
+																],
+																"*",
+																"t"
+															],
+															"*",
+															"jx"
+														]
+													],
+													"+",
+													[
+														1,
+														[
+															1,
+															"t",
+															"*",
+															"t"
+														],
+														"*",
+														"ex"
+													]
+												]
+											],
+											[
+												13,
+												"by",
+												[
+													1,
+													[
+														1,
+														[
+															1,
+															[
+																1,
+																"omt",
+																"*",
+																"omt"
+															],
+															"*",
+															"sy0"
+														],
+														"+",
+														[
+															1,
+															[
+																1,
+																[
+																	1,
+																	[5, "2"],
+																	"*",
+																	"omt"
+																],
+																"*",
+																"t"
+															],
+															"*",
+															"jy"
+														]
+													],
+													"+",
+													[
+														1,
+														[
+															1,
+															"t",
+															"*",
+															"t"
+														],
+														"*",
+														"ey"
+													]
+												]
+											],
+											[
+												13,
+												"bAge",
+												[
+													6,
+													"std.mix",
+													[
+														"ageS",
+														"ageE",
+														"t"
+													]
+												]
+											],
+											[
+												13,
+												"bWid",
+												[
+													6,
+													"std.mix",
+													[
+														"widS",
+														"widE",
+														"t"
+													]
+												]
+											],
+											[
+												13,
+												"ra",
+												[
+													1,
+													[
+														1,
+														"baseRadius",
+														"*",
+														"sWid"
+													],
+													"*",
+													[
+														1,
+														[5, "1"],
+														"-",
+														[
+															1,
+															"sAge",
+															"*",
+															"shrink"
+														]
+													]
+												]
+											],
+											[
+												13,
+												"rb",
+												[
+													1,
+													[
+														1,
+														"baseRadius",
+														"*",
+														"bWid"
+													],
+													"*",
+													[
+														1,
+														[5, "1"],
+														"-",
+														[
+															1,
+															"bAge",
+															"*",
+															"shrink"
+														]
+													]
+												]
+											],
+											[
+												13,
+												"bax",
+												[
+													1,
+													"bx",
+													"-",
+													"sx"
+												]
+											],
+											[
+												13,
+												"bay",
+												[
+													1,
+													"by",
+													"-",
+													"sy"
+												]
+											],
+											[
+												13,
+												"tt",
+												[
+													6,
+													"std.clamp",
+													[
+														[
+															1,
+															[
+																1,
+																[
+																	1,
+																	[
+																		1,
+																		"px",
+																		"-",
+																		"sx"
+																	],
+																	"*",
+																	"bax"
+																],
+																"+",
+																[
+																	1,
+																	[
+																		1,
+																		"py",
+																		"-",
+																		"sy"
+																	],
+																	"*",
+																	"bay"
+																]
+															],
+															"/",
+															[
+																6,
+																"std.max",
+																[[
+																	1,
+																	[
+																		1,
+																		"bax",
+																		"*",
+																		"bax"
+																	],
+																	"+",
+																	[
+																		1,
+																		"bay",
+																		"*",
+																		"bay"
+																	]
+																], [5, "1e-8"]]
+															]
+														],
+														[5, "0"],
+														[5, "1"]
+													]
+												]
+											],
+											[
+												13,
+												"dist",
+												[
+													1,
+													[
+														6,
+														"std.length",
+														[[
+															6,
+															"d.vec2f",
+															[[
+																1,
+																"px",
+																"-",
+																[
+																	1,
+																	"sx",
+																	"+",
+																	[
+																		1,
+																		"bax",
+																		"*",
+																		"tt"
+																	]
+																]
+															], [
+																1,
+																"py",
+																"-",
+																[
+																	1,
+																	"sy",
+																	"+",
+																	[
+																		1,
+																		"bay",
+																		"*",
+																		"tt"
+																	]
+																]
+															]]
+														]]
+													],
+													"-",
+													[
+														6,
+														"std.mix",
+														[
+															"ra",
+															"rb",
+															"tt"
+														]
+													]
+												]
+											],
+											[
+												11,
+												[
+													1,
+													"dist",
+													"<",
+													"jMin"
+												],
+												[0, [[
+													2,
+													"jMin",
+													"=",
+													"dist"
+												], [
+													2,
+													"jAge",
+													"=",
+													[
+														6,
+														"std.mix",
+														[
+															"sAge",
+															"bAge",
+															"tt"
+														]
+													]
+												]]]
+											],
+											[
+												2,
+												"sx",
+												"=",
+												"bx"
+											],
+											[
+												2,
+												"sy",
+												"=",
+												"by"
+											],
+											[
+												2,
+												"sAge",
+												"=",
+												"bAge"
+											],
+											[
+												2,
+												"sWid",
+												"=",
+												"bWid"
+											]
+										]]
+									],
+									[
+										2,
+										"minSdf",
+										"=",
+										[
+											6,
+											"std.min",
+											["minSdf", "jMin"]
+										]
+									],
+									[
+										13,
+										"w",
+										[
+											6,
+											"std.exp",
+											[[
+												1,
+												[
+													1,
+													"jMin",
+													"*",
+													[
+														4,
+														"-",
+														[5, "1"]
+													]
+												],
+												"*",
+												"sharp"
+											]]
+										]
+									],
+									[
+										2,
+										"ageSum",
+										"=",
+										[
+											1,
+											"ageSum",
+											"+",
+											[
+												1,
+												"jAge",
+												"*",
+												"w"
+											]
+										]
+									],
+									[
+										2,
+										"wSum",
+										"=",
+										[
+											1,
+											"wSum",
+											"+",
+											"w"
+										]
+									]
+								]],
+								[0, [
+									[
+										13,
+										"dist",
+										[
+											1,
+											[
+												6,
+												"std.length",
+												[[
+													6,
+													"d.vec2f",
+													[[
+														1,
+														"px",
+														"-",
+														"cx"
+													], [
+														1,
+														"py",
+														"-",
+														"cy"
+													]]
+												]]
+											],
+											"-",
+											[
+												1,
+												[
+													1,
+													"baseRadius",
+													"*",
+													[
+														6,
+														"std.abs",
+														[[
+															7,
+															"cur",
+															"w"
+														]]
+													]
+												],
+												"*",
+												[
+													1,
+													[5, "1"],
+													"-",
+													[
+														1,
+														[
+															7,
+															"cur",
+															"z"
+														],
+														"*",
+														"shrink"
+													]
+												]
+											]
+										]
+									],
+									[
+										2,
+										"minSdf",
+										"=",
+										[
+											6,
+											"std.min",
+											["minSdf", "dist"]
+										]
+									],
+									[
+										13,
+										"w",
+										[
+											6,
+											"std.exp",
+											[[
+												1,
+												[
+													1,
+													"dist",
+													"*",
+													[
+														4,
+														"-",
+														[5, "1"]
+													]
+												],
+												"*",
+												"sharp"
+											]]
+										]
+									],
+									[
+										2,
+										"ageSum",
+										"=",
+										[
+											1,
+											"ageSum",
+											"+",
+											[
+												1,
+												[
+													7,
+													"cur",
+													"z"
+												],
+												"*",
+												"w"
+											]
+										]
+									],
+									[
+										2,
+										"wSum",
+										"=",
+										[
+											1,
+											"wSum",
+											"+",
+											"w"
+										]
+									]
+								]]
+							]
+						]]
+					],
+					[
+						2,
+						"prev2",
+						"=",
+						[
+							6,
+							"d.vec4f",
+							["prev"]
+						]
+					],
+					[
+						2,
+						"prev",
+						"=",
+						[
+							6,
+							"d.vec4f",
+							["cur"]
+						]
+					]
+				]]
+			],
+			[
+				13,
+				"age",
+				[
+					1,
+					"ageSum",
+					"/",
+					[
+						6,
+						"std.max",
+						["wSum", [5, "1e-20"]]
+					]
+				]
+			],
+			[
+				13,
+				"coverage",
+				[
+					1,
+					[
+						1,
+						[5, "1"],
+						"-",
+						[
+							6,
+							"std.smoothstep",
+							[
+								[
+									1,
+									"edgeW",
+									"*",
+									[
+										4,
+										"-",
+										[5, "1"]
+									]
+								],
+								"edgeW",
+								"minSdf"
+							]
+						]
+					],
+					"*",
+					[
+						1,
+						[5, "1"],
+						"-",
+						[
+							6,
+							"std.smoothstep",
+							[
+								[5, "0.8"],
+								[5, "1"],
+								"age"
+							]
+						]
+					]
+				]
+			],
+			[10, [
+				6,
+				"d.vec2f",
+				["age", "coverage"]
+			]]
+		]]
+	},
+	externals: {
+		"std.max": () => max,
+		"d.f32": () => f32,
+		"d.vec4f": () => vec4f,
+		"MAX_POINTS": () => MAX_POINTS,
+		"std.textureLoad": () => textureLoad,
+		"d.vec2u": () => vec2u,
+		"d.u32": () => u32,
+		"std.select": () => select,
+		"std.abs": () => abs,
+		"BEZIER_SUBDIVISIONS": () => BEZIER_SUBDIVISIONS,
+		"std.mix": () => mix,
+		"std.clamp": () => clamp,
+		"std.length": () => length,
+		"d.vec2f": () => vec2f,
+		"std.min": () => min,
+		"std.exp": () => exp,
+		"std.smoothstep": () => smoothstep
+	}
+}) && $.f)({})).$name("cursorTrailScan");
+const componentDefinition = {
+	name: "CursorTrail",
+	boundingBoxDeclaration: { aspectRatio: null },
+	category: "Interactive",
+	description: "Animated trail effect that tracks cursor movement",
+	usesPointer: true,
+	props: {
+		colorA: {
+			default: "#00aaff",
+			transform: transformColor,
+			description: "Color of fresh trails",
+			ui: {
+				type: "color",
+				label: "Start Color",
+				group: "Colors"
+			}
+		},
+		colorB: {
+			default: "#ff00aa",
+			transform: transformColor,
+			description: "Color trails transition to as they fade",
+			ui: {
+				type: "color",
+				label: "End Color",
+				group: "Colors"
+			}
+		},
+		stops: colorStopsPropConfig(),
+		radius: {
+			default: .5,
+			description: "Base radius of the trail stroke",
+			ui: {
+				type: "range",
+				min: .5,
+				max: 2,
+				step: .1,
+				label: "Radius",
+				group: "Effect"
+			}
+		},
+		length: {
+			default: .5,
+			description: "How long the trail persists (in seconds)",
+			ui: {
+				type: "range",
+				min: .1,
+				max: 2,
+				step: .1,
+				label: "Trail Length",
+				group: "Animation"
+			}
+		},
+		shrink: {
+			default: 1,
+			description: "How much the stroke tapers as it fades out (0 = no taper, 1 = full taper)",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .1,
+				label: "Shrink Amount",
+				group: "Effect"
+			}
+		},
+		softness: {
+			default: 0,
+			description: "Edge softness of the trail (0 = crisp paint edge, 1 = very soft)",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Softness",
+				group: "Effect"
+			}
+		},
+		colorSpace: {
+			default: "linear",
+			transform: transformColorSpace,
+			compileTime: true,
+			description: "Color space for color interpolation",
+			ui: {
+				type: "select",
+				options: colorSpaceOptions,
+				label: "Color Space",
+				group: "Colors"
+			}
+		}
+	},
+	fragment: (params) => {
+		const { ctx, propValues, uniforms, gpu } = params;
+		if (!gpu?.root) return ZERO;
+		const { createDataTexture, registerMediaTexture, onBeforeRender, onCleanup, onResize, getCpuValue, dimensions } = params;
+		const pts = [];
+		const texData = new Uint16Array(MAX_POINTS * 4);
+		for (let i = 0; i < MAX_POINTS; i++) texData[i * 4 + 2] = HALF_ONE;
+		const dataTex = createDataTexture({
+			width: MAX_POINTS,
+			height: 1,
+			format: "rgba16float",
+			data: texData,
+			label: "cursortrail-points"
+		});
+		onCleanup(() => dataTex.destroy());
+		const pointsKit = registerMediaTexture(() => dataTex.texture);
+		const tracker = createPointerVelocityTracker({
+			minDrag: .001,
+			teleportGuard: Number.POSITIVE_INFINITY
+		});
+		let curW = Math.max(1, Math.round(dimensions.width));
+		let curH = Math.max(1, Math.round(dimensions.height));
+		onResize(({ width, height }) => {
+			curW = Math.max(1, Math.round(width));
+			curH = Math.max(1, Math.round(height));
+		});
+		let headDist = 0;
+		let wasActive = false;
+		onBeforeRender((fp) => {
+			const { pointer, deltaTime } = fp;
+			const rawDt = Math.max(0, deltaTime ?? 0);
+			const dt = Math.min(rawDt, .1);
+			const length$1 = getCpuValue("length") ?? .5;
+			const drawRadius = (getCpuValue("radius") ?? .5) * .1;
+			const aspect = curW / curH;
+			const move = tracker.update(pointer, dt);
+			const ageRate = Math.min(rawDt, .25) / Math.max(.1, length$1);
+			for (const p of pts) p.age = Math.min(1, p.age + ageRate);
+			while (pts.length > 0 && pts[0].age >= 1) pts.shift();
+			if (move.dragDist > .001) {
+				const stepDist = Math.sqrt(move.dx * aspect * (move.dx * aspect) + move.dy * move.dy);
+				const widthNow = Math.min(1, Math.max(WIDTH_MIN, Math.sqrt(move.smoothSpeed / SPEED_FULL)));
+				if (pts.length === 0) {
+					pts.push({
+						x: move.prevX,
+						y: move.prevY,
+						age: 0,
+						link: 0,
+						width: widthNow
+					});
+					pts.push({
+						x: move.x,
+						y: move.y,
+						age: 0,
+						link: 1,
+						width: widthNow
+					});
+					headDist = stepDist;
+				} else {
+					const head = pts[pts.length - 1];
+					head.x = move.x;
+					head.y = move.y;
+					head.age = 0;
+					head.width = widthNow;
+					headDist += stepDist;
+					if (headDist >= Math.max(.006, drawRadius * .5)) {
+						const n = pts.length;
+						if (n >= 3 && pts[n - 2].link === 1) {
+							pts[n - 2].x = .25 * pts[n - 3].x + .5 * pts[n - 2].x + .25 * pts[n - 1].x;
+							pts[n - 2].y = .25 * pts[n - 3].y + .5 * pts[n - 2].y + .25 * pts[n - 1].y;
+						}
+						pts.push({
+							x: move.x,
+							y: move.y,
+							age: 0,
+							link: 1,
+							width: widthNow
+						});
+						headDist = 0;
+					}
+				}
+				while (pts.length > MAX_POINTS - 1) pts.shift();
+			}
+			const active = pts.length > 0;
+			if (active || wasActive) {
+				const count = pts.length > 0 ? pts.length + 1 : 0;
+				for (let i = 0; i < MAX_POINTS; i++) {
+					const base = i * 4;
+					if (i < count) {
+						const p = pts[Math.min(i, pts.length - 1)];
+						texData[base] = toHalfFloat(p.x);
+						texData[base + 1] = toHalfFloat(p.y);
+						texData[base + 2] = toHalfFloat(p.age);
+						texData[base + 3] = toHalfFloat(i === pts.length || p.link === 1 ? p.width : -p.width);
+					} else {
+						texData[base] = 0;
+						texData[base + 1] = 0;
+						texData[base + 2] = HALF_ONE;
+						texData[base + 3] = 0;
+					}
+				}
+				dataTex.write(texData);
+			}
+			wasActive = active;
+		});
+		const scan = call(cursorTrailScan, "cursorTrailScan", [
+			pointsKit.accessor(),
+			ctx.uv,
+			ctx.aspect,
+			uniforms.radius,
+			uniforms.shrink,
+			uniforms.softness,
+			ctx.viewportSize.member("y")
+		]);
+		const trailAge = scan.member("x");
+		const coverage = scan.member("y");
+		const colorSpaceMode = propValues.colorSpace ?? 0;
+		const stopCount = propValues.stopCount ?? 0;
+		let trailColor;
+		if (stopCount > 1) trailColor = mixColorStopsRuntime(trailAge, {
+			colorsArray: uniforms.colorsArray,
+			positionsArray: uniforms.positionsArray,
+			convertedColorsArray: uniforms.convertedColorsArray,
+			stopCount: uniforms.stopCount
+		}, colorSpaceMode);
+		else {
+			const cm = colorMixing_exports;
+			trailColor = call(cm.mixColorsVariants[colorSpaceMode] ?? cm.mixColorsLinear, "mixColors", [
+				uniforms.colorA,
+				uniforms.colorB,
+				trailAge
+			]);
+		}
+		return vec4(trailColor.member("rgb"), trailColor.member("a").mul(coverage));
+	}
+};
+var CursorTrail_default = componentDefinition;
+export { componentDefinition as n, cursorTrailScan as r, CursorTrail_default as t };