shaders 3.1.463 → 3.2.465

package/dist/core/{sdf3d-B8EwGL7R.js → sdf3d-DQ55w9nI.js}

@@ -1,5 +1,5 @@
-import { Bt as size, Dt as sin, Et as sign, Ft as vec3f, Gt as textureStorage2d, Lt as vec4f, Mt as vec2f, Ot as smoothstep, Pt as vec2u, Wt as texture2d, _t as max, cn as i32, ct as clamp, dt as dot, et as typegpu_default, gt as length, hn as __export, it as abs, kt as sqrt, ln as u32, lt as cos, m as call, mt as floor, ot as atan2, qt as struct, rt as select, sn as f32, vt as min, yt as mix, zt as align } from "./edges-CV-BHMpI.js";
-import { I as textureLoad, M as createGuardedCompute, R as textureStore, c as createAnalyticSdfSampler, d as createSvgSdfSamplerWithGradients, i as SVG_SDF_SIZE, l as createSdfDataTexture, m as driveAnalyticSubProps, t as isMobileGpuViewport, u as createSvgSdfSampler } from "./device-DKcu50_C.js";
+import { $n as clamp, Ar as texture2d, Br as f32, C as createSvgSdfSamplerWithGradients, Cr as vec2u, Dr as align, E as driveAnalyticSubProps, G as createGuardedCompute, Hr as u32, Jn as select, Jr as __export, Mr as arrayOf, Nr as struct, Or as size, S as createSvgSdfSampler, Tr as vec4f, Un as textureStore, Vn as textureLoad, Vr as i32, Yn as abs, Zn as atan2, _r as smoothstep, ar as floor, b as createAnalyticSdfSampler, cr as max, dr as normalize, er as cos, g as SVG_SDF_SIZE, gr as sin, hr as sign, jr as textureStorage2d, lr as min, nr as dot, ot as call, sr as length, ur as mix, vr as sqrt, wr as vec3f, x as createSdfDataTexture, xr as vec2f, zn as typegpu_default } from "./lower-DSk_KxOY.js";
+import { t as isMobileGpuViewport } from "./device-m0ud8-Fn.js";
 var SVG_SDF_SIZE$1 = 512;
 var cache = {};
 var pending = /* @__PURE__ */ new Set();
@@ -213,6 +213,7 @@ const SHAPE3D_DEFAULTS$1 = {
 		rotZ: 0
 	},
 	metaballs3D: {
+		balls: 4,
 		ballRadius: .16,
 		spread: .2,
 		blend: .12,
@@ -469,6 +470,7 @@ function resolveShapeType(shapeType, shape) {
 }
 var sdf3d_exports = /* @__PURE__ */ __export({
 	HELIX_TURNS: () => 3,
+	MAX_METABALLS: () => 8,
 	MarchParams: () => MarchParams,
 	RotStruct: () => RotStruct,
 	SHAPE3D_DEFAULTS: () => SHAPE3D_DEFAULTS,
@@ -480,22 +482,33 @@ var sdf3d_exports = /* @__PURE__ */ __export({
 	VOLUMETRIC_FIELD_FORMAT: () => VOLUMETRIC_FIELD_FORMAT,
 	VOLUMETRIC_FIELD_RES: () => VOLUMETRIC_FIELD_RES,
 	VOLUMETRIC_FIELD_RES_MOBILE: () => 768,
+	boxFaceUV: () => boxFaceUV,
 	buildFieldSampleGraph: () => buildFieldSampleGraph,
 	buildFieldSampleGraphArgs: () => buildFieldSampleGraphArgs,
 	buildRaymarchedField: () => buildRaymarchedField,
 	buildRaymarchedFieldFn: () => buildRaymarchedFieldFn,
 	buildVolumetricFieldKernel: () => buildVolumetricFieldKernel,
 	buildVolumetricFieldSampler: () => buildVolumetricFieldSampler,
+	capsuleSurfaceUV: () => capsuleSurfaceUV,
 	createAnalytic3dSdfSetup: () => createAnalytic3dSdfSetup,
 	createSvg3dSdfSetup: () => createSvg3dSdfSetup,
 	createVolumetricFieldCompute: () => createVolumetricFieldCompute,
 	createVolumetricFieldComputeNode: () => createVolumetricFieldComputeNode,
+	eulerRotatePacked: () => eulerRotatePacked,
 	is3dShapeType: () => is3dShapeType,
 	isMobileGpuViewport: () => isMobileGpuViewport,
 	isSvg3dShapeType: () => isSvg3dShapeType,
 	isVolumetricShapeType: () => isVolumetricShapeType,
 	makeVolumetricFieldLayout: () => makeVolumetricFieldLayout,
 	makeVolumetricSvgFieldLayout: () => makeVolumetricSvgFieldLayout,
+	mobiusSurfaceUV: () => mobiusSurfaceUV,
+	packedParamExtraFields: () => packedParamExtraFields,
+	paramBoxSdf: () => paramBoxSdf,
+	paramCapsuleSdf: () => paramCapsuleSdf,
+	paramMobiusSdf: () => paramMobiusSdf,
+	paramSphereSdf: () => paramSphereSdf,
+	paramTorusSdf: () => paramTorusSdf,
+	paramTwistedRibbonSdf: () => paramTwistedRibbonSdf,
 	resolveActiveFieldRes: () => resolveActiveFieldRes,
 	resolveShapeFieldSampler: () => resolveShapeFieldSampler,
 	resolveShapeSubProp: () => resolveShapeSubProp,
@@ -525,7 +538,10 @@ var sdf3d_exports = /* @__PURE__ */ __export({
 	sdWobbleBlob: () => sdWobbleBlob,
 	shape3dBoundingRadius: () => shape3dBoundingRadius,
 	shapeSubPropMax: () => shapeSubPropMax,
-	smin: () => smin
+	smin: () => smin,
+	sphereSurfaceUV: () => sphereSurfaceUV,
+	torusSurfaceUV: () => torusSurfaceUV,
+	twistedRibbonSurfaceUV: () => twistedRibbonSurfaceUV
 });
 var PI = 3.141592653589793;
 var TWO_PI = 6.283185307179586;
@@ -749,6 +765,7 @@ const SHAPE3D_DEFAULTS = {
 		rotZ: 0
 	},
 	metaballs3D: {
+		balls: 4,
 		ballRadius: .16,
 		spread: .2,
 		blend: .12,
@@ -3377,7 +3394,13 @@ const sdHelix = typegpu_default.fn([
 		"std.max": () => max
 	}
 }) && $.f)({}));
+var MetaballArray = arrayOf(vec3f, 8);
+var METABALL_COUNT = 8;
 const sdMetaballs = typegpu_default.fn([
+	vec3f,
+	vec3f,
+	vec3f,
+	vec3f,
 	vec3f,
 	vec3f,
 	vec3f,
@@ -3385,12 +3408,19 @@ const sdMetaballs = typegpu_default.fn([
 	vec3f,
 	f32,
 	f32
-], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p, b0, b1, b2, b3, r, k) => {
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p, b0, b1, b2, b3, b4, b5, b6, b7, r, k) => {
 	"use gpu";
-	let dd = __tsover_sub(length(p.sub(b0)), r);
-	dd = smin(dd, __tsover_sub(length(p.sub(b1)), r), k);
-	dd = smin(dd, __tsover_sub(length(p.sub(b2)), r), k);
-	dd = smin(dd, __tsover_sub(length(p.sub(b3)), r), k);
+	const balls = MetaballArray();
+	balls[0] = vec3f(b0);
+	balls[1] = vec3f(b1);
+	balls[2] = vec3f(b2);
+	balls[3] = vec3f(b3);
+	balls[4] = vec3f(b4);
+	balls[5] = vec3f(b5);
+	balls[6] = vec3f(b6);
+	balls[7] = vec3f(b7);
+	let dd = __tsover_sub(length(p.sub(balls[0])), r);
+	for (let i = 1; i < METABALL_COUNT; i++) dd = smin(dd, __tsover_sub(length(p.sub(balls[i])), r), k);
 	return dd;
 }), {
 	v: 2,
@@ -3417,6 +3447,22 @@ const sdMetaballs = typegpu_default.fn([
 				"type": "i",
 				"name": "b3"
 			},
+			{
+				"type": "i",
+				"name": "b4"
+			},
+			{
+				"type": "i",
+				"name": "b5"
+			},
+			{
+				"type": "i",
+				"name": "b6"
+			},
+			{
+				"type": "i",
+				"name": "b7"
+			},
 			{
 				"type": "i",
 				"name": "r"
@@ -3427,6 +3473,127 @@ const sdMetaballs = typegpu_default.fn([
 			}
 		],
 		"body": [0, [
+			[
+				13,
+				"balls",
+				[
+					6,
+					"MetaballArray",
+					[]
+				]
+			],
+			[
+				2,
+				[
+					8,
+					"balls",
+					[5, "0"]
+				],
+				"=",
+				[
+					6,
+					"d.vec3f",
+					["b0"]
+				]
+			],
+			[
+				2,
+				[
+					8,
+					"balls",
+					[5, "1"]
+				],
+				"=",
+				[
+					6,
+					"d.vec3f",
+					["b1"]
+				]
+			],
+			[
+				2,
+				[
+					8,
+					"balls",
+					[5, "2"]
+				],
+				"=",
+				[
+					6,
+					"d.vec3f",
+					["b2"]
+				]
+			],
+			[
+				2,
+				[
+					8,
+					"balls",
+					[5, "3"]
+				],
+				"=",
+				[
+					6,
+					"d.vec3f",
+					["b3"]
+				]
+			],
+			[
+				2,
+				[
+					8,
+					"balls",
+					[5, "4"]
+				],
+				"=",
+				[
+					6,
+					"d.vec3f",
+					["b4"]
+				]
+			],
+			[
+				2,
+				[
+					8,
+					"balls",
+					[5, "5"]
+				],
+				"=",
+				[
+					6,
+					"d.vec3f",
+					["b5"]
+				]
+			],
+			[
+				2,
+				[
+					8,
+					"balls",
+					[5, "6"]
+				],
+				"=",
+				[
+					6,
+					"d.vec3f",
+					["b6"]
+				]
+			],
+			[
+				2,
+				[
+					8,
+					"balls",
+					[5, "7"]
+				],
+				"=",
+				[
+					6,
+					"d.vec3f",
+					["b7"]
+				]
+			],
 			[
 				12,
 				"dd",
@@ -3442,7 +3609,11 @@ const sdMetaballs = typegpu_default.fn([
 								"p",
 								"sub"
 							],
-							["b0"]
+							[[
+								8,
+								"balls",
+								[5, "0"]
+							]]
 						]]
 					],
 					"-",
@@ -3450,103 +3621,67 @@ const sdMetaballs = typegpu_default.fn([
 				]
 			],
 			[
-				2,
-				"dd",
-				"=",
+				14,
 				[
-					6,
-					"smin",
-					[
-						"dd",
-						[
-							1,
-							[
-								6,
-								"std.length",
-								[[
-									6,
-									[
-										7,
-										"p",
-										"sub"
-									],
-									["b1"]
-								]]
-							],
-							"-",
-							"r"
-						],
-						"k"
-					]
-				]
-			],
-			[
-				2,
-				"dd",
-				"=",
+					12,
+					"i",
+					[5, "1"]
+				],
 				[
-					6,
-					"smin",
-					[
-						"dd",
-						[
-							1,
-							[
-								6,
-								"std.length",
-								[[
-									6,
-									[
-										7,
-										"p",
-										"sub"
-									],
-									["b2"]
-								]]
-							],
-							"-",
-							"r"
-						],
-						"k"
-					]
-				]
-			],
-			[
-				2,
-				"dd",
-				"=",
+					1,
+					"i",
+					"<",
+					"METABALL_COUNT"
+				],
 				[
-					6,
-					"smin",
+					102,
+					"++",
+					"i"
+				],
+				[0, [[
+					2,
+					"dd",
+					"=",
 					[
-						"dd",
+						6,
+						"smin",
 						[
-							1,
+							"dd",
 							[
-								6,
-								"std.length",
-								[[
+								1,
+								[
 									6,
-									[
-										7,
-										"p",
-										"sub"
-									],
-									["b3"]
-								]]
+									"std.length",
+									[[
+										6,
+										[
+											7,
+											"p",
+											"sub"
+										],
+										[[
+											8,
+											"balls",
+											"i"
+										]]
+									]]
+								],
+								"-",
+								"r"
 							],
-							"-",
-							"r"
-						],
-						"k"
+							"k"
+						]
 					]
-				]
+				]]]
 			],
 			[10, "dd"]
 		]]
 	},
 	externals: {
+		"MetaballArray": () => MetaballArray,
+		"d.vec3f": () => vec3f,
 		"std.length": () => length,
+		"METABALL_COUNT": () => METABALL_COUNT,
 		"smin": () => smin
 	}
 }) && $.f)({}));
