shaders 3.0.441 → 3.0.443

package/dist/core/FloatingParticles-Qh0dQBmA.js

@@ -1,2582 +0,0 @@
-import { Ft as floatE, V as createGuardedCompute, jt as call, kt as ZERO, n as tgpu, sn as d, z as std } from "./coords-DLZT4HVT.js";
-import { a as transformColor } from "./transformations-P50Uo_Ju.js";
-var PARTICLE_TEX = 1024;
-var STATE_FORMAT = "rgba16float";
-var ParticleParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(d.struct({
-	randomness: d.f32,
-	particleSoftness: d.f32,
-	particleSize: d.f32,
-	twinkle: d.f32,
-	count: d.f32,
-	angle: d.f32,
-	speedVariance: d.f32,
-	angleVariance: d.f32,
-	particleDensity: d.f32,
-	color: d.vec3f,
-	animTime: d.f32,
-	frameTime: d.f32,
-	aspect: d.f32
-}), "ParticleParams");
-var particleLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
-	params: { uniform: ParticleParams },
-	outTex: { storageTexture: d.textureStorage2d(STATE_FORMAT, "write-only") }
-}), "particleLayout");
-var hash12 = tgpu.fn([d.vec2f], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p) => {
-	"use gpu";
-	const p3 = std.fract(d.vec3f(p.x, p.y, p.x).mul(.1031));
-	const dd = std.dot(p3, d.vec3f(p3.y, p3.z, p3.x).add(33.33));
-	const p3b = p3.add(dd);
-	return std.fract(__tsover_mul(__tsover_add(p3b.x, p3b.y), p3b.z));
-}), {
-	v: 1,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "p"
-		}],
-		"body": [0, [
-			[
-				13,
-				"p3",
-				[
-					6,
-					[
-						7,
-						"std",
-						"fract"
-					],
-					[[
-						6,
-						[
-							7,
-							[
-								6,
-								[
-									7,
-									"d",
-									"vec3f"
-								],
-								[
-									[
-										7,
-										"p",
-										"x"
-									],
-									[
-										7,
-										"p",
-										"y"
-									],
-									[
-										7,
-										"p",
-										"x"
-									]
-								]
-							],
-							"mul"
-						],
-						[[5, "0.1031"]]
-					]]
-				]
-			],
-			[
-				13,
-				"dd",
-				[
-					6,
-					[
-						7,
-						"std",
-						"dot"
-					],
-					["p3", [
-						6,
-						[
-							7,
-							[
-								6,
-								[
-									7,
-									"d",
-									"vec3f"
-								],
-								[
-									[
-										7,
-										"p3",
-										"y"
-									],
-									[
-										7,
-										"p3",
-										"z"
-									],
-									[
-										7,
-										"p3",
-										"x"
-									]
-								]
-							],
-							"add"
-						],
-						[[5, "33.33"]]
-					]]
-				]
-			],
-			[
-				13,
-				"p3b",
-				[
-					6,
-					[
-						7,
-						"p3",
-						"add"
-					],
-					["dd"]
-				]
-			],
-			[10, [
-				6,
-				[
-					7,
-					"std",
-					"fract"
-				],
-				[[
-					1,
-					[
-						1,
-						[
-							7,
-							"p3b",
-							"x"
-						],
-						"+",
-						[
-							7,
-							"p3b",
-							"y"
-						]
-					],
-					"*",
-					[
-						7,
-						"p3b",
-						"z"
-					]
-				]]
-			]]
-		]],
-		"externalNames": ["std", "d"]
-	},
-	externals: () => ({
-		std,
-		d
-	})
-}) && $.f)({}));
-var hash22 = tgpu.fn([d.vec2f], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p) => {
-	"use gpu";
-	const p3 = std.fract(d.vec3f(p.x, p.y, p.x).mul(d.vec3f(.1031, .103, .0973)));
-	const dd = std.dot(p3, d.vec3f(p3.y, p3.z, p3.x).add(33.33));
-	const p3b = p3.add(dd);
-	const s = __tsover_add(p3b.x, p3b.y);
-	return std.fract(d.vec2f(__tsover_mul(s, p3b.z), __tsover_mul(s, p3b.y)));
-}), {
-	v: 1,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "p"
-		}],
-		"body": [0, [
-			[
-				13,
-				"p3",
-				[
-					6,
-					[
-						7,
-						"std",
-						"fract"
-					],
-					[[
-						6,
-						[
-							7,
-							[
-								6,
-								[
-									7,
-									"d",
-									"vec3f"
-								],
-								[
-									[
-										7,
-										"p",
-										"x"
-									],
-									[
-										7,
-										"p",
-										"y"
-									],
-									[
-										7,
-										"p",
-										"x"
-									]
-								]
-							],
-							"mul"
-						],
-						[[
-							6,
-							[
-								7,
-								"d",
-								"vec3f"
-							],
-							[
-								[5, "0.1031"],
-								[5, "0.103"],
-								[5, "0.0973"]
-							]
-						]]
-					]]
-				]
-			],
-			[
-				13,
-				"dd",
-				[
-					6,
-					[
-						7,
-						"std",
-						"dot"
-					],
-					["p3", [
-						6,
-						[
-							7,
-							[
-								6,
-								[
-									7,
-									"d",
-									"vec3f"
-								],
-								[
-									[
-										7,
-										"p3",
-										"y"
-									],
-									[
-										7,
-										"p3",
-										"z"
-									],
-									[
-										7,
-										"p3",
-										"x"
-									]
-								]
-							],
-							"add"
-						],
-						[[5, "33.33"]]
-					]]
-				]
-			],
-			[
-				13,
-				"p3b",
-				[
-					6,
-					[
-						7,
-						"p3",
-						"add"
-					],
-					["dd"]
-				]
-			],
-			[
-				13,
-				"s",
-				[
-					1,
-					[
-						7,
-						"p3b",
-						"x"
-					],
-					"+",
-					[
-						7,
-						"p3b",
-						"y"
-					]
-				]
-			],
-			[10, [
-				6,
-				[
-					7,
-					"std",
-					"fract"
-				],
-				[[
-					6,
-					[
-						7,
-						"d",
-						"vec2f"
-					],
-					[[
-						1,
-						"s",
-						"*",
-						[
-							7,
-							"p3b",
-							"z"
-						]
-					], [
-						1,
-						"s",
-						"*",
-						[
-							7,
-							"p3b",
-							"y"
-						]
-					]]
-				]]
-			]]
-		]],
-		"externalNames": ["std", "d"]
-	},
-	externals: () => ({
-		std,
-		d
-	})
-}) && $.f)({}));
-var voronoiPoint = tgpu.fn([d.vec2f, d.f32], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((root, deg) => {
-	"use gpu";
-	const point = hash22(root).sub(.5);
-	const s = std.sin(deg);
-	const c = std.cos(deg);
-	const rotatedX = __tsover_mul(__tsover_sub(__tsover_mul(c, point.x), __tsover_mul(s, point.y)), .66);
-	const rotatedY = __tsover_mul(__tsover_add(__tsover_mul(s, point.x), __tsover_mul(c, point.y)), .66);
-	return d.vec2f(rotatedX, rotatedY).add(root).add(.5);
-}), {
-	v: 1,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "root"
-		}, {
-			"type": "i",
-			"name": "deg"
-		}],
-		"body": [0, [
-			[
-				13,
-				"point",
-				[
-					6,
-					[
-						7,
-						[
-							6,
-							"hash22",
-							["root"]
-						],
-						"sub"
-					],
-					[[5, "0.5"]]
-				]
-			],
-			[
-				13,
-				"s",
-				[
-					6,
-					[
-						7,
-						"std",
-						"sin"
-					],
-					["deg"]
-				]
-			],
-			[
-				13,
-				"c",
-				[
-					6,
-					[
-						7,
-						"std",
-						"cos"
-					],
-					["deg"]
-				]
-			],
-			[
-				13,
-				"rotatedX",
-				[
-					1,
-					[
-						1,
-						[
-							1,
-							"c",
-							"*",
-							[
-								7,
-								"point",
-								"x"
-							]
-						],
-						"-",
-						[
-							1,
-							"s",
-							"*",
-							[
-								7,
-								"point",
-								"y"
-							]
-						]
-					],
-					"*",
-					[5, "0.66"]
-				]
-			],
-			[
-				13,
-				"rotatedY",
-				[
-					1,
-					[
-						1,
-						[
-							1,
-							"s",
-							"*",
-							[
-								7,
-								"point",
-								"x"
-							]
-						],
-						"+",
-						[
-							1,
-							"c",
-							"*",
-							[
-								7,
-								"point",
-								"y"
-							]
-						]
-					],
-					"*",
-					[5, "0.66"]
-				]
-			],
-			[10, [
-				6,
-				[
-					7,
-					[
-						6,
-						[
-							7,
-							[
-								6,
-								[
-									7,
-									"d",
-									"vec2f"
-								],
-								["rotatedX", "rotatedY"]
-							],
-							"add"
-						],
-						["root"]
-					],
-					"add"
-				],
-				[[5, "0.5"]]
-			]]
-		]],
-		"externalNames": [
-			"hash22",
-			"std",
-			"d"
-		]
-	},
-	externals: () => ({
-		hash22,
-		std,
-		d
-	})
-}) && $.f)({}));
-var degFromRoot = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, randomness, frameTime) => {
-	"use gpu";
-	return __tsover_mul(__tsover_mul(__tsover_mul(frameTime, randomness), __tsover_sub(hash12(uv), .5)), 2);
-}), {
-	v: 1,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "uv"
-			},
-			{
-				"type": "i",
-				"name": "randomness"
-			},
-			{
-				"type": "i",
-				"name": "frameTime"
-			}
-		],
-		"body": [0, [[10, [
-			1,
-			[
-				1,
-				[
-					1,
-					"frameTime",
-					"*",
-					"randomness"
-				],
-				"*",
-				[
-					1,
-					[
-						6,
-						"hash12",
-						["uv"]
-					],
-					"-",
-					[5, "0.5"]
-				]
-			],
-			"*",
-			[5, "2"]
-		]]]],
-		"externalNames": ["hash12"]
-	},
-	externals: () => ({ hash12 })
-}) && $.f)({}));
-var getParticleDistance = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.f32,
-	d.f32
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, cellUV, randomness, frameTime) => {
-	"use gpu";
-	const pointUV = voronoiPoint(cellUV, degFromRoot(cellUV, randomness, frameTime));
-	return std.length(uv.sub(pointUV));
-}), {
-	v: 1,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "uv"
-			},
-			{
-				"type": "i",
-				"name": "cellUV"
-			},
-			{
-				"type": "i",
-				"name": "randomness"
-			},
-			{
-				"type": "i",
-				"name": "frameTime"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"deg",
-				[
-					6,
-					"degFromRoot",
-					[
-						"cellUV",
-						"randomness",
-						"frameTime"
-					]
-				]
-			],
-			[
-				13,
-				"pointUV",
-				[
-					6,
-					"voronoiPoint",
-					["cellUV", "deg"]
-				]
-			],
-			[10, [
-				6,
-				[
-					7,
-					"std",
-					"length"
-				],
-				[[
-					6,
-					[
-						7,
-						"uv",
-						"sub"
-					],
-					["pointUV"]
-				]]
-			]]
-		]],
-		"externalNames": [
-			"degFromRoot",
-			"voronoiPoint",
-			"std"
-		]
-	},
-	externals: () => ({
-		degFromRoot,
-		voronoiPoint,
-		std
-	})
-}) && $.f)({}));
-var renderParticle = tgpu.fn([d.vec2f, ParticleParams], d.vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, p) => {
-	"use gpu";
-	const rootUV = std.floor(uv);
-	const dCenter = getParticleDistance(uv, rootUV, p.randomness, p.frameTime);
-	const dLeft = getParticleDistance(uv, rootUV.add(d.vec2f(-1, 0)), p.randomness, p.frameTime);
-	const dRight = getParticleDistance(uv, rootUV.add(d.vec2f(1, 0)), p.randomness, p.frameTime);
-	const dTop = getParticleDistance(uv, rootUV.add(d.vec2f(0, -1)), p.randomness, p.frameTime);
-	const dBottom = getParticleDistance(uv, rootUV.add(d.vec2f(0, 1)), p.randomness, p.frameTime);
-	const minDist = std.min(std.min(std.min(std.min(dCenter, dLeft), dRight), dTop), dBottom);
-	const scaledSize = __tsover_mul(p.particleSize, .01);
-	const innerRadius = __tsover_mul(scaledSize, .6);
-	const outerRadius = __tsover_add(innerRadius, __tsover_mul(p.particleSoftness, __tsover_mul(scaledSize, 2.4)));
-	const baseIntensity = __tsover_sub(1, std.smoothstep(innerRadius, outerRadius, minDist));
-	const particlePhase = hash12(rootUV);
-	const twinkleTime = __tsover_add(__tsover_mul(p.frameTime, 2), __tsover_mul(particlePhase, 6.28318));
-	const twinkleValue = __tsover_add(__tsover_mul(std.sin(twinkleTime), .5), .5);
-	const twinkleModifier = std.mix(d.f32(1), twinkleValue, p.twinkle);
-	return p.color.mul(__tsover_mul(baseIntensity, twinkleModifier));
-}), {
-	v: 1,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "uv"
-		}, {
-			"type": "i",
-			"name": "p"
-		}],
-		"body": [0, [
-			[
-				13,
-				"rootUV",
-				[
-					6,
-					[
-						7,
-						"std",
-						"floor"
-					],
-					["uv"]
-				]
-			],
-			[
-				13,
-				"dCenter",
-				[
-					6,
-					"getParticleDistance",
-					[
-						"uv",
-						"rootUV",
-						[
-							7,
-							"p",
-							"randomness"
-						],
-						[
-							7,
-							"p",
-							"frameTime"
-						]
-					]
-				]
-			],
-			[
-				13,
-				"dLeft",
-				[
-					6,
-					"getParticleDistance",
-					[
-						"uv",
-						[
-							6,
-							[
-								7,
-								"rootUV",
-								"add"
-							],
-							[[
-								6,
-								[
-									7,
-									"d",
-									"vec2f"
-								],
-								[[
-									4,
-									"-",
-									[5, "1"]
-								], [5, "0"]]
-							]]
-						],
-						[
-							7,
-							"p",
-							"randomness"
-						],
-						[
-							7,
-							"p",
-							"frameTime"
-						]
-					]
-				]
-			],
-			[
-				13,
-				"dRight",
-				[
-					6,
-					"getParticleDistance",
-					[
-						"uv",
-						[
-							6,
-							[
-								7,
-								"rootUV",
-								"add"
-							],
-							[[
-								6,
-								[
-									7,
-									"d",
-									"vec2f"
-								],
-								[[5, "1"], [5, "0"]]
-							]]
-						],
-						[
-							7,
-							"p",
-							"randomness"
-						],
-						[
-							7,
-							"p",
-							"frameTime"
-						]
-					]
-				]
-			],
-			[
-				13,
-				"dTop",
-				[
-					6,
-					"getParticleDistance",
-					[
-						"uv",
-						[
-							6,
-							[
-								7,
-								"rootUV",
-								"add"
-							],
-							[[
-								6,
-								[
-									7,
-									"d",
-									"vec2f"
-								],
-								[[5, "0"], [
-									4,
-									"-",
-									[5, "1"]
-								]]
-							]]
-						],
-						[
-							7,
-							"p",
-							"randomness"
-						],
-						[
-							7,
-							"p",
-							"frameTime"
-						]
-					]
-				]
-			],
-			[
-				13,
-				"dBottom",
-				[
-					6,
-					"getParticleDistance",
-					[
-						"uv",
-						[
-							6,
-							[
-								7,
-								"rootUV",
-								"add"
-							],
-							[[
-								6,
-								[
-									7,
-									"d",
-									"vec2f"
-								],
-								[[5, "0"], [5, "1"]]
-							]]
-						],
-						[
-							7,
-							"p",
-							"randomness"
-						],
-						[
-							7,
-							"p",
-							"frameTime"
-						]
-					]
-				]
-			],
-			[
-				13,
-				"minDist",
-				[
-					6,
-					[
-						7,
-						"std",
-						"min"
-					],
-					[[
-						6,
-						[
-							7,
-							"std",
-							"min"
-						],
-						[[
-							6,
-							[
-								7,
-								"std",
-								"min"
-							],
-							[[
-								6,
-								[
-									7,
-									"std",
-									"min"
-								],
-								["dCenter", "dLeft"]
-							], "dRight"]
-						], "dTop"]
-					], "dBottom"]
-				]
-			],
-			[
-				13,
-				"scaledSize",
-				[
-					1,
-					[
-						7,
-						"p",
-						"particleSize"
-					],
-					"*",
-					[5, "0.01"]
-				]
-			],
-			[
-				13,
-				"innerRadius",
-				[
-					1,
-					"scaledSize",
-					"*",
-					[5, "0.6"]
-				]
-			],
-			[
-				13,
-				"outerRadius",
-				[
-					1,
-					"innerRadius",
-					"+",
-					[
-						1,
-						[
-							7,
-							"p",
-							"particleSoftness"
-						],
-						"*",
-						[
-							1,
-							"scaledSize",
-							"*",
-							[5, "2.4"]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"baseIntensity",
-				[
-					1,
-					[5, "1"],
-					"-",
-					[
-						6,
-						[
-							7,
-							"std",
-							"smoothstep"
-						],
-						[
-							"innerRadius",
-							"outerRadius",
-							"minDist"
-						]
-					]
-				]
-			],
-			[
-				13,
-				"particlePhase",
-				[
-					6,
-					"hash12",
-					["rootUV"]
-				]
-			],
-			[
-				13,
-				"twinkleTime",
-				[
-					1,
-					[
-						1,
-						[
-							7,
-							"p",
-							"frameTime"
-						],
-						"*",
-						[5, "2"]
-					],
-					"+",
-					[
-						1,
-						"particlePhase",
-						"*",
-						[5, "6.28318"]
-					]
-				]
-			],
-			[
-				13,
-				"twinkleValue",
-				[
-					1,
-					[
-						1,
-						[
-							6,
-							[
-								7,
-								"std",
-								"sin"
-							],
-							["twinkleTime"]
-						],
-						"*",
-						[5, "0.5"]
-					],
-					"+",
-					[5, "0.5"]
-				]
-			],
-			[
-				13,
-				"twinkleModifier",
-				[
-					6,
-					[
-						7,
-						"std",
-						"mix"
-					],
-					[
-						[
-							6,
-							[
-								7,
-								"d",
-								"f32"
-							],
-							[[5, "1"]]
-						],
-						"twinkleValue",
-						[
-							7,
-							"p",
-							"twinkle"
-						]
-					]
-				]
-			],
-			[10, [
-				6,
-				[
-					7,
-					[
-						7,
-						"p",
-						"color"
-					],
-					"mul"
-				],
-				[[
-					1,
-					"baseIntensity",
-					"*",
-					"twinkleModifier"
-				]]
-			]]
-		]],
-		"externalNames": [
-			"std",
-			"getParticleDistance",
-			"d",
-			"hash12"
-		]
-	},
-	externals: () => ({
-		std,
-		getParticleDistance,
-		d,
-		hash12
-	})
-}) && $.f)({}));
-var layeredParticles = tgpu.fn([d.vec2f, ParticleParams], d.vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, p) => {
-	"use gpu";
-	const sizeMod = 1.05;
-	const alphaMod = .9;
-	let particles = d.vec3f(0, 0, 0);
-	let layerScale = d.f32(1);
-	let alpha = d.f32(1);
-	let offset = d.vec2f(0, 0);
-	const angleRad = __tsover_div(__tsover_mul(p.angle, 3.14159), 180);
-	const baseMovementDir = d.vec2f(std.cos(angleRad), std.sin(angleRad));
-	const baseMovement = baseMovementDir.mul(p.animTime);
-	const speedVar = p.speedVariance;
-	const angleVar = __tsover_div(__tsover_mul(p.angleVariance, 3.14159), 180);
-	for (let i = 0; i < 5; i++) {
-		const layerActive = d.f32(i) < p.count && alpha > .02;
-		const layerHash = hash22(d.vec2f(alpha, __tsover_mul(d.f32(i), 7.919)));
-		const speedMod = __tsover_add(1, __tsover_mul(__tsover_sub(layerHash.x, .5), speedVar));
-		const angleDelta = __tsover_mul(__tsover_mul(__tsover_sub(layerHash.y, .5), angleVar), 2);
-		const variedAngle = __tsover_add(angleRad, angleDelta);
-		const variedDir = d.vec2f(std.cos(variedAngle), std.sin(variedAngle));
-		const movement = baseMovement.mul(speedMod).add(variedDir.sub(baseMovementDir).mul(p.animTime));
-		const layerParticles = renderParticle(uv.mul(layerScale).add(movement).add(offset), p).mul(alpha);
-		particles = particles.add(std.select(d.vec3f(0, 0, 0), layerParticles, layerActive));
-		offset = offset.add(layerHash.mul(10));
-		alpha = __tsover_mul(alpha, alphaMod);
-		layerScale = __tsover_mul(layerScale, sizeMod);
-	}
-	return particles;
-}), {
-	v: 1,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "uv"
-		}, {
-			"type": "i",
-			"name": "p"
-		}],
-		"body": [0, [
-			[
-				13,
-				"sizeMod",
-				[5, "1.05"]
-			],
-			[
-				13,
-				"alphaMod",
-				[5, "0.9"]
-			],
-			[
-				12,
-				"particles",
-				[
-					6,
-					[
-						7,
-						"d",
-						"vec3f"
-					],
-					[
-						[5, "0"],
-						[5, "0"],
-						[5, "0"]
-					]
-				]
-			],
-			[
-				12,
-				"layerScale",
-				[
-					6,
-					[
-						7,
-						"d",
-						"f32"
-					],
-					[[5, "1"]]
-				]
-			],
-			[
-				12,
-				"alpha",
-				[
-					6,
-					[
-						7,
-						"d",
-						"f32"
-					],
-					[[5, "1"]]
-				]
-			],
-			[
-				12,
-				"offset",
-				[
-					6,
-					[
-						7,
-						"d",
-						"vec2f"
-					],
-					[[5, "0"], [5, "0"]]
-				]
-			],
-			[
-				13,
-				"angleRad",
-				[
-					1,
-					[
-						1,
-						[
-							7,
-							"p",
-							"angle"
-						],
-						"*",
-						[5, "3.14159"]
-					],
-					"/",
-					[5, "180"]
-				]
-			],
-			[
-				13,
-				"baseMovementDir",
-				[
-					6,
-					[
-						7,
-						"d",
-						"vec2f"
-					],
-					[[
-						6,
-						[
-							7,
-							"std",
-							"cos"
-						],
-						["angleRad"]
-					], [
-						6,
-						[
-							7,
-							"std",
-							"sin"
-						],
-						["angleRad"]
-					]]
-				]
-			],
-			[
-				13,
-				"baseMovement",
-				[
-					6,
-					[
-						7,
-						"baseMovementDir",
-						"mul"
-					],
-					[[
-						7,
-						"p",
-						"animTime"
-					]]
-				]
-			],
-			[
-				13,
-				"speedVar",
-				[
-					7,
-					"p",
-					"speedVariance"
-				]
-			],
-			[
-				13,
-				"angleVar",
-				[
-					1,
-					[
-						1,
-						[
-							7,
-							"p",
-							"angleVariance"
-						],
-						"*",
-						[5, "3.14159"]
-					],
-					"/",
-					[5, "180"]
-				]
-			],
-			[
-				14,
-				[
-					12,
-					"i",
-					[5, "0"]
-				],
-				[
-					1,
-					"i",
-					"<",
-					[5, "5"]
-				],
-				[
-					102,
-					"++",
-					"i"
-				],
-				[0, [
-					[
-						13,
-						"layerActive",
-						[
-							3,
-							[
-								1,
-								[
-									6,
-									[
-										7,
-										"d",
-										"f32"
-									],
-									["i"]
-								],
-								"<",
-								[
-									7,
-									"p",
-									"count"
-								]
-							],
-							"&&",
-							[
-								1,
-								"alpha",
-								">",
-								[5, "0.02"]
-							]
-						]
-					],
-					[
-						13,
-						"layerHash",
-						[
-							6,
-							"hash22",
-							[[
-								6,
-								[
-									7,
-									"d",
-									"vec2f"
-								],
-								["alpha", [
-									1,
-									[
-										6,
-										[
-											7,
-											"d",
-											"f32"
-										],
-										["i"]
-									],
-									"*",
-									[5, "7.919"]
-								]]
-							]]
-						]
-					],
-					[
-						13,
-						"speedMod",
-						[
-							1,
-							[5, "1"],
-							"+",
-							[
-								1,
-								[
-									1,
-									[
-										7,
-										"layerHash",
-										"x"
-									],
-									"-",
-									[5, "0.5"]
-								],
-								"*",
-								"speedVar"
-							]
-						]
-					],
-					[
-						13,
-						"angleDelta",
-						[
-							1,
-							[
-								1,
-								[
-									1,
-									[
-										7,
-										"layerHash",
-										"y"
-									],
-									"-",
-									[5, "0.5"]
-								],
-								"*",
-								"angleVar"
-							],
-							"*",
-							[5, "2"]
-						]
-					],
-					[
-						13,
-						"variedAngle",
-						[
-							1,
-							"angleRad",
-							"+",
-							"angleDelta"
-						]
-					],
-					[
-						13,
-						"variedDir",
-						[
-							6,
-							[
-								7,
-								"d",
-								"vec2f"
-							],
-							[[
-								6,
-								[
-									7,
-									"std",
-									"cos"
-								],
-								["variedAngle"]
-							], [
-								6,
-								[
-									7,
-									"std",
-									"sin"
-								],
-								["variedAngle"]
-							]]
-						]
-					],
-					[
-						13,
-						"movement",
-						[
-							6,
-							[
-								7,
-								[
-									6,
-									[
-										7,
-										"baseMovement",
-										"mul"
-									],
-									["speedMod"]
-								],
-								"add"
-							],
-							[[
-								6,
-								[
-									7,
-									[
-										6,
-										[
-											7,
-											"variedDir",
-											"sub"
-										],
-										["baseMovementDir"]
-									],
-									"mul"
-								],
-								[[
-									7,
-									"p",
-									"animTime"
-								]]
-							]]
-						]
-					],
-					[
-						13,
-						"particleUV",
-						[
-							6,
-							[
-								7,
-								[
-									6,
-									[
-										7,
-										[
-											6,
-											[
-												7,
-												"uv",
-												"mul"
-											],
-											["layerScale"]
-										],
-										"add"
-									],
-									["movement"]
-								],
-								"add"
-							],
-							["offset"]
-						]
-					],
-					[
-						13,
-						"layerParticles",
-						[
-							6,
-							[
-								7,
-								[
-									6,
-									"renderParticle",
-									["particleUV", "p"]
-								],
-								"mul"
-							],
-							["alpha"]
-						]
-					],
-					[
-						2,
-						"particles",
-						"=",
-						[
-							6,
-							[
-								7,
-								"particles",
-								"add"
-							],
-							[[
-								6,
-								[
-									7,
-									"std",
-									"select"
-								],
-								[
-									[
-										6,
-										[
-											7,
-											"d",
-											"vec3f"
-										],
-										[
-											[5, "0"],
-											[5, "0"],
-											[5, "0"]
-										]
-									],
-									"layerParticles",
-									"layerActive"
-								]
-							]]
-						]
-					],
-					[
-						2,
-						"offset",
-						"=",
-						[
-							6,
-							[
-								7,
-								"offset",
-								"add"
-							],
-							[[
-								6,
-								[
-									7,
-									"layerHash",
-									"mul"
-								],
-								[[5, "10"]]
-							]]
-						]
-					],
-					[
-						2,
-						"alpha",
-						"=",
-						[
-							1,
-							"alpha",
-							"*",
-							"alphaMod"
-						]
-					],
-					[
-						2,
-						"layerScale",
-						"=",
-						[
-							1,
-							"layerScale",
-							"*",
-							"sizeMod"
-						]
-					]
-				]]
-			],
-			[10, "particles"]
-		]],
-		"externalNames": [
-			"d",
-			"std",
-			"hash22",
-			"renderParticle"
-		]
-	},
-	externals: () => ({
-		d,
-		std,
-		hash22,
-		renderParticle
-	})
-}) && $.f)({}));
-const particleKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-	"use gpu";
-	const p = particleLayout.$.params;
-	const u = __tsover_div(__tsover_add(d.f32(cx), .5), d.f32(PARTICLE_TEX));
-	const v = __tsover_div(__tsover_add(d.f32(cy), .5), d.f32(PARTICLE_TEX));
-	const particles = layeredParticles(d.vec2f(__tsover_mul(__tsover_sub(__tsover_mul(u, 2), 1), p.aspect), __tsover_sub(__tsover_mul(v, 2), 1)).mul(p.particleDensity), p);
-	const pa = std.clamp(std.length(particles), 0, 1);
-	std.textureStore(particleLayout.$.outTex, d.vec2u(cx, cy), d.vec4f(particles, pa));
-}), {
-	v: 1,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "cx"
-		}, {
-			"type": "i",
-			"name": "cy"
-		}],
-		"body": [0, [
-			[
-				13,
-				"p",
-				[
-					7,
-					[
-						7,
-						"particleLayout",
-						"$"
-					],
-					"params"
-				]
-			],
-			[
-				13,
-				"u",
-				[
-					1,
-					[
-						1,
-						[
-							6,
-							[
-								7,
-								"d",
-								"f32"
-							],
-							["cx"]
-						],
-						"+",
-						[5, "0.5"]
-					],
-					"/",
-					[
-						6,
-						[
-							7,
-							"d",
-							"f32"
-						],
-						["PARTICLE_TEX"]
-					]
-				]
-			],
-			[
-				13,
-				"v",
-				[
-					1,
-					[
-						1,
-						[
-							6,
-							[
-								7,
-								"d",
-								"f32"
-							],
-							["cy"]
-						],
-						"+",
-						[5, "0.5"]
-					],
-					"/",
-					[
-						6,
-						[
-							7,
-							"d",
-							"f32"
-						],
-						["PARTICLE_TEX"]
-					]
-				]
-			],
-			[
-				13,
-				"centered",
-				[
-					6,
-					[
-						7,
-						"d",
-						"vec2f"
-					],
-					[[
-						1,
-						[
-							1,
-							[
-								1,
-								"u",
-								"*",
-								[5, "2"]
-							],
-							"-",
-							[5, "1"]
-						],
-						"*",
-						[
-							7,
-							"p",
-							"aspect"
-						]
-					], [
-						1,
-						[
-							1,
-							"v",
-							"*",
-							[5, "2"]
-						],
-						"-",
-						[5, "1"]
-					]]
-				]
-			],
-			[
-				13,
-				"adjustedUV",
-				[
-					6,
-					[
-						7,
-						"centered",
-						"mul"
-					],
-					[[
-						7,
-						"p",
-						"particleDensity"
-					]]
-				]
-			],
-			[
-				13,
-				"particles",
-				[
-					6,
-					"layeredParticles",
-					["adjustedUV", "p"]
-				]
-			],
-			[
-				13,
-				"pa",
-				[
-					6,
-					[
-						7,
-						"std",
-						"clamp"
-					],
-					[
-						[
-							6,
-							[
-								7,
-								"std",
-								"length"
-							],
-							["particles"]
-						],
-						[5, "0"],
-						[5, "1"]
-					]
-				]
-			],
-			[
-				6,
-				[
-					7,
-					"std",
-					"textureStore"
-				],
-				[
-					[
-						7,
-						[
-							7,
-							"particleLayout",
-							"$"
-						],
-						"outTex"
-					],
-					[
-						6,
-						[
-							7,
-							"d",
-							"vec2u"
-						],
-						["cx", "cy"]
-					],
-					[
-						6,
-						[
-							7,
-							"d",
-							"vec4f"
-						],
-						["particles", "pa"]
-					]
-				]
-			]
-		]],
-		"externalNames": [
-			"particleLayout",
-			"d",
-			"PARTICLE_TEX",
-			"layeredParticles",
-			"std"
-		]
-	},
-	externals: () => ({
-		particleLayout,
-		d,
-		PARTICLE_TEX,
-		layeredParticles,
-		std
-	})
-}) && $.f)({})).$name("floatingParticles");
-const particleTapUV = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, ox, oy) => {
-	"use gpu";
-	return d.vec2f(__tsover_add(uv.x, ox), __tsover_add(uv.y, oy));
-}), {
-	v: 1,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "uv"
-			},
-			{
-				"type": "i",
-				"name": "ox"
-			},
-			{
-				"type": "i",
-				"name": "oy"
-			}
-		],
-		"body": [0, [[10, [
-			6,
-			[
-				7,
-				"d",
-				"vec2f"
-			],
-			[[
-				1,
-				[
-					7,
-					"uv",
-					"x"
-				],
-				"+",
-				"ox"
-			], [
-				1,
-				[
-					7,
-					"uv",
-					"y"
-				],
-				"+",
-				"oy"
-			]]
-		]]]],
-		"externalNames": ["d"]
-	},
-	externals: () => ({ d })
-}) && $.f)({}));
-const particleUpsample = tgpu.fn([
-	d.vec4f,
-	d.vec4f,
-	d.vec4f,
-	d.vec4f,
-	d.vec4f
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((s0, s1, s2, s3, s4) => {
-	"use gpu";
-	const rgb = s0.xyz.mul(.5).add(s1.xyz.mul(.125)).add(s2.xyz.mul(.125)).add(s3.xyz.mul(.125)).add(s4.xyz.mul(.125));
-	const a = __tsover_add(__tsover_add(__tsover_add(__tsover_add(__tsover_mul(s0.w, .5), __tsover_mul(s1.w, .125)), __tsover_mul(s2.w, .125)), __tsover_mul(s3.w, .125)), __tsover_mul(s4.w, .125));
-	return d.vec4f(rgb, a);
-}), {
-	v: 1,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "s0"
-			},
-			{
-				"type": "i",
-				"name": "s1"
-			},
-			{
-				"type": "i",
-				"name": "s2"
-			},
-			{
-				"type": "i",
-				"name": "s3"
-			},
-			{
-				"type": "i",
-				"name": "s4"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"rgb",
-				[
-					6,
-					[
-						7,
-						[
-							6,
-							[
-								7,
-								[
-									6,
-									[
-										7,
-										[
-											6,
-											[
-												7,
-												[
-													6,
-													[
-														7,
-														[
-															7,
-															"s0",
-															"xyz"
-														],
-														"mul"
-													],
-													[[5, "0.5"]]
-												],
-												"add"
-											],
-											[[
-												6,
-												[
-													7,
-													[
-														7,
-														"s1",
-														"xyz"
-													],
-													"mul"
-												],
-												[[5, "0.125"]]
-											]]
-										],
-										"add"
-									],
-									[[
-										6,
-										[
-											7,
-											[
-												7,
-												"s2",
-												"xyz"
-											],
-											"mul"
-										],
-										[[5, "0.125"]]
-									]]
-								],
-								"add"
-							],
-							[[
-								6,
-								[
-									7,
-									[
-										7,
-										"s3",
-										"xyz"
-									],
-									"mul"
-								],
-								[[5, "0.125"]]
-							]]
-						],
-						"add"
-					],
-					[[
-						6,
-						[
-							7,
-							[
-								7,
-								"s4",
-								"xyz"
-							],
-							"mul"
-						],
-						[[5, "0.125"]]
-					]]
-				]
-			],
-			[
-				13,
-				"a",
-				[
-					1,
-					[
-						1,
-						[
-							1,
-							[
-								1,
-								[
-									1,
-									[
-										7,
-										"s0",
-										"w"
-									],
-									"*",
-									[5, "0.5"]
-								],
-								"+",
-								[
-									1,
-									[
-										7,
-										"s1",
-										"w"
-									],
-									"*",
-									[5, "0.125"]
-								]
-							],
-							"+",
-							[
-								1,
-								[
-									7,
-									"s2",
-									"w"
-								],
-								"*",
-								[5, "0.125"]
-							]
-						],
-						"+",
-						[
-							1,
-							[
-								7,
-								"s3",
-								"w"
-							],
-							"*",
-							[5, "0.125"]
-						]
-					],
-					"+",
-					[
-						1,
-						[
-							7,
-							"s4",
-							"w"
-						],
-						"*",
-						[5, "0.125"]
-					]
-				]
-			],
-			[10, [
-				6,
-				[
-					7,
-					"d",
-					"vec4f"
-				],
-				["rgb", "a"]
-			]]
-		]],
-		"externalNames": ["d"]
-	},
-	externals: () => ({ d })
-}) && $.f)({}));
-const particleOverChild = tgpu.fn([d.vec4f, d.vec4f], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p, c) => {
-	"use gpu";
-	const gate = std.select(d.f32(0), p.w, p.w > .01);
-	const mixedColor = std.mix(c.xyz, p.xyz, d.vec3f(gate));
-	const pa = std.clamp(p.w, 0, 1);
-	const finalAlpha = __tsover_add(pa, __tsover_mul(c.w, __tsover_sub(1, pa)));
-	return d.vec4f(mixedColor, finalAlpha);
-}), {
-	v: 1,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "p"
-		}, {
-			"type": "i",
-			"name": "c"
-		}],
-		"body": [0, [
-			[
-				13,
-				"gate",
-				[
-					6,
-					[
-						7,
-						"std",
-						"select"
-					],
-					[
-						[
-							6,
-							[
-								7,
-								"d",
-								"f32"
-							],
-							[[5, "0"]]
-						],
-						[
-							7,
-							"p",
-							"w"
-						],
-						[
-							1,
-							[
-								7,
-								"p",
-								"w"
-							],
-							">",
-							[5, "0.01"]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"mixedColor",
-				[
-					6,
-					[
-						7,
-						"std",
-						"mix"
-					],
-					[
-						[
-							7,
-							"c",
-							"xyz"
-						],
-						[
-							7,
-							"p",
-							"xyz"
-						],
-						[
-							6,
-							[
-								7,
-								"d",
-								"vec3f"
-							],
-							["gate"]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"pa",
-				[
-					6,
-					[
-						7,
-						"std",
-						"clamp"
-					],
-					[
-						[
-							7,
-							"p",
-							"w"
-						],
-						[5, "0"],
-						[5, "1"]
-					]
-				]
-			],
-			[
-				13,
-				"finalAlpha",
-				[
-					1,
-					"pa",
-					"+",
-					[
-						1,
-						[
-							7,
-							"c",
-							"w"
-						],
-						"*",
-						[
-							1,
-							[5, "1"],
-							"-",
-							"pa"
-						]
-					]
-				]
-			],
-			[10, [
-				6,
-				[
-					7,
-					"d",
-					"vec4f"
-				],
-				["mixedColor", "finalAlpha"]
-			]]
-		]],
-		"externalNames": ["std", "d"]
-	},
-	externals: () => ({
-		std,
-		d
-	})
-}) && $.f)({}));
-const componentDefinition = {
-	name: "FloatingParticles",
-	boundingBoxDeclaration: { aspectRatio: null },
-	category: "Textures",
-	description: "Animated floating particles with twinkle effects",
-	requiresRTT: false,
-	props: {
-		randomness: {
-			default: .25,
-			description: "Randomness of particle animation",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .1,
-				label: "Randomness",
-				group: "Effect"
-			}
-		},
-		speed: {
-			default: .25,
-			description: "Speed of particle movement",
-			ui: {
-				type: "range",
-				min: 0,
-				max: 1,
-				step: .1,
-				label: "Speed",
-				group: "Animation"
-			}
-		},
-		angle: {
-			default: 90,
-			description: "Movement angle in degrees (0=right, 90=down, 180=left, 270=up)",
-			ui: {
-				type: "range",
-				min: 0,
-				max: 360,
-				step: 1,
-				label: "Angle",
-				group: "Animation"
-			}
-		},
-		particleSize: {
-			default: 2,
-			description: "Size of particles",
-			ui: {
-				type: ["range", "map"],
-				min: .1,
-				max: 20,
-				step: .1,
-				label: "Particle Size",
-				group: "Effect"
-			}
-		},
-		particleSoftness: {
-			default: 0,
-			description: "Edge softness of particles (0 = sharp, 1 = very soft)",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 5,
-				step: .1,
-				label: "Particle Softness",
-				group: "Effect"
-			}
-		},
-		twinkle: {
-			default: .5,
-			description: "Intensity of the twinkle effect (0 = off, 1 = full twinkle)",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .1,
-				label: "Twinkle",
-				group: "Animation"
-			}
-		},
-		count: {
-			default: 5,
-			description: "Number of particle layers",
-			ui: {
-				type: "range",
-				min: 1,
-				max: 5,
-				step: 1,
-				label: "Count",
-				group: "Effect"
-			}
-		},
-		particleColor: {
-			default: "#ffffff",
-			transform: transformColor,
-			description: "Color of the particles",
-			ui: {
-				type: "color",
-				label: "Particle Color",
-				group: "Colors"
-			}
-		},
-		speedVariance: {
-			default: .3,
-			description: "Per-layer speed variance (0 = all layers same speed, 1 = high variance)",
-			ui: {
-				type: "range",
-				min: 0,
-				max: 1,
-				step: .1,
-				label: "Speed Variance",
-				group: "Animation"
-			}
-		},
-		angleVariance: {
-			default: 30,
-			description: "Per-layer angle variance in degrees (0 = all layers same angle, 180 = full variance)",
-			ui: {
-				type: "range",
-				min: 0,
-				max: 180,
-				step: 1,
-				label: "Angle Variance",
-				group: "Animation"
-			}
-		},
-		particleDensity: {
-			default: 3,
-			description: "Particle density (lower = more spread out, higher = more dense)",
-			ui: {
-				type: "range",
-				min: .5,
-				max: 3,
-				step: .1,
-				label: "Particle Density",
-				group: "Effect"
-			}
-		}
-	},
-	compute: (params) => {
-		const { gpu, registerComputeTexture, getCpuValue, onCleanup } = params;
-		const root = gpu?.root;
-		if (!root) return null;
-		const outTex = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
-			size: [PARTICLE_TEX, PARTICLE_TEX],
-			format: STATE_FORMAT
-		}).$usage("storage", "sampled"), "outTex");
-		onCleanup(() => outTex.destroy());
-		const particleTexture = registerComputeTexture(outTex);
-		const paramsU = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(ParticleParams), "paramsU");
-		const bg = root.createBindGroup(particleLayout, {
-			params: paramsU.buffer,
-			outTex
-		});
-		const pass = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-			"use gpu";
-			particleKernel(cx, cy);
-		}), {
-			v: 1,
-			name: void 0,
-			ast: {
-				"params": [{
-					"type": "i",
-					"name": "cx"
-				}, {
-					"type": "i",
-					"name": "cy"
-				}],
-				"body": [0, [[
-					6,
-					"particleKernel",
-					["cx", "cy"]
-				]]],
-				"externalNames": ["particleKernel"]
-			},
-			externals: () => ({ particleKernel })
-		}) && $.f)({}), {
-			size: [PARTICLE_TEX, PARTICLE_TEX],
-			bindGroup: bg
-		});
-		let animTime = 0;
-		let frameTime = 0;
-		return {
-			outputs: { particleTexture },
-			getComputeNodes: (frameParams) => {
-				const fp = frameParams;
-				const dt = fp.deltaTime ?? 0;
-				animTime += dt * (getCpuValue("speed") ?? .25);
-				frameTime += dt;
-				const h = fp.dimensions?.height ?? 0;
-				const aspect = h > 0 ? (fp.dimensions?.width ?? 0) / h : 16 / 9;
-				const color = getCpuValue("particleColor");
-				paramsU.write({
-					randomness: getCpuValue("randomness") ?? .25,
-					particleSoftness: getCpuValue("particleSoftness") ?? 0,
-					particleSize: getCpuValue("particleSize") ?? 2,
-					twinkle: getCpuValue("twinkle") ?? .5,
-					count: getCpuValue("count") ?? 5,
-					angle: getCpuValue("angle") ?? 90,
-					speedVariance: getCpuValue("speedVariance") ?? .3,
-					angleVariance: getCpuValue("angleVariance") ?? 30,
-					particleDensity: getCpuValue("particleDensity") ?? 3,
-					color: d.vec3f(color?.x ?? 1, color?.y ?? 1, color?.z ?? 1),
-					animTime,
-					frameTime,
-					aspect
-				});
-				return [pass];
-			}
-		};
-	},
-	fragment: ({ ctx, childNode, computeOutputs }) => {
-		const particleField = computeOutputs?.particleTexture;
-		if (!particleField) return ZERO;
-		const px = 1 / PARTICLE_TEX;
-		const tap = (ox, oy) => particleField.sample(call(particleTapUV, "particleTapUV", [
-			ctx.uv,
-			floatE(ox),
-			floatE(oy)
-		]), "linearClamp");
-		const p = call(particleUpsample, "particleUpsample", [
-			particleField.sample(ctx.uv, "linearClamp"),
-			tap(px, 0),
-			tap(0, px),
-			tap(-px, 0),
-			tap(0, -px)
-		]);
-		if (childNode) return call(particleOverChild, "particleOverChild", [p, childNode]);
-		return p;
-	}
-};
-var FloatingParticles_default = componentDefinition;
-export { particleTapUV as a, particleOverChild as i, componentDefinition as n, particleUpsample as o, particleKernel as r, FloatingParticles_default as t };