shaders 2.5.134 → 3.0.436

package/dist/core/FloatingParticles-C_Te8jN0.js

@@ -0,0 +1,2582 @@
+import { At as call, B as createGuardedCompute, Ot as ZERO, Pt as floatE, R as std, n as tgpu, on as d } from "./coords-BxHv8WrA.js";
+import { a as transformColor } from "./transformations-fqzznt4g.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 };