@@ -7081,7 +7216,11 @@ const MarchParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) =>
 	mb0: vec3f,
 	mb1: vec3f,
 	mb2: vec3f,
-	mb3: vec3f
+	mb3: vec3f,
+	mb4: vec3f,
+	mb5: vec3f,
+	mb6: vec3f,
+	mb7: vec3f
 }), "MarchParams");
 function makeVolumetricFieldLayout() {
 	return {
@@ -15409,7 +15548,7 @@ function createAnalytic3dSdfSetup(root, shapeType, initialConfig, getShapeConfig
 		else if (shapeType === "link3D") return sdLink(p, pp.pB, pp.pA, pp.pC);
 		else if (shapeType === "gem3D") return sdGem(p, pp.pA, pp.pB, pp.pC);
 		else if (shapeType === "helix3D") return sdHelix(p, pp.pA, pp.pB, pp.pC, f32(3));
-		else if (shapeType === "metaballs3D") return sdMetaballs(p, pp.mb0, pp.mb1, pp.mb2, pp.mb3, pp.pA, pp.pD);
+		else if (shapeType === "metaballs3D") return sdMetaballs(p, pp.mb0, pp.mb1, pp.mb2, pp.mb3, pp.mb4, pp.mb5, pp.mb6, pp.mb7, pp.pA, pp.pD);
 		else if (shapeType === "dodecahedron3D") return sdDodecahedron(p, pp.pA);
 		else if (shapeType === "hemisphere3D") return sdCutSphere(p, pp.pA, pp.pB);
 		else if (shapeType === "ribbon3D") return sdRibbon(p, pp.pA, pp.pB, pp.pC, pp.mb0.x, pp.mb0.y, pp.mb0.z, pp.mb1.x, pp.mb1.y, pp.mb1.z, pp.mb2.x);
@@ -15831,6 +15970,26 @@ function createAnalytic3dSdfSetup(root, shapeType, initialConfig, getShapeConfig
 																				"pp",
 																				"mb3"
 																			],
+																			[
+																				7,
+																				"pp",
+																				"mb4"
+																			],
+																			[
+																				7,
+																				"pp",
+																				"mb5"
+																			],
+																			[
+																				7,
+																				"pp",
+																				"mb6"
+																			],
+																			[
+																				7,
+																				"pp",
+																				"mb7"
+																			],
 																			[
 																				7,
 																				"pp",
@@ -16206,28 +16365,11 @@ function createAnalytic3dSdfSetup(root, shapeType, initialConfig, getShapeConfig
 	let cx = 1, sx = 0, cy = 1, sy = 0, cz = 1, sz = 0;
 	let spanX = 1, spanY = 1, originX = 0, originY = 0;
 	let activeRes = resolveVolumetricFieldRes();
-	const mb = [
-		[
-			0,
-			0,
-			0
-		],
-		[
-			0,
-			0,
-			0
-		],
-		[
-			0,
-			0,
-			0
-		],
-		[
-			0,
-			0,
-			0
-		]
-	];
+	const mb = Array.from({ length: 8 }, () => [
+		0,
+		0,
+		0
+	]);
 	const writeMarch = () => {
 		marchParamsBuffer.write({
 			rot: {
@@ -16251,7 +16393,11 @@ function createAnalytic3dSdfSetup(root, shapeType, initialConfig, getShapeConfig
 			mb0: vec3f(mb[0][0], mb[0][1], mb[0][2]),
 			mb1: vec3f(mb[1][0], mb[1][1], mb[1][2]),
 			mb2: vec3f(mb[2][0], mb[2][1], mb[2][2]),
-			mb3: vec3f(mb[3][0], mb[3][1], mb[3][2])
+			mb3: vec3f(mb[3][0], mb[3][1], mb[3][2]),
+			mb4: vec3f(mb[4][0], mb[4][1], mb[4][2]),
+			mb5: vec3f(mb[5][0], mb[5][1], mb[5][2]),
+			mb6: vec3f(mb[6][0], mb[6][1], mb[6][2]),
+			mb7: vec3f(mb[7][0], mb[7][1], mb[7][2])
 		});
 	};
 	const update = (frameParams) => {
@@ -16278,22 +16424,7 @@ function createAnalytic3dSdfSetup(root, shapeType, initialConfig, getShapeConfig
 		pB = .3;
 		pC = .3;
 		pD = 0;
-		mb[0] = [
-			0,
-			0,
-			0
-		];
-		mb[1] = [
-			0,
-			0,
-			0
-		];
-		mb[2] = [
-			0,
-			0,
-			0
-		];
-		mb[3] = [
+		for (let i = 0; i < mb.length; i++) mb[i] = [
 			0,
 			0,
 			0
@@ -16356,9 +16487,18 @@ function createAnalytic3dSdfSetup(root, shapeType, initialConfig, getShapeConfig
 				pA = sub("ballRadius");
 				pB = sub("spread");
 				pD = sub("blend");
+				const count = Math.min(8, Math.max(1, Math.round(sub("balls"))));
 				const sp = pB, tt = elapsed * sub("speed") * .6;
 				for (let i = 0; i < mb.length; i++) {
-					const phase = i * (Math.PI / 2);
+					if (i >= count) {
+						mb[i] = [
+							0,
+							99,
+							0
+						];
+						continue;
+					}
+					const phase = i * (TWO_PI / count);
 					const ang = phase + tt;
 					const wob = .75 + .25 * Math.sin(tt * 1.3 + i * 1.7);
 					mb[i] = [
@@ -17039,7 +17179,11 @@ function createSvg3dSdfSetup(params, shapeSdfUrl, getShapeConfig) {
 			mb0: vec3f(0, 0, 0),
 			mb1: vec3f(0, 0, 0),
 			mb2: vec3f(0, 0, 0),
-			mb3: vec3f(0, 0, 0)
+			mb3: vec3f(0, 0, 0),
+			mb4: vec3f(0, 0, 0),
+			mb5: vec3f(0, 0, 0),
+			mb6: vec3f(0, 0, 0),
+			mb7: vec3f(0, 0, 0)
 		});
 	};
 	const update = (frameParams) => {
@@ -17183,4 +17327,2931 @@ function createVolumetricFieldComputeNode(params, getShapeConfig, patternMode =
 		getFieldDomain: () => ({ ...domain })
 	};
 }
-export { SHAPE3D_DEFAULTS$1 as a, SVG3D_TYPES$1 as c, isVolumetricShapeType$1 as d, shape3dBoundingRadius$1 as f, shapeEffectBoundingBoxDeclaration as i, is3dShapeType$1 as l, sdf3d_exports as n, SHAPE3D_TYPES$1 as o, resolveShapeType as r, SVG3D_DEFAULTS$1 as s, VOLUMETRIC_FIELD_EXTRA_FIELDS as t, isSvg3dShapeType$1 as u };
+var TWISTED_RIBBON_TWIST_RATE = .08;
+const eulerRotatePacked = typegpu_default.fn([
+	vec3f,
+	vec4f,
+	vec4f
+], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p, rp0, rp1) => {
+	"use gpu";
+	const cx = rp0.x;
+	const sx = rp0.y;
+	const cy = rp0.z;
+	const sy = rp0.w;
+	const cz = rp1.x;
+	const sz = rp1.y;
+	const py = vec3f(__tsover_add(__tsover_mul(p.x, cy), __tsover_mul(p.z, sy)), p.y, __tsover_add(__tsover_mul(__tsover_mul(p.x, sy), -1), __tsover_mul(p.z, cy)));
+	const px = vec3f(py.x, __tsover_sub(__tsover_mul(py.y, cx), __tsover_mul(py.z, sx)), __tsover_add(__tsover_mul(py.y, sx), __tsover_mul(py.z, cx)));
+	return vec3f(__tsover_sub(__tsover_mul(px.x, cz), __tsover_mul(px.y, sz)), __tsover_add(__tsover_mul(px.x, sz), __tsover_mul(px.y, cz)), px.z);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "p"
+			},
+			{
+				"type": "i",
+				"name": "rp0"
+			},
+			{
+				"type": "i",
+				"name": "rp1"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"cx",
+				[
+					7,
+					"rp0",
+					"x"
+				]
+			],
+			[
+				13,
+				"sx",
+				[
+					7,
+					"rp0",
+					"y"
+				]
+			],
+			[
+				13,
+				"cy",
+				[
+					7,
+					"rp0",
+					"z"
+				]
+			],
+			[
+				13,
+				"sy",
+				[
+					7,
+					"rp0",
+					"w"
+				]
+			],
+			[
+				13,
+				"cz",
+				[
+					7,
+					"rp1",
+					"x"
+				]
+			],
+			[
+				13,
+				"sz",
+				[
+					7,
+					"rp1",
+					"y"
+				]
+			],
+			[
+				13,
+				"py",
+				[
+					6,
+					"d.vec3f",
+					[
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									"p",
+									"x"
+								],
+								"*",
+								"cy"
+							],
+							"+",
+							[
+								1,
+								[
+									7,
+									"p",
+									"z"
+								],
+								"*",
+								"sy"
+							]
+						],
+						[
+							7,
+							"p",
+							"y"
+						],
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									[
+										7,
+										"p",
+										"x"
+									],
+									"*",
+									"sy"
+								],
+								"*",
+								[
+									4,
+									"-",
+									[5, "1"]
+								]
+							],
+							"+",
+							[
+								1,
+								[
+									7,
+									"p",
+									"z"
+								],
+								"*",
+								"cy"
+							]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"px",
+				[
+					6,
+					"d.vec3f",
+					[
+						[
+							7,
+							"py",
+							"x"
+						],
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									"py",
+									"y"
+								],
+								"*",
+								"cx"
+							],
+							"-",
+							[
+								1,
+								[
+									7,
+									"py",
+									"z"
+								],
+								"*",
+								"sx"
+							]
+						],
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									"py",
+									"y"
+								],
+								"*",
+								"sx"
+							],
+							"+",
+							[
+								1,
+								[
+									7,
+									"py",
+									"z"
+								],
+								"*",
+								"cx"
+							]
+						]
+					]
+				]
+			],
+			[10, [
+				6,
+				"d.vec3f",
+				[
+					[
+						1,
+						[
+							1,
+							[
+								7,
+								"px",
+								"x"
+							],
+							"*",
+							"cz"
+						],
+						"-",
+						[
+							1,
+							[
+								7,
+								"px",
+								"y"
+							],
+							"*",
+							"sz"
+						]
+					],
+					[
+						1,
+						[
+							1,
+							[
+								7,
+								"px",
+								"x"
+							],
+							"*",
+							"sz"
+						],
+						"+",
+						[
+							1,
+							[
+								7,
+								"px",
+								"y"
+							],
+							"*",
+							"cz"
+						]
+					],
+					[
+						7,
+						"px",
+						"z"
+					]
+				]
+			]]
+		]]
+	},
+	externals: { "d.vec3f": () => vec3f }
+}) && $.f)({})).$name("eulerRotatePacked");
+const paramSphereSdf = typegpu_default.fn([
+	vec3f,
+	vec4f,
+	vec4f,
+	vec4f,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p, rp0, rp1, _rp2, _t) => {
+	"use gpu";
+	return __tsover_sub(length(eulerRotatePacked(p, rp0, rp1)), rp1.z);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "p"
+			},
+			{
+				"type": "i",
+				"name": "rp0"
+			},
+			{
+				"type": "i",
+				"name": "rp1"
+			},
+			{
+				"type": "i",
+				"name": "_rp2"
+			},
+			{
+				"type": "i",
+				"name": "_t"
+			}
+		],
+		"body": [0, [[10, [
+			1,
+			[
+				6,
+				"std.length",
+				[[
+					6,
+					"eulerRotatePacked",
+					[
+						"p",
+						"rp0",
+						"rp1"
+					]
+				]]
+			],
+			"-",
+			[
+				7,
+				"rp1",
+				"z"
+			]
+		]]]]
+	},
+	externals: {
+		"std.length": () => length,
+		"eulerRotatePacked": () => eulerRotatePacked
+	}
+}) && $.f)({})).$name("paramSphereSdf");
+const sphereSurfaceUV = typegpu_default.fn([
+	vec3f,
+	vec3f,
+	vec4f,
+	vec4f,
+	vec4f,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((h, _n, rp0, rp1, _rp2, _t) => {
+	"use gpu";
+	const n = normalize(eulerRotatePacked(h, rp0, rp1));
+	return vec2f(__tsover_add(__tsover_div(atan2(n.z, n.x), 6.283185307179586), .5), __tsover_mul(__tsover_add(n.y, 1), .5));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "h"
+			},
+			{
+				"type": "i",
+				"name": "_n"
+			},
+			{
+				"type": "i",
+				"name": "rp0"
+			},
+			{
+				"type": "i",
+				"name": "rp1"
+			},
+			{
+				"type": "i",
+				"name": "_rp2"
+			},
+			{
+				"type": "i",
+				"name": "_t"
+			}
+		],
+		"body": [0, [[
+			13,
+			"n",
+			[
+				6,
+				"std.normalize",
+				[[
+					6,
+					"eulerRotatePacked",
+					[
+						"h",
+						"rp0",
+						"rp1"
+					]
+				]]
+			]
+		], [10, [
+			6,
+			"d.vec2f",
+			[[
+				1,
+				[
+					1,
+					[
+						6,
+						"std.atan2",
+						[[
+							7,
+							"n",
+							"z"
+						], [
+							7,
+							"n",
+							"x"
+						]]
+					],
+					"/",
+					[5, "6.283185307179586"]
+				],
+				"+",
+				[5, "0.5"]
+			], [
+				1,
+				[
+					1,
+					[
+						7,
+						"n",
+						"y"
+					],
+					"+",
+					[5, "1"]
+				],
+				"*",
+				[5, "0.5"]
+			]]
+		]]]]
+	},
+	externals: {
+		"std.normalize": () => normalize,
+		"eulerRotatePacked": () => eulerRotatePacked,
+		"d.vec2f": () => vec2f,
+		"std.atan2": () => atan2
+	}
+}) && $.f)({})).$name("sphereSurfaceUV");
+const paramTorusSdf = typegpu_default.fn([
+	vec3f,
+	vec4f,
+	vec4f,
+	vec4f,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p, rp0, rp1, _rp2, _t) => {
+	"use gpu";
+	const rp = eulerRotatePacked(p, rp0, rp1);
+	const q = vec2f(__tsover_sub(length(vec2f(rp.x, rp.z)), rp1.z), rp.y);
+	return __tsover_sub(length(q), rp1.w);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "p"
+			},
+			{
+				"type": "i",
+				"name": "rp0"
+			},
+			{
+				"type": "i",
+				"name": "rp1"
+			},
+			{
+				"type": "i",
+				"name": "_rp2"
+			},
+			{
+				"type": "i",
+				"name": "_t"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"rp",
+				[
+					6,
+					"eulerRotatePacked",
+					[
+						"p",
+						"rp0",
+						"rp1"
+					]
+				]
+			],
+			[
+				13,
+				"q",
+				[
+					6,
+					"d.vec2f",
+					[[
+						1,
+						[
+							6,
+							"std.length",
+							[[
+								6,
+								"d.vec2f",
+								[[
+									7,
+									"rp",
+									"x"
+								], [
+									7,
+									"rp",
+									"z"
+								]]
+							]]
+						],
+						"-",
+						[
+							7,
+							"rp1",
+							"z"
+						]
+					], [
+						7,
+						"rp",
+						"y"
+					]]
+				]
+			],
+			[10, [
+				1,
+				[
+					6,
+					"std.length",
+					["q"]
+				],
+				"-",
+				[
+					7,
+					"rp1",
+					"w"
+				]
+			]]
+		]]
+	},
+	externals: {
+		"eulerRotatePacked": () => eulerRotatePacked,
+		"d.vec2f": () => vec2f,
+		"std.length": () => length
+	}
+}) && $.f)({})).$name("paramTorusSdf");
+const torusSurfaceUV = typegpu_default.fn([
+	vec3f,
+	vec3f,
+	vec4f,
+	vec4f,
+	vec4f,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((h, _n, rp0, rp1, _rp2, _t) => {
+	"use gpu";
+	const rp = eulerRotatePacked(h, rp0, rp1);
+	const u = __tsover_add(__tsover_div(atan2(rp.z, rp.x), 6.283185307179586), .5);
+	const ringDist = __tsover_sub(length(vec2f(rp.x, rp.z)), rp1.z);
+	return vec2f(u, __tsover_add(__tsover_div(atan2(rp.y, ringDist), 6.283185307179586), .5));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "h"
+			},
+			{
+				"type": "i",
+				"name": "_n"
+			},
+			{
+				"type": "i",
+				"name": "rp0"
+			},
+			{
+				"type": "i",
+				"name": "rp1"
+			},
+			{
+				"type": "i",
+				"name": "_rp2"
+			},
+			{
+				"type": "i",
+				"name": "_t"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"rp",
+				[
+					6,
+					"eulerRotatePacked",
+					[
+						"h",
+						"rp0",
+						"rp1"
+					]
+				]
+			],
+			[
+				13,
+				"u",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							"std.atan2",
+							[[
+								7,
+								"rp",
+								"z"
+							], [
+								7,
+								"rp",
+								"x"
+							]]
+						],
+						"/",
+						[5, "6.283185307179586"]
+					],
+					"+",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"ringDist",
+				[
+					1,
+					[
+						6,
+						"std.length",
+						[[
+							6,
+							"d.vec2f",
+							[[
+								7,
+								"rp",
+								"x"
+							], [
+								7,
+								"rp",
+								"z"
+							]]
+						]]
+					],
+					"-",
+					[
+						7,
+						"rp1",
+						"z"
+					]
+				]
+			],
+			[10, [
+				6,
+				"d.vec2f",
+				["u", [
+					1,
+					[
+						1,
+						[
+							6,
+							"std.atan2",
+							[[
+								7,
+								"rp",
+								"y"
+							], "ringDist"]
+						],
+						"/",
+						[5, "6.283185307179586"]
+					],
+					"+",
+					[5, "0.5"]
+				]]
+			]]
+		]]
+	},
+	externals: {
+		"eulerRotatePacked": () => eulerRotatePacked,
+		"std.atan2": () => atan2,
+		"std.length": () => length,
+		"d.vec2f": () => vec2f
+	}
+}) && $.f)({})).$name("torusSurfaceUV");
+const paramBoxSdf = typegpu_default.fn([
+	vec3f,
+	vec4f,
+	vec4f,
+	vec4f,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p, rp0, rp1, rp2, _t) => {
+	"use gpu";
+	const rp = eulerRotatePacked(p, rp0, rp1);
+	const rounding = rp2.y;
+	const qx = __tsover_add(__tsover_sub(abs(rp.x), rp1.z), rounding);
+	const qy = __tsover_add(__tsover_sub(abs(rp.y), rp1.w), rounding);
+	const qz = __tsover_add(__tsover_sub(abs(rp.z), rp2.x), rounding);
+	const outer = length(vec3f(max(qx, f32(0)), max(qy, f32(0)), max(qz, f32(0))));
+	const inner = min(max(qx, max(qy, qz)), f32(0));
+	return __tsover_sub(__tsover_add(outer, inner), rounding);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "p"
+			},
+			{
+				"type": "i",
+				"name": "rp0"
+			},
+			{
+				"type": "i",
+				"name": "rp1"
+			},
+			{
+				"type": "i",
+				"name": "rp2"
+			},
+			{
+				"type": "i",
+				"name": "_t"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"rp",
+				[
+					6,
+					"eulerRotatePacked",
+					[
+						"p",
+						"rp0",
+						"rp1"
+					]
+				]
+			],
+			[
+				13,
+				"rounding",
+				[
+					7,
+					"rp2",
+					"y"
+				]
+			],
+			[
+				13,
+				"qx",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							"std.abs",
+							[[
+								7,
+								"rp",
+								"x"
+							]]
+						],
+						"-",
+						[
+							7,
+							"rp1",
+							"z"
+						]
+					],
+					"+",
+					"rounding"
+				]
+			],
+			[
+				13,
+				"qy",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							"std.abs",
+							[[
+								7,
+								"rp",
+								"y"
+							]]
+						],
+						"-",
+						[
+							7,
+							"rp1",
+							"w"
+						]
+					],
+					"+",
+					"rounding"
+				]
+			],
+			[
+				13,
+				"qz",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							"std.abs",
+							[[
+								7,
+								"rp",
+								"z"
+							]]
+						],
+						"-",
+						[
+							7,
+							"rp2",
+							"x"
+						]
+					],
+					"+",
+					"rounding"
+				]
+			],
+			[
+				13,
+				"outer",
+				[
+					6,
+					"std.length",
+					[[
+						6,
+						"d.vec3f",
+						[
+							[
+								6,
+								"std.max",
+								["qx", [
+									6,
+									"d.f32",
+									[[5, "0"]]
+								]]
+							],
+							[
+								6,
+								"std.max",
+								["qy", [
+									6,
+									"d.f32",
+									[[5, "0"]]
+								]]
+							],
+							[
+								6,
+								"std.max",
+								["qz", [
+									6,
+									"d.f32",
+									[[5, "0"]]
+								]]
+							]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"inner",
+				[
+					6,
+					"std.min",
+					[[
+						6,
+						"std.max",
+						["qx", [
+							6,
+							"std.max",
+							["qy", "qz"]
+						]]
+					], [
+						6,
+						"d.f32",
+						[[5, "0"]]
+					]]
+				]
+			],
+			[10, [
+				1,
+				[
+					1,
+					"outer",
+					"+",
+					"inner"
+				],
+				"-",
+				"rounding"
+			]]
+		]]
+	},
+	externals: {
+		"eulerRotatePacked": () => eulerRotatePacked,
+		"std.abs": () => abs,
+		"std.length": () => length,
+		"d.vec3f": () => vec3f,
+		"std.max": () => max,
+		"d.f32": () => f32,
+		"std.min": () => min
+	}
+}) && $.f)({})).$name("paramBoxSdf");
+const boxFaceUV = typegpu_default.fn([
+	vec3f,
+	vec3f,
+	vec4f,
+	vec4f,
+	vec4f,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((h, n, rp0, rp1, rp2, _t) => {
+	"use gpu";
+	const rp = eulerRotatePacked(h, rp0, rp1);
+	const rn = eulerRotatePacked(n, rp0, rp1);
+	const an = vec3f(abs(rn.x), abs(rn.y), abs(rn.z));
+	const hx = rp1.z;
+	const hy = rp1.w;
+	const hz = rp2.x;
+	const scaleX = __tsover_div(.5, max(hy, hz));
+	const scaleY = __tsover_div(.5, max(hx, hz));
+	const scaleZ = __tsover_div(.5, max(hx, hy));
+	const uvX = vec2f(__tsover_add(__tsover_mul(rp.z, scaleX), .5), __tsover_add(__tsover_mul(rp.y, scaleX), .5));
+	const uvY = vec2f(__tsover_add(__tsover_mul(rp.x, scaleY), .5), __tsover_add(__tsover_mul(rp.z, scaleY), .5));
+	const uvZ = vec2f(__tsover_add(__tsover_mul(rp.x, scaleZ), .5), __tsover_add(__tsover_mul(rp.y, scaleZ), .5));
+	const pickXZ = select(uvZ, uvX, an.x > an.z);
+	return select(select(uvZ, uvY, an.y > an.z), pickXZ, an.x > an.y);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "h"
+			},
+			{
+				"type": "i",
+				"name": "n"
+			},
+			{
+				"type": "i",
+				"name": "rp0"
+			},
+			{
+				"type": "i",
+				"name": "rp1"
+			},
+			{
+				"type": "i",
+				"name": "rp2"
+			},
+			{
+				"type": "i",
+				"name": "_t"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"rp",
+				[
+					6,
+					"eulerRotatePacked",
+					[
+						"h",
+						"rp0",
+						"rp1"
+					]
+				]
+			],
+			[
+				13,
+				"rn",
+				[
+					6,
+					"eulerRotatePacked",
+					[
+						"n",
+						"rp0",
+						"rp1"
+					]
+				]
+			],
+			[
+				13,
+				"an",
+				[
+					6,
+					"d.vec3f",
+					[
+						[
+							6,
+							"std.abs",
+							[[
+								7,
+								"rn",
+								"x"
+							]]
+						],
+						[
+							6,
+							"std.abs",
+							[[
+								7,
+								"rn",
+								"y"
+							]]
+						],
+						[
+							6,
+							"std.abs",
+							[[
+								7,
+								"rn",
+								"z"
+							]]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"hx",
+				[
+					7,
+					"rp1",
+					"z"
+				]
+			],
+			[
+				13,
+				"hy",
+				[
+					7,
+					"rp1",
+					"w"
+				]
+			],
+			[
+				13,
+				"hz",
+				[
+					7,
+					"rp2",
+					"x"
+				]
+			],
+			[
+				13,
+				"scaleX",
+				[
+					1,
+					[5, "0.5"],
+					"/",
+					[
+						6,
+						"std.max",
+						["hy", "hz"]
+					]
+				]
+			],
+			[
+				13,
+				"scaleY",
+				[
+					1,
+					[5, "0.5"],
+					"/",
+					[
+						6,
+						"std.max",
+						["hx", "hz"]
+					]
+				]
+			],
+			[
+				13,
+				"scaleZ",
+				[
+					1,
+					[5, "0.5"],
+					"/",
+					[
+						6,
+						"std.max",
+						["hx", "hy"]
+					]
+				]
+			],
+			[
+				13,
+				"uvX",
+				[
+					6,
+					"d.vec2f",
+					[[
+						1,
+						[
+							1,
+							[
+								7,
+								"rp",
+								"z"
+							],
+							"*",
+							"scaleX"
+						],
+						"+",
+						[5, "0.5"]
+					], [
+						1,
+						[
+							1,
+							[
+								7,
+								"rp",
+								"y"
+							],
+							"*",
+							"scaleX"
+						],
+						"+",
+						[5, "0.5"]
+					]]
+				]
+			],
+			[
+				13,
+				"uvY",
+				[
+					6,
+					"d.vec2f",
+					[[
+						1,
+						[
+							1,
+							[
+								7,
+								"rp",
+								"x"
+							],
+							"*",
+							"scaleY"
+						],
+						"+",
+						[5, "0.5"]
+					], [
+						1,
+						[
+							1,
+							[
+								7,
+								"rp",
+								"z"
+							],
+							"*",
+							"scaleY"
+						],
+						"+",
+						[5, "0.5"]
+					]]
+				]
+			],
+			[
+				13,
+				"uvZ",
+				[
+					6,
+					"d.vec2f",
+					[[
+						1,
+						[
+							1,
+							[
+								7,
+								"rp",
+								"x"
+							],
+							"*",
+							"scaleZ"
+						],
+						"+",
+						[5, "0.5"]
+					], [
+						1,
+						[
+							1,
+							[
+								7,
+								"rp",
+								"y"
+							],
+							"*",
+							"scaleZ"
+						],
+						"+",
+						[5, "0.5"]
+					]]
+				]
+			],
+			[
+				13,
+				"pickXZ",
+				[
+					6,
+					"std.select",
+					[
+						"uvZ",
+						"uvX",
+						[
+							1,
+							[
+								7,
+								"an",
+								"x"
+							],
+							">",
+							[
+								7,
+								"an",
+								"z"
+							]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"pickYZ",
+				[
+					6,
+					"std.select",
+					[
+						"uvZ",
+						"uvY",
+						[
+							1,
+							[
+								7,
+								"an",
+								"y"
+							],
+							">",
+							[
+								7,
+								"an",
+								"z"
+							]
+						]
+					]
+				]
+			],
+			[10, [
+				6,
+				"std.select",
+				[
+					"pickYZ",
+					"pickXZ",
+					[
+						1,
+						[
+							7,
+							"an",
+							"x"
+						],
+						">",
+						[
+							7,
+							"an",
+							"y"
+						]
+					]
+				]
+			]]
+		]]
+	},
+	externals: {
+		"eulerRotatePacked": () => eulerRotatePacked,
+		"d.vec3f": () => vec3f,
+		"std.abs": () => abs,
+		"std.max": () => max,
+		"d.vec2f": () => vec2f,
+		"std.select": () => select
+	}
+}) && $.f)({})).$name("boxFaceUV");
+const paramCapsuleSdf = typegpu_default.fn([
+	vec3f,
+	vec4f,
+	vec4f,
+	vec4f,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p, rp0, rp1, _rp2, _t) => {
+	"use gpu";
+	const rp = eulerRotatePacked(p, rp0, rp1);
+	const radius = rp1.z;
+	const halfHeight = rp1.w;
+	const clampedY = clamp(rp.y, __tsover_mul(halfHeight, -1), halfHeight);
+	return __tsover_sub(length(vec3f(rp.x, __tsover_sub(rp.y, clampedY), rp.z)), radius);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "p"
+			},
+			{
+				"type": "i",
+				"name": "rp0"
+			},
+			{
+				"type": "i",
+				"name": "rp1"
+			},
+			{
+				"type": "i",
+				"name": "_rp2"
+			},
+			{
+				"type": "i",
+				"name": "_t"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"rp",
+				[
+					6,
+					"eulerRotatePacked",
+					[
+						"p",
+						"rp0",
+						"rp1"
+					]
+				]
+			],
+			[
+				13,
+				"radius",
+				[
+					7,
+					"rp1",
+					"z"
+				]
+			],
+			[
+				13,
+				"halfHeight",
+				[
+					7,
+					"rp1",
+					"w"
+				]
+			],
+			[
+				13,
+				"clampedY",
+				[
+					6,
+					"std.clamp",
+					[
+						[
+							7,
+							"rp",
+							"y"
+						],
+						[
+							1,
+							"halfHeight",
+							"*",
+							[
+								4,
+								"-",
+								[5, "1"]
+							]
+						],
+						"halfHeight"
+					]
+				]
+			],
+			[10, [
+				1,
+				[
+					6,
+					"std.length",
+					[[
+						6,
+						"d.vec3f",
+						[
+							[
+								7,
+								"rp",
+								"x"
+							],
+							[
+								1,
+								[
+									7,
+									"rp",
+									"y"
+								],
+								"-",
+								"clampedY"
+							],
+							[
+								7,
+								"rp",
+								"z"
+							]
+						]
+					]]
+				],
+				"-",
+				"radius"
+			]]
+		]]
+	},
+	externals: {
+		"eulerRotatePacked": () => eulerRotatePacked,
+		"std.clamp": () => clamp,
+		"std.length": () => length,
+		"d.vec3f": () => vec3f
+	}
+}) && $.f)({})).$name("paramCapsuleSdf");
+const capsuleSurfaceUV = typegpu_default.fn([
+	vec3f,
+	vec3f,
+	vec4f,
+	vec4f,
+	vec4f,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((h, _n, rp0, rp1, _rp2, _t) => {
+	"use gpu";
+	const rp = eulerRotatePacked(h, rp0, rp1);
+	const u = __tsover_add(__tsover_div(atan2(rp.z, rp.x), 6.283185307179586), .5);
+	const span = __tsover_add(rp1.w, rp1.z);
+	return vec2f(u, clamp(__tsover_add(__tsover_mul(__tsover_div(rp.y, span), .5), .5), 0, 1));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "h"
+			},
+			{
+				"type": "i",
+				"name": "_n"
+			},
+			{
+				"type": "i",
+				"name": "rp0"
+			},
+			{
+				"type": "i",
+				"name": "rp1"
+			},
+			{
+				"type": "i",
+				"name": "_rp2"
+			},
+			{
+				"type": "i",
+				"name": "_t"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"rp",
+				[
+					6,
+					"eulerRotatePacked",
+					[
+						"h",
+						"rp0",
+						"rp1"
+					]
+				]
+			],
+			[
+				13,
+				"u",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							"std.atan2",
+							[[
+								7,
+								"rp",
+								"z"
+							], [
+								7,
+								"rp",
+								"x"
+							]]
+						],
+						"/",
+						[5, "6.283185307179586"]
+					],
+					"+",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"span",
+				[
+					1,
+					[
+						7,
+						"rp1",
+						"w"
+					],
+					"+",
+					[
+						7,
+						"rp1",
+						"z"
+					]
+				]
+			],
+			[10, [
+				6,
+				"d.vec2f",
+				["u", [
+					6,
+					"std.clamp",
+					[
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									[
+										7,
+										"rp",
+										"y"
+									],
+									"/",
+									"span"
+								],
+								"*",
+								[5, "0.5"]
+							],
+							"+",
+							[5, "0.5"]
+						],
+						[5, "0"],
+						[5, "1"]
+					]
+				]]
+			]]
+		]]
+	},
+	externals: {
+		"eulerRotatePacked": () => eulerRotatePacked,
+		"std.atan2": () => atan2,
+		"d.vec2f": () => vec2f,
+		"std.clamp": () => clamp
+	}
+}) && $.f)({})).$name("capsuleSurfaceUV");
+const paramMobiusSdf = typegpu_default.fn([
+	vec3f,
+	vec4f,
+	vec4f,
+	vec4f,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p, rp0, rp1, rp2, _t) => {
+	"use gpu";
+	const rp = eulerRotatePacked(p, rp0, rp1);
+	const ringRadius = rp1.z;
+	const halfWidth = rp1.w;
+	const thickness = rp2.x;
+	const phi = atan2(rp.z, rp.x);
+	const spine = vec3f(__tsover_mul(cos(phi), ringRadius), 0, __tsover_mul(sin(phi), ringRadius));
+	const dvec = vec3f(__tsover_sub(rp.x, spine.x), __tsover_sub(rp.y, spine.y), __tsover_sub(rp.z, spine.z));
+	const halfPhi = __tsover_mul(phi, .5);
+	const ev = vec3f(__tsover_mul(cos(phi), cos(halfPhi)), sin(halfPhi), __tsover_mul(sin(phi), cos(halfPhi)));
+	const vProj = dot(dvec, ev);
+	const du = max(__tsover_sub(abs(vProj), halfWidth), f32(0));
+	const perp = vec3f(__tsover_sub(dvec.x, __tsover_mul(ev.x, vProj)), __tsover_sub(dvec.y, __tsover_mul(ev.y, vProj)), __tsover_sub(dvec.z, __tsover_mul(ev.z, vProj)));
+	return __tsover_sub(length(vec2f(du, length(perp))), thickness);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "p"
+			},
+			{
+				"type": "i",
+				"name": "rp0"
+			},
+			{
+				"type": "i",
+				"name": "rp1"
+			},
+			{
+				"type": "i",
+				"name": "rp2"
+			},
+			{
+				"type": "i",
+				"name": "_t"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"rp",
+				[
+					6,
+					"eulerRotatePacked",
+					[
+						"p",
+						"rp0",
+						"rp1"
+					]
+				]
+			],
+			[
+				13,
+				"ringRadius",
+				[
+					7,
+					"rp1",
+					"z"
+				]
+			],
+			[
+				13,
+				"halfWidth",
+				[
+					7,
+					"rp1",
+					"w"
+				]
+			],
+			[
+				13,
+				"thickness",
+				[
+					7,
+					"rp2",
+					"x"
+				]
+			],
+			[
+				13,
+				"phi",
+				[
+					6,
+					"std.atan2",
+					[[
+						7,
+						"rp",
+						"z"
+					], [
+						7,
+						"rp",
+						"x"
+					]]
+				]
+			],
+			[
+				13,
+				"spine",
+				[
+					6,
+					"d.vec3f",
+					[
+						[
+							1,
+							[
+								6,
+								"std.cos",
+								["phi"]
+							],
+							"*",
+							"ringRadius"
+						],
+						[5, "0"],
+						[
+							1,
+							[
+								6,
+								"std.sin",
+								["phi"]
+							],
+							"*",
+							"ringRadius"
+						]
+					]
+				]
+			],
+			[
+				13,
+				"dvec",
+				[
+					6,
+					"d.vec3f",
+					[
+						[
+							1,
+							[
+								7,
+								"rp",
+								"x"
+							],
+							"-",
+							[
+								7,
+								"spine",
+								"x"
+							]
+						],
+						[
+							1,
+							[
+								7,
+								"rp",
+								"y"
+							],
+							"-",
+							[
+								7,
+								"spine",
+								"y"
+							]
+						],
+						[
+							1,
+							[
+								7,
+								"rp",
+								"z"
+							],
+							"-",
+							[
+								7,
+								"spine",
+								"z"
+							]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"halfPhi",
+				[
+					1,
+					"phi",
+					"*",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"ev",
+				[
+					6,
+					"d.vec3f",
+					[
+						[
+							1,
+							[
+								6,
+								"std.cos",
+								["phi"]
+							],
+							"*",
+							[
+								6,
+								"std.cos",
+								["halfPhi"]
+							]
+						],
+						[
+							6,
+							"std.sin",
+							["halfPhi"]
+						],
+						[
+							1,
+							[
+								6,
+								"std.sin",
+								["phi"]
+							],
+							"*",
+							[
+								6,
+								"std.cos",
+								["halfPhi"]
+							]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"vProj",
+				[
+					6,
+					"std.dot",
+					["dvec", "ev"]
+				]
+			],
+			[
+				13,
+				"du",
+				[
+					6,
+					"std.max",
+					[[
+						1,
+						[
+							6,
+							"std.abs",
+							["vProj"]
+						],
+						"-",
+						"halfWidth"
+					], [
+						6,
+						"d.f32",
+						[[5, "0"]]
+					]]
+				]
+			],
+			[
+				13,
+				"perp",
+				[
+					6,
+					"d.vec3f",
+					[
+						[
+							1,
+							[
+								7,
+								"dvec",
+								"x"
+							],
+							"-",
+							[
+								1,
+								[
+									7,
+									"ev",
+									"x"
+								],
+								"*",
+								"vProj"
+							]
+						],
+						[
+							1,
+							[
+								7,
+								"dvec",
+								"y"
+							],
+							"-",
+							[
+								1,
+								[
+									7,
+									"ev",
+									"y"
+								],
+								"*",
+								"vProj"
+							]
+						],
+						[
+							1,
+							[
+								7,
+								"dvec",
+								"z"
+							],
+							"-",
+							[
+								1,
+								[
+									7,
+									"ev",
+									"z"
+								],
+								"*",
+								"vProj"
+							]
+						]
+					]
+				]
+			],
+			[10, [
+				1,
+				[
+					6,
+					"std.length",
+					[[
+						6,
+						"d.vec2f",
+						["du", [
+							6,
+							"std.length",
+							["perp"]
+						]]
+					]]
+				],
+				"-",
+				"thickness"
+			]]
+		]]
+	},
+	externals: {
+		"eulerRotatePacked": () => eulerRotatePacked,
+		"std.atan2": () => atan2,
+		"d.vec3f": () => vec3f,
+		"std.cos": () => cos,
+		"std.sin": () => sin,
+		"std.dot": () => dot,
+		"std.max": () => max,
+		"std.abs": () => abs,
+		"d.f32": () => f32,
+		"std.length": () => length,
+		"d.vec2f": () => vec2f
+	}
+}) && $.f)({})).$name("paramMobiusSdf");
+const mobiusSurfaceUV = typegpu_default.fn([
+	vec3f,
+	vec3f,
+	vec4f,
+	vec4f,
+	vec4f,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((h, _n, rp0, rp1, _rp2, _t) => {
+	"use gpu";
+	const rp = eulerRotatePacked(h, rp0, rp1);
+	const ringRadius = rp1.z;
+	const halfWidth = rp1.w;
+	const phi = atan2(rp.z, rp.x);
+	const spine = vec3f(__tsover_mul(cos(phi), ringRadius), 0, __tsover_mul(sin(phi), ringRadius));
+	const dvec = vec3f(__tsover_sub(rp.x, spine.x), __tsover_sub(rp.y, spine.y), __tsover_sub(rp.z, spine.z));
+	const halfPhi = __tsover_mul(phi, .5);
+	const vProj = dot(dvec, vec3f(__tsover_mul(cos(phi), cos(halfPhi)), sin(halfPhi), __tsover_mul(sin(phi), cos(halfPhi))));
+	return vec2f(__tsover_add(__tsover_div(phi, 6.283185307179586), .5), __tsover_add(__tsover_mul(__tsover_div(vProj, halfWidth), .5), .5));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "h"
+			},
+			{
+				"type": "i",
+				"name": "_n"
+			},
+			{
+				"type": "i",
+				"name": "rp0"
+			},
+			{
+				"type": "i",
+				"name": "rp1"
+			},
+			{
+				"type": "i",
+				"name": "_rp2"
+			},
+			{
+				"type": "i",
+				"name": "_t"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"rp",
+				[
+					6,
+					"eulerRotatePacked",
+					[
+						"h",
+						"rp0",
+						"rp1"
+					]
+				]
+			],
+			[
+				13,
+				"ringRadius",
+				[
+					7,
+					"rp1",
+					"z"
+				]
+			],
+			[
+				13,
+				"halfWidth",
+				[
+					7,
+					"rp1",
+					"w"
+				]
+			],
+			[
+				13,
+				"phi",
+				[
+					6,
+					"std.atan2",
+					[[
+						7,
+						"rp",
+						"z"
+					], [
+						7,
+						"rp",
+						"x"
+					]]
+				]
+			],
+			[
+				13,
+				"spine",
+				[
+					6,
+					"d.vec3f",
+					[
+						[
+							1,
+							[
+								6,
+								"std.cos",
+								["phi"]
+							],
+							"*",
+							"ringRadius"
+						],
+						[5, "0"],
+						[
+							1,
+							[
+								6,
+								"std.sin",
+								["phi"]
+							],
+							"*",
+							"ringRadius"
+						]
+					]
+				]
+			],
+			[
+				13,
+				"dvec",
+				[
+					6,
+					"d.vec3f",
+					[
+						[
+							1,
+							[
+								7,
+								"rp",
+								"x"
+							],
+							"-",
+							[
+								7,
+								"spine",
+								"x"
+							]
+						],
+						[
+							1,
+							[
+								7,
+								"rp",
+								"y"
+							],
+							"-",
+							[
+								7,
+								"spine",
+								"y"
+							]
+						],
+						[
+							1,
+							[
+								7,
+								"rp",
+								"z"
+							],
+							"-",
+							[
+								7,
+								"spine",
+								"z"
+							]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"halfPhi",
+				[
+					1,
+					"phi",
+					"*",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"ev",
+				[
+					6,
+					"d.vec3f",
+					[
+						[
+							1,
+							[
+								6,
+								"std.cos",
+								["phi"]
+							],
+							"*",
+							[
+								6,
+								"std.cos",
+								["halfPhi"]
+							]
+						],
+						[
+							6,
+							"std.sin",
+							["halfPhi"]
+						],
+						[
+							1,
+							[
+								6,
+								"std.sin",
+								["phi"]
+							],
+							"*",
+							[
+								6,
+								"std.cos",
+								["halfPhi"]
+							]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"vProj",
+				[
+					6,
+					"std.dot",
+					["dvec", "ev"]
+				]
+			],
+			[10, [
+				6,
+				"d.vec2f",
+				[[
+					1,
+					[
+						1,
+						"phi",
+						"/",
+						[5, "6.283185307179586"]
+					],
+					"+",
+					[5, "0.5"]
+				], [
+					1,
+					[
+						1,
+						[
+							1,
+							"vProj",
+							"/",
+							"halfWidth"
+						],
+						"*",
+						[5, "0.5"]
+					],
+					"+",
+					[5, "0.5"]
+				]]
+			]]
+		]]
+	},
+	externals: {
+		"eulerRotatePacked": () => eulerRotatePacked,
+		"std.atan2": () => atan2,
+		"d.vec3f": () => vec3f,
+		"std.cos": () => cos,
+		"std.sin": () => sin,
+		"std.dot": () => dot,
+		"d.vec2f": () => vec2f
+	}
+}) && $.f)({})).$name("mobiusSurfaceUV");
+const paramTwistedRibbonSdf = typegpu_default.fn([
+	vec3f,
+	vec4f,
+	vec4f,
+	vec4f,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p, rp0, rp1, _rp2, t) => {
+	"use gpu";
+	const angleRad = rp0.x;
+	const twist = rp0.y;
+	const halfW = rp0.z;
+	const thickness = rp1.x;
+	const phase = rp1.y;
+	const lipschitz = rp1.z;
+	const cosA = cos(angleRad);
+	const sinA = sin(angleRad);
+	const rpx = __tsover_add(__tsover_mul(p.x, cosA), __tsover_mul(p.y, sinA));
+	const rpy = __tsover_add(__tsover_mul(__tsover_mul(p.x, sinA), -1), __tsover_mul(p.y, cosA));
+	const twistAngle = __tsover_add(__tsover_add(__tsover_mul(rpx, twist), phase), __tsover_mul(t, TWISTED_RIBBON_TWIST_RATE));
+	const ca = cos(twistAngle);
+	const sa = sin(twistAngle);
+	const localU = __tsover_add(__tsover_mul(rpy, ca), __tsover_mul(p.z, sa));
+	const localV = __tsover_add(__tsover_mul(__tsover_mul(rpy, sa), -1), __tsover_mul(p.z, ca));
+	const du = max(__tsover_sub(abs(localU), halfW), f32(0));
+	return __tsover_div(__tsover_sub(length(vec2f(du, localV)), thickness), lipschitz);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "p"
+			},
+			{
+				"type": "i",
+				"name": "rp0"
+			},
+			{
+				"type": "i",
+				"name": "rp1"
+			},
+			{
+				"type": "i",
+				"name": "_rp2"
+			},
+			{
+				"type": "i",
+				"name": "t"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"angleRad",
+				[
+					7,
+					"rp0",
+					"x"
+				]
+			],
+			[
+				13,
+				"twist",
+				[
+					7,
+					"rp0",
+					"y"
+				]
+			],
+			[
+				13,
+				"halfW",
+				[
+					7,
+					"rp0",
+					"z"
+				]
+			],
+			[
+				13,
+				"thickness",
+				[
+					7,
+					"rp1",
+					"x"
+				]
+			],
+			[
+				13,
+				"phase",
+				[
+					7,
+					"rp1",
+					"y"
+				]
+			],
+			[
+				13,
+				"lipschitz",
+				[
+					7,
+					"rp1",
+					"z"
+				]
+			],
+			[
+				13,
+				"cosA",
+				[
+					6,
+					"std.cos",
+					["angleRad"]
+				]
+			],
+			[
+				13,
+				"sinA",
+				[
+					6,
+					"std.sin",
+					["angleRad"]
+				]
+			],
+			[
+				13,
+				"rpx",
+				[
+					1,
+					[
+						1,
+						[
+							7,
+							"p",
+							"x"
+						],
+						"*",
+						"cosA"
+					],
+					"+",
+					[
+						1,
+						[
+							7,
+							"p",
+							"y"
+						],
+						"*",
+						"sinA"
+					]
+				]
+			],
+			[
+				13,
+				"rpy",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								7,
+								"p",
+								"x"
+							],
+							"*",
+							"sinA"
+						],
+						"*",
+						[
+							4,
+							"-",
+							[5, "1"]
+						]
+					],
+					"+",
+					[
+						1,
+						[
+							7,
+							"p",
+							"y"
+						],
+						"*",
+						"cosA"
+					]
+				]
+			],
+			[
+				13,
+				"twistAngle",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							"rpx",
+							"*",
+							"twist"
+						],
+						"+",
+						"phase"
+					],
+					"+",
+					[
+						1,
+						"t",
+						"*",
+						"TWISTED_RIBBON_TWIST_RATE"
+					]
+				]
+			],
+			[
+				13,
+				"ca",
+				[
+					6,
+					"std.cos",
+					["twistAngle"]
+				]
+			],
+			[
+				13,
+				"sa",
+				[
+					6,
+					"std.sin",
+					["twistAngle"]
+				]
+			],
+			[
+				13,
+				"localU",
+				[
+					1,
+					[
+						1,
+						"rpy",
+						"*",
+						"ca"
+					],
+					"+",
+					[
+						1,
+						[
+							7,
+							"p",
+							"z"
+						],
+						"*",
+						"sa"
+					]
+				]
+			],
+			[
+				13,
+				"localV",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							"rpy",
+							"*",
+							"sa"
+						],
+						"*",
+						[
+							4,
+							"-",
+							[5, "1"]
+						]
+					],
+					"+",
+					[
+						1,
+						[
+							7,
+							"p",
+							"z"
+						],
+						"*",
+						"ca"
+					]
+				]
+			],
+			[
+				13,
+				"du",
+				[
+					6,
+					"std.max",
+					[[
+						1,
+						[
+							6,
+							"std.abs",
+							["localU"]
+						],
+						"-",
+						"halfW"
+					], [
+						6,
+						"d.f32",
+						[[5, "0"]]
+					]]
+				]
+			],
+			[10, [
+				1,
+				[
+					1,
+					[
+						6,
+						"std.length",
+						[[
+							6,
+							"d.vec2f",
+							["du", "localV"]
+						]]
+					],
+					"-",
+					"thickness"
+				],
+				"/",
+				"lipschitz"
+			]]
+		]]
+	},
+	externals: {
+		"std.cos": () => cos,
+		"std.sin": () => sin,
+		"TWISTED_RIBBON_TWIST_RATE": () => TWISTED_RIBBON_TWIST_RATE,
+		"std.max": () => max,
+		"std.abs": () => abs,
+		"d.f32": () => f32,
+		"std.length": () => length,
+		"d.vec2f": () => vec2f
+	}
+}) && $.f)({})).$name("paramTwistedRibbonSdf");
+const twistedRibbonSurfaceUV = typegpu_default.fn([
+	vec3f,
+	vec3f,
+	vec4f,
+	vec4f,
+	vec4f,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((h, _n, rp0, rp1, _rp2, t) => {
+	"use gpu";
+	const angleRad = rp0.x;
+	const twist = rp0.y;
+	const halfW = rp0.z;
+	const width = rp0.w;
+	const phase = rp1.y;
+	const cosA = cos(angleRad);
+	const sinA = sin(angleRad);
+	const rpx = __tsover_add(__tsover_mul(h.x, cosA), __tsover_mul(h.y, sinA));
+	const rpy = __tsover_add(__tsover_mul(__tsover_mul(h.x, sinA), -1), __tsover_mul(h.y, cosA));
+	const twistAngle = __tsover_add(__tsover_add(__tsover_mul(rpx, twist), phase), __tsover_mul(t, TWISTED_RIBBON_TWIST_RATE));
+	const ca = cos(twistAngle);
+	const sa = sin(twistAngle);
+	const localUClamped = max(min(__tsover_add(__tsover_mul(rpy, ca), __tsover_mul(h.z, sa)), halfW), __tsover_mul(halfW, -1));
+	return vec2f(__tsover_add(__tsover_mul(rpx, .15), .5), __tsover_add(__tsover_div(localUClamped, width), .5));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "h"
+			},
+			{
+				"type": "i",
+				"name": "_n"
+			},
+			{
+				"type": "i",
+				"name": "rp0"
+			},
+			{
+				"type": "i",
+				"name": "rp1"
+			},
+			{
+				"type": "i",
+				"name": "_rp2"
+			},
+			{
+				"type": "i",
+				"name": "t"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"angleRad",
+				[
+					7,
+					"rp0",
+					"x"
+				]
+			],
+			[
+				13,
+				"twist",
+				[
+					7,
+					"rp0",
+					"y"
+				]
+			],
+			[
+				13,
+				"halfW",
+				[
+					7,
+					"rp0",
+					"z"
+				]
+			],
+			[
+				13,
+				"width",
+				[
+					7,
+					"rp0",
+					"w"
+				]
+			],
+			[
+				13,
+				"phase",
+				[
+					7,
+					"rp1",
+					"y"
+				]
+			],
+			[
+				13,
+				"cosA",
+				[
+					6,
+					"std.cos",
+					["angleRad"]
+				]
+			],
+			[
+				13,
+				"sinA",
+				[
+					6,
+					"std.sin",
+					["angleRad"]
+				]
+			],
+			[
+				13,
+				"rpx",
+				[
+					1,
+					[
+						1,
+						[
+							7,
+							"h",
+							"x"
+						],
+						"*",
+						"cosA"
+					],
+					"+",
+					[
+						1,
+						[
+							7,
+							"h",
+							"y"
+						],
+						"*",
+						"sinA"
+					]
+				]
+			],
+			[
+				13,
+				"rpy",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								7,
+								"h",
+								"x"
+							],
+							"*",
+							"sinA"
+						],
+						"*",
+						[
+							4,
+							"-",
+							[5, "1"]
+						]
+					],
+					"+",
+					[
+						1,
+						[
+							7,
+							"h",
+							"y"
+						],
+						"*",
+						"cosA"
+					]
+				]
+			],
+			[
+				13,
+				"twistAngle",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							"rpx",
+							"*",
+							"twist"
+						],
+						"+",
+						"phase"
+					],
+					"+",
+					[
+						1,
+						"t",
+						"*",
+						"TWISTED_RIBBON_TWIST_RATE"
+					]
+				]
+			],
+			[
+				13,
+				"ca",
+				[
+					6,
+					"std.cos",
+					["twistAngle"]
+				]
+			],
+			[
+				13,
+				"sa",
+				[
+					6,
+					"std.sin",
+					["twistAngle"]
+				]
+			],
+			[
+				13,
+				"localU",
+				[
+					1,
+					[
+						1,
+						"rpy",
+						"*",
+						"ca"
+					],
+					"+",
+					[
+						1,
+						[
+							7,
+							"h",
+							"z"
+						],
+						"*",
+						"sa"
+					]
+				]
+			],
+			[
+				13,
+				"localUClamped",
+				[
+					6,
+					"std.max",
+					[[
+						6,
+						"std.min",
+						["localU", "halfW"]
+					], [
+						1,
+						"halfW",
+						"*",
+						[
+							4,
+							"-",
+							[5, "1"]
+						]
+					]]
+				]
+			],
+			[10, [
+				6,
+				"d.vec2f",
+				[[
+					1,
+					[
+						1,
+						"rpx",
+						"*",
+						[5, "0.15"]
+					],
+					"+",
+					[5, "0.5"]
+				], [
+					1,
+					[
+						1,
+						"localUClamped",
+						"/",
+						"width"
+					],
+					"+",
+					[5, "0.5"]
+				]]
+			]]
+		]]
+	},
+	externals: {
+		"std.cos": () => cos,
+		"std.sin": () => sin,
+		"TWISTED_RIBBON_TWIST_RATE": () => TWISTED_RIBBON_TWIST_RATE,
+		"std.max": () => max,
+		"std.min": () => min,
+		"d.vec2f": () => vec2f
+	}
+}) && $.f)({})).$name("twistedRibbonSurfaceUV");
+function packedParamExtraFields(prefix, initials) {
+	const out = {};
+	initials.forEach((initial, i) => {
+		out[`${prefix}${i}`] = {
+			schema: vec4f,
+			initial
+		};
+	});
+	return out;
+}
+export { SVG3D_TYPES$1 as C, shape3dBoundingRadius$1 as D, isVolumetricShapeType$1 as E, SVG3D_DEFAULTS$1 as S, isSvg3dShapeType$1 as T, twistedRibbonSurfaceUV as _, packedParamExtraFields as a, SHAPE3D_DEFAULTS$1 as b, paramMobiusSdf as c, paramTwistedRibbonSdf as d, rotateVec3 as f, torusSurfaceUV as g, sphereSurfaceUV as h, mobiusSurfaceUV as i, paramSphereSdf as l, sdf3d_exports as m, buildFieldSampleGraphArgs as n, paramBoxSdf as o, rotateVecCpu as p, capsuleSurfaceUV as r, paramCapsuleSdf as s, boxFaceUV as t, paramTorusSdf as u, resolveShapeType as v, is3dShapeType$1 as w, SHAPE3D_TYPES$1 as x, shapeEffectBoundingBoxDeclaration as y };