shaders 3.1.462 → 3.2.464

package/dist/core/TimeTrail-BBQA-QYh.js

@@ -1,1928 +0,0 @@
-import { Ft as vec3f, Gt as textureStorage2d, Lt as vec4f, M as blendModes, Mt as vec2f, Ot as smoothstep, P as unpremultiplyAlpha, Pt as vec2u, R as hslToRgb, Wt as texture2d, Y as rgbToHsl, _t as max, d as ZERO, dt as dot, et as typegpu_default, ht as fract, it as abs, ln as u32, m as call, qt as struct, rt as select, sn as f32, v as floatE } from "./edges-CV-BHMpI.js";
-import { I as textureLoad, L as textureSampleLevel, M as createGuardedCompute, R as textureStore, t as isMobileGpuViewport } from "./device-DKcu50_C.js";
-import { D as createFeedbackTrailSim } from "./porters-j7yWJYy2.js";
-import { a as transformColor } from "./transformations-u-UZrXjj.js";
-var STATE_RES = isMobileGpuViewport() ? 384 : 640;
-var STATE_FORMAT = "rgba16float";
-var DIFFUSE_HALF_UV = 2.5 * .5 / STATE_RES;
-var DRIFT_SCALE = .5;
-var RAINBOW_RATE = .35;
-var TrailParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
-	persistence: f32,
-	diffusion: f32,
-	driftX: f32,
-	driftY: f32,
-	dt: f32,
-	zoom: f32,
-	hueRate: f32,
-	blendMode: f32,
-	motionThreshold: f32
-}), "TrailParams");
-var trailLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_default.bindGroupLayout({
-	src: { texture: texture2d(f32) },
-	prev: { texture: texture2d(f32) },
-	next: { storageTexture: textureStorage2d(STATE_FORMAT, "write-only") },
-	display: { storageTexture: textureStorage2d(STATE_FORMAT, "write-only") },
-	prevLive: { texture: texture2d(f32) },
-	prevLiveOut: { storageTexture: textureStorage2d(STATE_FORMAT, "write-only") },
-	samp: { sampler: "filtering" },
-	params: { uniform: TrailParams }
-}), "trailLayout");
-const timeTrailSampleHistory = typegpu_default.fn([f32, f32], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uvx, uvy) => {
-	"use gpu";
-	return textureSampleLevel(trailLayout.$.prev, trailLayout.$.samp, vec2f(uvx, uvy), f32(0));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "uvx"
-		}, {
-			"type": "i",
-			"name": "uvy"
-		}],
-		"body": [0, [[10, [
-			6,
-			"std.textureSampleLevel",
-			[
-				[
-					7,
-					[
-						7,
-						"trailLayout",
-						"$"
-					],
-					"prev"
-				],
-				[
-					7,
-					[
-						7,
-						"trailLayout",
-						"$"
-					],
-					"samp"
-				],
-				[
-					6,
-					"d.vec2f",
-					["uvx", "uvy"]
-				],
-				[
-					6,
-					"d.f32",
-					[[5, "0"]]
-				]
-			]
-		]]]]
-	},
-	externals: {
-		"std.textureSampleLevel": () => textureSampleLevel,
-		"trailLayout": () => trailLayout,
-		"d.vec2f": () => vec2f,
-		"d.f32": () => f32
-	}
-}) && $.f)({}));
-const timeTrailSampleLive = typegpu_default.fn([f32, f32], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uvx, uvy) => {
-	"use gpu";
-	return textureSampleLevel(trailLayout.$.src, trailLayout.$.samp, vec2f(uvx, uvy), f32(0));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "uvx"
-		}, {
-			"type": "i",
-			"name": "uvy"
-		}],
-		"body": [0, [[10, [
-			6,
-			"std.textureSampleLevel",
-			[
-				[
-					7,
-					[
-						7,
-						"trailLayout",
-						"$"
-					],
-					"src"
-				],
-				[
-					7,
-					[
-						7,
-						"trailLayout",
-						"$"
-					],
-					"samp"
-				],
-				[
-					6,
-					"d.vec2f",
-					["uvx", "uvy"]
-				],
-				[
-					6,
-					"d.f32",
-					[[5, "0"]]
-				]
-			]
-		]]]]
-	},
-	externals: {
-		"std.textureSampleLevel": () => textureSampleLevel,
-		"trailLayout": () => trailLayout,
-		"d.vec2f": () => vec2f,
-		"d.f32": () => f32
-	}
-}) && $.f)({}));
-const timeTrailMotionMask = typegpu_default.fn([
-	vec4f,
-	vec4f,
-	f32
-], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((live, prev, threshold) => {
-	"use gpu";
-	const dRgb = abs(live.xyz.sub(prev.xyz));
-	const dA = abs(__tsover_sub(live.w, prev.w));
-	const diff = __tsover_add(dot(dRgb, vec3f(.299, .587, .114)), dA);
-	return smoothstep(threshold, __tsover_add(__tsover_mul(threshold, 2), .001), diff);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "live"
-			},
-			{
-				"type": "i",
-				"name": "prev"
-			},
-			{
-				"type": "i",
-				"name": "threshold"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"dRgb",
-				[
-					6,
-					"std.abs",
-					[[
-						6,
-						[
-							7,
-							[
-								7,
-								"live",
-								"xyz"
-							],
-							"sub"
-						],
-						[[
-							7,
-							"prev",
-							"xyz"
-						]]
-					]]
-				]
-			],
-			[
-				13,
-				"dA",
-				[
-					6,
-					"std.abs",
-					[[
-						1,
-						[
-							7,
-							"live",
-							"w"
-						],
-						"-",
-						[
-							7,
-							"prev",
-							"w"
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"diff",
-				[
-					1,
-					[
-						6,
-						"std.dot",
-						["dRgb", [
-							6,
-							"d.vec3f",
-							[
-								[5, "0.299"],
-								[5, "0.587"],
-								[5, "0.114"]
-							]
-						]]
-					],
-					"+",
-					"dA"
-				]
-			],
-			[10, [
-				6,
-				"std.smoothstep",
-				[
-					"threshold",
-					[
-						1,
-						[
-							1,
-							"threshold",
-							"*",
-							[5, "2"]
-						],
-						"+",
-						[5, "0.001"]
-					],
-					"diff"
-				]
-			]]
-		]]
-	},
-	externals: {
-		"std.abs": () => abs,
-		"std.dot": () => dot,
-		"d.vec3f": () => vec3f,
-		"std.smoothstep": () => smoothstep
-	}
-}) && $.f)({}));
-const timeTrailRotateHue = typegpu_default.fn([vec3f, f32], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((rgb, amount) => {
-	"use gpu";
-	const hsl = rgbToHsl(rgb);
-	return hslToRgb(vec3f(fract(__tsover_add(hsl.x, amount)), hsl.y, hsl.z));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "rgb"
-		}, {
-			"type": "i",
-			"name": "amount"
-		}],
-		"body": [0, [
-			[
-				13,
-				"hsl",
-				[
-					6,
-					"colorMixing.rgbToHsl",
-					["rgb"]
-				]
-			],
-			[
-				13,
-				"rotated",
-				[
-					6,
-					"d.vec3f",
-					[
-						[
-							6,
-							"std.fract",
-							[[
-								1,
-								[
-									7,
-									"hsl",
-									"x"
-								],
-								"+",
-								"amount"
-							]]
-						],
-						[
-							7,
-							"hsl",
-							"y"
-						],
-						[
-							7,
-							"hsl",
-							"z"
-						]
-					]
-				]
-			],
-			[10, [
-				6,
-				"colorMixing.hslToRgb",
-				["rotated"]
-			]]
-		]]
-	},
-	externals: {
-		"colorMixing.rgbToHsl": () => rgbToHsl,
-		"d.vec3f": () => vec3f,
-		"std.fract": () => fract,
-		"colorMixing.hslToRgb": () => hslToRgb
-	}
-}) && $.f)({}));
-const timeTrailTexelUv = typegpu_default.fn([u32, u32], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-	"use gpu";
-	const res = f32(STATE_RES);
-	return vec2f(__tsover_div(__tsover_add(f32(cx), .5), res), __tsover_div(__tsover_add(f32(cy), .5), res));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "cx"
-		}, {
-			"type": "i",
-			"name": "cy"
-		}],
-		"body": [0, [[
-			13,
-			"res",
-			[
-				6,
-				"d.f32",
-				["STATE_RES"]
-			]
-		], [10, [
-			6,
-			"d.vec2f",
-			[[
-				1,
-				[
-					1,
-					[
-						6,
-						"d.f32",
-						["cx"]
-					],
-					"+",
-					[5, "0.5"]
-				],
-				"/",
-				"res"
-			], [
-				1,
-				[
-					1,
-					[
-						6,
-						"d.f32",
-						["cy"]
-					],
-					"+",
-					[5, "0.5"]
-				],
-				"/",
-				"res"
-			]]
-		]]]]
-	},
-	externals: {
-		"d.f32": () => f32,
-		"STATE_RES": () => STATE_RES,
-		"d.vec2f": () => vec2f
-	}
-}) && $.f)({}));
-const timeTrailFeedbackUv = typegpu_default.fn([vec2f], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv) => {
-	"use gpu";
-	const P = trailLayout.$.params;
-	const zoom = max(P.zoom, .01);
-	return vec2f(__tsover_sub(__tsover_add(__tsover_div(__tsover_sub(uv.x, .5), zoom), .5), __tsover_mul(__tsover_mul(P.driftX, P.dt), DRIFT_SCALE)), __tsover_sub(__tsover_add(__tsover_div(__tsover_sub(uv.y, .5), zoom), .5), __tsover_mul(__tsover_mul(P.driftY, P.dt), DRIFT_SCALE)));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "uv"
-		}],
-		"body": [0, [
-			[
-				13,
-				"P",
-				[
-					7,
-					[
-						7,
-						"trailLayout",
-						"$"
-					],
-					"params"
-				]
-			],
-			[
-				13,
-				"zoom",
-				[
-					6,
-					"std.max",
-					[[
-						7,
-						"P",
-						"zoom"
-					], [5, "0.01"]]
-				]
-			],
-			[10, [
-				6,
-				"d.vec2f",
-				[[
-					1,
-					[
-						1,
-						[
-							1,
-							[
-								1,
-								[
-									7,
-									"uv",
-									"x"
-								],
-								"-",
-								[5, "0.5"]
-							],
-							"/",
-							"zoom"
-						],
-						"+",
-						[5, "0.5"]
-					],
-					"-",
-					[
-						1,
-						[
-							1,
-							[
-								7,
-								"P",
-								"driftX"
-							],
-							"*",
-							[
-								7,
-								"P",
-								"dt"
-							]
-						],
-						"*",
-						"DRIFT_SCALE"
-					]
-				], [
-					1,
-					[
-						1,
-						[
-							1,
-							[
-								1,
-								[
-									7,
-									"uv",
-									"y"
-								],
-								"-",
-								[5, "0.5"]
-							],
-							"/",
-							"zoom"
-						],
-						"+",
-						[5, "0.5"]
-					],
-					"-",
-					[
-						1,
-						[
-							1,
-							[
-								7,
-								"P",
-								"driftY"
-							],
-							"*",
-							[
-								7,
-								"P",
-								"dt"
-							]
-						],
-						"*",
-						"DRIFT_SCALE"
-					]
-				]]
-			]]
-		]]
-	},
-	externals: {
-		"trailLayout": () => trailLayout,
-		"std.max": () => max,
-		"d.vec2f": () => vec2f,
-		"DRIFT_SCALE": () => DRIFT_SCALE
-	}
-}) && $.f)({}));
-const timeTrailDecayed = typegpu_default.fn([f32, f32], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((bx, by) => {
-	"use gpu";
-	const P = trailLayout.$.params;
-	const h = __tsover_mul(P.diffusion, DIFFUSE_HALF_UV);
-	return timeTrailSampleHistory(__tsover_sub(bx, h), __tsover_sub(by, h)).add(timeTrailSampleHistory(__tsover_add(bx, h), __tsover_sub(by, h))).add(timeTrailSampleHistory(__tsover_sub(bx, h), __tsover_add(by, h))).add(timeTrailSampleHistory(__tsover_add(bx, h), __tsover_add(by, h))).mul(__tsover_mul(P.persistence, .25));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "bx"
-		}, {
-			"type": "i",
-			"name": "by"
-		}],
-		"body": [0, [
-			[
-				13,
-				"P",
-				[
-					7,
-					[
-						7,
-						"trailLayout",
-						"$"
-					],
-					"params"
-				]
-			],
-			[
-				13,
-				"h",
-				[
-					1,
-					[
-						7,
-						"P",
-						"diffusion"
-					],
-					"*",
-					"DIFFUSE_HALF_UV"
-				]
-			],
-			[
-				13,
-				"sum",
-				[
-					6,
-					[
-						7,
-						[
-							6,
-							[
-								7,
-								[
-									6,
-									[
-										7,
-										[
-											6,
-											"timeTrailSampleHistory",
-											[[
-												1,
-												"bx",
-												"-",
-												"h"
-											], [
-												1,
-												"by",
-												"-",
-												"h"
-											]]
-										],
-										"add"
-									],
-									[[
-										6,
-										"timeTrailSampleHistory",
-										[[
-											1,
-											"bx",
-											"+",
-											"h"
-										], [
-											1,
-											"by",
-											"-",
-											"h"
-										]]
-									]]
-								],
-								"add"
-							],
-							[[
-								6,
-								"timeTrailSampleHistory",
-								[[
-									1,
-									"bx",
-									"-",
-									"h"
-								], [
-									1,
-									"by",
-									"+",
-									"h"
-								]]
-							]]
-						],
-						"add"
-					],
-					[[
-						6,
-						"timeTrailSampleHistory",
-						[[
-							1,
-							"bx",
-							"+",
-							"h"
-						], [
-							1,
-							"by",
-							"+",
-							"h"
-						]]
-					]]
-				]
-			],
-			[10, [
-				6,
-				[
-					7,
-					"sum",
-					"mul"
-				],
-				[[
-					1,
-					[
-						7,
-						"P",
-						"persistence"
-					],
-					"*",
-					[5, "0.25"]
-				]]
-			]]
-		]]
-	},
-	externals: {
-		"trailLayout": () => trailLayout,
-		"DIFFUSE_HALF_UV": () => DIFFUSE_HALF_UV,
-		"timeTrailSampleHistory": () => timeTrailSampleHistory
-	}
-}) && $.f)({})).$name("timeTrailDecayed");
-const timeTrailDecayedTinted = typegpu_default.fn([f32, f32], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((bx, by) => {
-	"use gpu";
-	const decayed = timeTrailDecayed(bx, by);
-	const a = max(decayed.w, 1e-4);
-	return vec4f(timeTrailRotateHue(decayed.xyz.div(a), trailLayout.$.params.hueRate).mul(decayed.w), decayed.w);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "bx"
-		}, {
-			"type": "i",
-			"name": "by"
-		}],
-		"body": [0, [
-			[
-				13,
-				"decayed",
-				[
-					6,
-					"timeTrailDecayed",
-					["bx", "by"]
-				]
-			],
-			[
-				13,
-				"a",
-				[
-					6,
-					"std.max",
-					[[
-						7,
-						"decayed",
-						"w"
-					], [5, "0.0001"]]
-				]
-			],
-			[
-				13,
-				"rotated",
-				[
-					6,
-					"timeTrailRotateHue",
-					[[
-						6,
-						[
-							7,
-							[
-								7,
-								"decayed",
-								"xyz"
-							],
-							"div"
-						],
-						["a"]
-					], [
-						7,
-						[
-							7,
-							[
-								7,
-								"trailLayout",
-								"$"
-							],
-							"params"
-						],
-						"hueRate"
-					]]
-				]
-			],
-			[10, [
-				6,
-				"d.vec4f",
-				[[
-					6,
-					[
-						7,
-						"rotated",
-						"mul"
-					],
-					[[
-						7,
-						"decayed",
-						"w"
-					]]
-				], [
-					7,
-					"decayed",
-					"w"
-				]]
-			]]
-		]]
-	},
-	externals: {
-		"timeTrailDecayed": () => timeTrailDecayed,
-		"std.max": () => max,
-		"timeTrailRotateHue": () => timeTrailRotateHue,
-		"trailLayout": () => trailLayout,
-		"d.vec4f": () => vec4f
-	}
-}) && $.f)({})).$name("timeTrailDecayedTinted");
-const timeTrailStamp = typegpu_default.fn([
-	vec4f,
-	f32,
-	vec4f
-], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((live, m, trail) => {
-	"use gpu";
-	const P = trailLayout.$.params;
-	const stamp = vec4f(live.xyz.mul(m), __tsover_mul(live.w, m));
-	const outA = __tsover_add(stamp.w, __tsover_mul(trail.w, __tsover_sub(1, stamp.w)));
-	const rgbNormal = stamp.xyz.add(trail.xyz.mul(__tsover_sub(1, stamp.w)));
-	const rgbScreen = stamp.xyz.add(trail.xyz).sub(stamp.xyz.mul(trail.xyz));
-	const rgbAdd = stamp.xyz.add(trail.xyz);
-	return vec4f(select(select(rgbNormal, rgbScreen, P.blendMode > .5), rgbAdd, P.blendMode > 1.5), outA);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "live"
-			},
-			{
-				"type": "i",
-				"name": "m"
-			},
-			{
-				"type": "i",
-				"name": "trail"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"P",
-				[
-					7,
-					[
-						7,
-						"trailLayout",
-						"$"
-					],
-					"params"
-				]
-			],
-			[
-				13,
-				"stamp",
-				[
-					6,
-					"d.vec4f",
-					[[
-						6,
-						[
-							7,
-							[
-								7,
-								"live",
-								"xyz"
-							],
-							"mul"
-						],
-						["m"]
-					], [
-						1,
-						[
-							7,
-							"live",
-							"w"
-						],
-						"*",
-						"m"
-					]]
-				]
-			],
-			[
-				13,
-				"outA",
-				[
-					1,
-					[
-						7,
-						"stamp",
-						"w"
-					],
-					"+",
-					[
-						1,
-						[
-							7,
-							"trail",
-							"w"
-						],
-						"*",
-						[
-							1,
-							[5, "1"],
-							"-",
-							[
-								7,
-								"stamp",
-								"w"
-							]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"rgbNormal",
-				[
-					6,
-					[
-						7,
-						[
-							7,
-							"stamp",
-							"xyz"
-						],
-						"add"
-					],
-					[[
-						6,
-						[
-							7,
-							[
-								7,
-								"trail",
-								"xyz"
-							],
-							"mul"
-						],
-						[[
-							1,
-							[5, "1"],
-							"-",
-							[
-								7,
-								"stamp",
-								"w"
-							]
-						]]
-					]]
-				]
-			],
-			[
-				13,
-				"rgbScreen",
-				[
-					6,
-					[
-						7,
-						[
-							6,
-							[
-								7,
-								[
-									7,
-									"stamp",
-									"xyz"
-								],
-								"add"
-							],
-							[[
-								7,
-								"trail",
-								"xyz"
-							]]
-						],
-						"sub"
-					],
-					[[
-						6,
-						[
-							7,
-							[
-								7,
-								"stamp",
-								"xyz"
-							],
-							"mul"
-						],
-						[[
-							7,
-							"trail",
-							"xyz"
-						]]
-					]]
-				]
-			],
-			[
-				13,
-				"rgbAdd",
-				[
-					6,
-					[
-						7,
-						[
-							7,
-							"stamp",
-							"xyz"
-						],
-						"add"
-					],
-					[[
-						7,
-						"trail",
-						"xyz"
-					]]
-				]
-			],
-			[
-				13,
-				"rgbSN",
-				[
-					6,
-					"std.select",
-					[
-						"rgbNormal",
-						"rgbScreen",
-						[
-							1,
-							[
-								7,
-								"P",
-								"blendMode"
-							],
-							">",
-							[5, "0.5"]
-						]
-					]
-				]
-			],
-			[10, [
-				6,
-				"d.vec4f",
-				[[
-					6,
-					"std.select",
-					[
-						"rgbSN",
-						"rgbAdd",
-						[
-							1,
-							[
-								7,
-								"P",
-								"blendMode"
-							],
-							">",
-							[5, "1.5"]
-						]
-					]
-				], "outA"]
-			]]
-		]]
-	},
-	externals: {
-		"trailLayout": () => trailLayout,
-		"d.vec4f": () => vec4f,
-		"std.select": () => select
-	}
-}) && $.f)({}));
-const makeTimeTrailKernel = (trailFn) => typegpu_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-	"use gpu";
-	const uv = timeTrailTexelUv(cx, cy);
-	const b = timeTrailFeedbackUv(uv);
-	const trail = trailFn(b.x, b.y);
-	const live = timeTrailSampleLive(uv.x, uv.y);
-	const m = timeTrailMotionMask(live, textureLoad(trailLayout.$.prevLive, vec2u(cx, cy), 0), trailLayout.$.params.motionThreshold);
-	textureStore(trailLayout.$.next, vec2u(cx, cy), timeTrailStamp(live, m, trail));
-	textureStore(trailLayout.$.display, vec2u(cx, cy), trail);
-	textureStore(trailLayout.$.prevLiveOut, vec2u(cx, cy), live);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "cx"
-		}, {
-			"type": "i",
-			"name": "cy"
-		}],
-		"body": [0, [
-			[
-				13,
-				"uv",
-				[
-					6,
-					"timeTrailTexelUv",
-					["cx", "cy"]
-				]
-			],
-			[
-				13,
-				"b",
-				[
-					6,
-					"timeTrailFeedbackUv",
-					["uv"]
-				]
-			],
-			[
-				13,
-				"trail",
-				[
-					6,
-					"trailFn",
-					[[
-						7,
-						"b",
-						"x"
-					], [
-						7,
-						"b",
-						"y"
-					]]
-				]
-			],
-			[
-				13,
-				"live",
-				[
-					6,
-					"timeTrailSampleLive",
-					[[
-						7,
-						"uv",
-						"x"
-					], [
-						7,
-						"uv",
-						"y"
-					]]
-				]
-			],
-			[
-				13,
-				"pl",
-				[
-					6,
-					"std.textureLoad",
-					[
-						[
-							7,
-							[
-								7,
-								"trailLayout",
-								"$"
-							],
-							"prevLive"
-						],
-						[
-							6,
-							"d.vec2u",
-							["cx", "cy"]
-						],
-						[5, "0"]
-					]
-				]
-			],
-			[
-				13,
-				"m",
-				[
-					6,
-					"timeTrailMotionMask",
-					[
-						"live",
-						"pl",
-						[
-							7,
-							[
-								7,
-								[
-									7,
-									"trailLayout",
-									"$"
-								],
-								"params"
-							],
-							"motionThreshold"
-						]
-					]
-				]
-			],
-			[
-				6,
-				"std.textureStore",
-				[
-					[
-						7,
-						[
-							7,
-							"trailLayout",
-							"$"
-						],
-						"next"
-					],
-					[
-						6,
-						"d.vec2u",
-						["cx", "cy"]
-					],
-					[
-						6,
-						"timeTrailStamp",
-						[
-							"live",
-							"m",
-							"trail"
-						]
-					]
-				]
-			],
-			[
-				6,
-				"std.textureStore",
-				[
-					[
-						7,
-						[
-							7,
-							"trailLayout",
-							"$"
-						],
-						"display"
-					],
-					[
-						6,
-						"d.vec2u",
-						["cx", "cy"]
-					],
-					"trail"
-				]
-			],
-			[
-				6,
-				"std.textureStore",
-				[
-					[
-						7,
-						[
-							7,
-							"trailLayout",
-							"$"
-						],
-						"prevLiveOut"
-					],
-					[
-						6,
-						"d.vec2u",
-						["cx", "cy"]
-					],
-					"live"
-				]
-			]
-		]]
-	},
-	externals: {
-		"timeTrailTexelUv": () => timeTrailTexelUv,
-		"timeTrailFeedbackUv": () => timeTrailFeedbackUv,
-		"trailFn": () => trailFn,
-		"timeTrailSampleLive": () => timeTrailSampleLive,
-		"std.textureLoad": () => textureLoad,
-		"trailLayout": () => trailLayout,
-		"d.vec2u": () => vec2u,
-		"timeTrailMotionMask": () => timeTrailMotionMask,
-		"std.textureStore": () => textureStore,
-		"timeTrailStamp": () => timeTrailStamp
-	}
-}) && $.f)({})).$name("timeTrailStep");
-const makeTimeTrailAlphaKernel = (trailFn) => typegpu_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-	"use gpu";
-	const uv = timeTrailTexelUv(cx, cy);
-	const b = timeTrailFeedbackUv(uv);
-	const trail = trailFn(b.x, b.y);
-	const outC = timeTrailStamp(timeTrailSampleLive(uv.x, uv.y), f32(1), trail);
-	textureStore(trailLayout.$.next, vec2u(cx, cy), outC);
-	textureStore(trailLayout.$.display, vec2u(cx, cy), outC);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "cx"
-		}, {
-			"type": "i",
-			"name": "cy"
-		}],
-		"body": [0, [
-			[
-				13,
-				"uv",
-				[
-					6,
-					"timeTrailTexelUv",
-					["cx", "cy"]
-				]
-			],
-			[
-				13,
-				"b",
-				[
-					6,
-					"timeTrailFeedbackUv",
-					["uv"]
-				]
-			],
-			[
-				13,
-				"trail",
-				[
-					6,
-					"trailFn",
-					[[
-						7,
-						"b",
-						"x"
-					], [
-						7,
-						"b",
-						"y"
-					]]
-				]
-			],
-			[
-				13,
-				"live",
-				[
-					6,
-					"timeTrailSampleLive",
-					[[
-						7,
-						"uv",
-						"x"
-					], [
-						7,
-						"uv",
-						"y"
-					]]
-				]
-			],
-			[
-				13,
-				"outC",
-				[
-					6,
-					"timeTrailStamp",
-					[
-						"live",
-						[
-							6,
-							"d.f32",
-							[[5, "1"]]
-						],
-						"trail"
-					]
-				]
-			],
-			[
-				6,
-				"std.textureStore",
-				[
-					[
-						7,
-						[
-							7,
-							"trailLayout",
-							"$"
-						],
-						"next"
-					],
-					[
-						6,
-						"d.vec2u",
-						["cx", "cy"]
-					],
-					"outC"
-				]
-			],
-			[
-				6,
-				"std.textureStore",
-				[
-					[
-						7,
-						[
-							7,
-							"trailLayout",
-							"$"
-						],
-						"display"
-					],
-					[
-						6,
-						"d.vec2u",
-						["cx", "cy"]
-					],
-					"outC"
-				]
-			]
-		]]
-	},
-	externals: {
-		"timeTrailTexelUv": () => timeTrailTexelUv,
-		"timeTrailFeedbackUv": () => timeTrailFeedbackUv,
-		"trailFn": () => trailFn,
-		"timeTrailSampleLive": () => timeTrailSampleLive,
-		"timeTrailStamp": () => timeTrailStamp,
-		"d.f32": () => f32,
-		"std.textureStore": () => textureStore,
-		"trailLayout": () => trailLayout,
-		"d.vec2u": () => vec2u
-	}
-}) && $.f)({})).$name("timeTrailStepAlpha");
-const timeTrailKernel = makeTimeTrailKernel(timeTrailDecayed);
-const timeTrailColorize = typegpu_default.fn([vec4f, vec4f], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((trail, tint) => {
-	"use gpu";
-	const a = max(trail.w, 1e-4);
-	const lum = dot(trail.xyz.div(a), vec3f(.299, .587, .114));
-	return vec4f(tint.xyz.mul(__tsover_mul(lum, 1.5)).mul(trail.w), trail.w);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "trail"
-		}, {
-			"type": "i",
-			"name": "tint"
-		}],
-		"body": [0, [
-			[
-				13,
-				"a",
-				[
-					6,
-					"std.max",
-					[[
-						7,
-						"trail",
-						"w"
-					], [5, "0.0001"]]
-				]
-			],
-			[
-				13,
-				"straight",
-				[
-					6,
-					[
-						7,
-						[
-							7,
-							"trail",
-							"xyz"
-						],
-						"div"
-					],
-					["a"]
-				]
-			],
-			[
-				13,
-				"lum",
-				[
-					6,
-					"std.dot",
-					["straight", [
-						6,
-						"d.vec3f",
-						[
-							[5, "0.299"],
-							[5, "0.587"],
-							[5, "0.114"]
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"colored",
-				[
-					6,
-					[
-						7,
-						[
-							7,
-							"tint",
-							"xyz"
-						],
-						"mul"
-					],
-					[[
-						1,
-						"lum",
-						"*",
-						[5, "1.5"]
-					]]
-				]
-			],
-			[10, [
-				6,
-				"d.vec4f",
-				[[
-					6,
-					[
-						7,
-						"colored",
-						"mul"
-					],
-					[[
-						7,
-						"trail",
-						"w"
-					]]
-				], [
-					7,
-					"trail",
-					"w"
-				]]
-			]]
-		]]
-	},
-	externals: {
-		"std.max": () => max,
-		"std.dot": () => dot,
-		"d.vec3f": () => vec3f,
-		"d.vec4f": () => vec4f
-	}
-}) && $.f)({}));
-const timeTrailScaleTrail = typegpu_default.fn([vec4f, f32], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((trail, k) => {
-	"use gpu";
-	return trail.mul(k);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "trail"
-		}, {
-			"type": "i",
-			"name": "k"
-		}],
-		"body": [0, [[10, [
-			6,
-			[
-				7,
-				"trail",
-				"mul"
-			],
-			["k"]
-		]]]]
-	},
-	externals: {}
-}) && $.f)({}));
-var TINT_MODES = {
-	none: 0,
-	color: 1,
-	rainbow: 2
-};
-var SOURCE_MODES = {
-	motion: 1,
-	alpha: 0
-};
-var resolveBlendKey = (v) => {
-	const key = v === "add" ? "linearDodge" : String(v ?? "normal");
-	return key in blendModes ? key : "normal";
-};
-var stampModeFor = (key) => key === "screen" ? 1 : key === "linearDodge" ? 2 : 0;
-const componentDefinition = {
-	name: "TimeTrail",
-	boundingBoxDeclaration: { aspectRatio: null },
-	category: "Stylize",
-	description: "An Echo-style temporal trail — whatever moves sheds a smooth, decaying long-exposure ghost trail (frame-difference Motion mode works on opaque images and video; Alpha mode trails a shape's coverage), with optional zoom-feedback tunnels and rainbow light-painting",
-	requiresRTT: true,
-	requiresChild: true,
-	props: {
-		trailSource: {
-			default: "motion",
-			description: "What sheds the trail — Motion trails whatever changes frame-to-frame (works on opaque images and video), Alpha trails the child's transparency coverage (best for a clean shape over empty canvas)",
-			compileTime: true,
-			transform: (v) => SOURCE_MODES[v] ?? 1,
-			ui: {
-				type: "select",
-				options: [{
-					label: "Motion",
-					value: "motion"
-				}, {
-					label: "Alpha",
-					value: "alpha"
-				}],
-				label: "Source",
-				group: "Trail"
-			}
-		},
-		motionThreshold: {
-			default: .06,
-			description: "How much a pixel must change between frames to shed a trail (Motion source only) — lower catches subtle movement, higher only fast motion",
-			ui: {
-				type: ["range", "map"],
-				min: .01,
-				max: .5,
-				step: .01,
-				label: "Motion Threshold",
-				group: "Trail"
-			}
-		},
-		trailLength: {
-			default: .6,
-			description: "How long the trail lingers, in seconds — the time constant of the fade (the star control)",
-			ui: {
-				type: ["range", "map"],
-				min: .05,
-				max: 4,
-				step: .01,
-				label: "Trail Length",
-				group: "Trail"
-			}
-		},
-		diffusion: {
-			default: 1,
-			description: "How much the trail smears and softens as it fades — 0 keeps crisp ghost frames, higher melts them together",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Diffusion",
-				group: "Trail"
-			}
-		},
-		trailOpacity: {
-			default: 1,
-			description: "Overall strength of the trail behind the live frame",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Trail Opacity",
-				group: "Trail"
-			}
-		},
-		trailBlend: {
-			default: "normal",
-			description: "How the trail combines with the frame — Add / Screen build glowing light-painting trails, Multiply lays down dark ink ghosts, plus the full standard blend set",
-			compileTime: true,
-			ui: {
-				type: "select",
-				options: [
-					{
-						label: "Normal",
-						value: "normal"
-					},
-					{
-						label: "Add",
-						value: "add"
-					},
-					{
-						label: "Screen",
-						value: "screen"
-					},
-					{
-						label: "Multiply",
-						value: "multiply"
-					},
-					{
-						label: "Overlay",
-						value: "overlay"
-					},
-					{
-						label: "Soft Light",
-						value: "softLight"
-					},
-					{
-						label: "Hard Light",
-						value: "hardLight"
-					},
-					{
-						label: "Darken",
-						value: "darken"
-					},
-					{
-						label: "Lighten",
-						value: "lighten"
-					},
-					{
-						label: "Color Dodge",
-						value: "colorDodge"
-					},
-					{
-						label: "Color Burn",
-						value: "colorBurn"
-					},
-					{
-						label: "Linear Burn",
-						value: "linearBurn"
-					},
-					{
-						label: "Difference",
-						value: "difference"
-					},
-					{
-						label: "Exclusion",
-						value: "exclusion"
-					},
-					{
-						label: "Hue",
-						value: "hue"
-					},
-					{
-						label: "Saturation",
-						value: "saturation"
-					},
-					{
-						label: "Color",
-						value: "color"
-					},
-					{
-						label: "Luminosity",
-						value: "luminosity"
-					}
-				],
-				label: "Blend",
-				group: "Trail"
-			}
-		},
-		driftX: {
-			default: 0,
-			description: "Sideways drift of the trail per second — smears the trail in a direction",
-			ui: {
-				type: ["range", "map"],
-				min: -1,
-				max: 1,
-				step: .01,
-				label: "Drift X",
-				group: "Feedback"
-			}
-		},
-		driftY: {
-			default: 0,
-			description: "Vertical drift of the trail per second",
-			ui: {
-				type: ["range", "map"],
-				min: -1,
-				max: 1,
-				step: .01,
-				label: "Drift Y",
-				group: "Feedback"
-			}
-		},
-		zoom: {
-			default: 1,
-			description: "Per-frame zoom of the trail around the centre — above 1 pulls the trail into an outward tunnel, below 1 sucks it inward",
-			ui: {
-				type: ["range", "map"],
-				min: .9,
-				max: 1.1,
-				step: .001,
-				label: "Zoom",
-				group: "Feedback"
-			}
-		},
-		tintMode: {
-			default: "none",
-			description: "Colour the trail — Color tints it a single hue, Rainbow cycles hue as the trail ages",
-			compileTime: true,
-			transform: (v) => TINT_MODES[v] ?? 0,
-			ui: {
-				type: "select",
-				options: [
-					{
-						label: "None",
-						value: "none"
-					},
-					{
-						label: "Color",
-						value: "color"
-					},
-					{
-						label: "Rainbow",
-						value: "rainbow"
-					}
-				],
-				label: "Tint Mode",
-				group: "Color"
-			}
-		},
-		tint: {
-			default: "#33aaff",
-			transform: transformColor,
-			description: "Trail tint colour (used in Color mode)",
-			ui: {
-				type: "color",
-				label: "Tint",
-				group: "Color"
-			}
-		},
-		speed: {
-			default: 1,
-			description: "Simulation speed. 0 freezes the trail in place.",
-			ui: {
-				type: "range",
-				min: 0,
-				max: 4,
-				step: .1,
-				label: "Speed",
-				group: "Animation"
-			}
-		}
-	},
-	compute: (params) => {
-		const { childNode, gpu, getCpuValue, propValues } = params;
-		if (!childNode) return null;
-		const root = gpu?.root;
-		if (!root) return null;
-		const tintMode = Number(propValues.tintMode) || 0;
-		const blendMode = stampModeFor(resolveBlendKey(propValues.trailBlend));
-		const isMotion = (propValues.trailSource == null ? 1 : Number(propValues.trailSource)) > .5;
-		const trailSampler = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createSampler({
-			magFilter: "linear",
-			minFilter: "linear",
-			addressModeU: "clamp-to-edge",
-			addressModeV: "clamp-to-edge"
-		}), "trailSampler");
-		const paramsBuf = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(TrailParams), "paramsBuf");
-		const sim = createFeedbackTrailSim(params, {
-			size: STATE_RES,
-			format: STATE_FORMAT,
-			extraSlots: { prevLive: isMotion ? STATE_RES : [1, 1] },
-			speedProp: "speed",
-			bindGroups: ({ childTexture, display }, read, write) => root.createBindGroup(trailLayout, {
-				src: childTexture,
-				prev: read.state,
-				next: write.state,
-				display,
-				prevLive: read.extra.prevLive,
-				prevLiveOut: write.extra.prevLive,
-				samp: trailSampler,
-				params: paramsBuf.buffer
-			})
-		});
-		if (!sim) return null;
-		const trailFn = tintMode === 2 ? timeTrailDecayedTinted : timeTrailDecayed;
-		const kernel = isMotion ? makeTimeTrailKernel(trailFn) : makeTimeTrailAlphaKernel(trailFn);
-		const pipeline = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-			"use gpu";
-			kernel(cx, cy);
-		}), {
-			v: 2,
-			name: void 0,
-			ast: {
-				"params": [{
-					"type": "i",
-					"name": "cx"
-				}, {
-					"type": "i",
-					"name": "cy"
-				}],
-				"body": [0, [[
-					6,
-					"kernel",
-					["cx", "cy"]
-				]]]
-			},
-			externals: { "kernel": () => kernel }
-		}) && $.f)({}), { size: [STATE_RES, STATE_RES] });
-		return {
-			outputs: {
-				childTexture: sim.childTexture,
-				display: sim.display
-			},
-			bindInputs: sim.bindInputs,
-			getComputeNodes: (frameParams) => sim.tick(frameParams, ({ groups, dt }) => {
-				const zoom = getCpuValue("zoom") ?? 1;
-				if ((getCpuValue("trailOpacity") ?? 1) === 0) return null;
-				const trailLength = Math.max(getCpuValue("trailLength") ?? .6, .001);
-				paramsBuf.write({
-					persistence: Math.exp(-dt / trailLength),
-					diffusion: getCpuValue("diffusion") ?? .3,
-					driftX: getCpuValue("driftX") ?? 0,
-					driftY: getCpuValue("driftY") ?? 0,
-					dt,
-					zoom: Math.pow(zoom, dt * 60),
-					hueRate: tintMode === 2 ? RAINBOW_RATE * dt : 0,
-					blendMode,
-					motionThreshold: getCpuValue("motionThreshold") ?? .06
-				});
-				return [pipeline.with(groups)];
-			})
-		};
-	},
-	fragment: ({ childNode, ctx, computeOutputs, uniforms, propValues, convertToTexture }) => {
-		if (!childNode) return ZERO;
-		const display = computeOutputs?.display;
-		const live = (computeOutputs?.childTexture ?? convertToTexture(childNode)).sample(ctx.uv);
-		if (!display) return call(unpremultiplyAlpha, "unpremultiplyAlpha", [live]);
-		const blendKey = resolveBlendKey(propValues.trailBlend);
-		const blendFn = blendModes[blendKey];
-		const tintMode = Number(propValues.tintMode) || 0;
-		const sourceMode = propValues.trailSource == null ? 1 : Number(propValues.trailSource);
-		let trail = display.sample(ctx.uv, "linearClamp");
-		if (tintMode === 1) trail = call(timeTrailColorize, "timeTrailColorize", [trail, uniforms.tint]);
-		const liveStraight = call(unpremultiplyAlpha, "unpremultiplyLive", [live]);
-		if (sourceMode === 1) {
-			const trailStraight$1 = call(unpremultiplyAlpha, "unpremultiplyTrail", [trail]);
-			return call(unpremultiplyAlpha, "unpremultiplyOut", [call(blendFn, `trailBlend_${blendKey}`, [
-				liveStraight,
-				trailStraight$1,
-				uniforms.trailOpacity
-			])]);
-		}
-		const trailStraight = call(unpremultiplyAlpha, "unpremultiplyTrail", [call(timeTrailScaleTrail, "timeTrailScaleTrail", [trail, uniforms.trailOpacity])]);
-		return call(unpremultiplyAlpha, "unpremultiplyOut", [call(blendFn, `trailBlend_${blendKey}`, [
-			trailStraight,
-			liveStraight,
-			floatE(1)
-		])]);
-	}
-};
-var TimeTrail_default = componentDefinition;
-export { timeTrailColorize as a, timeTrailFeedbackUv as c, timeTrailRotateHue as d, timeTrailSampleHistory as f, timeTrailTexelUv as g, timeTrailStamp as h, makeTimeTrailKernel as i, timeTrailKernel as l, timeTrailScaleTrail as m, componentDefinition as n, timeTrailDecayed as o, timeTrailSampleLive as p, makeTimeTrailAlphaKernel as r, timeTrailDecayedTinted as s, TimeTrail_default as t, timeTrailMotionMask as u };