shaders 3.2.464 → 3.2.465

package/dist/core/{noisePaints-Cs2Q1Xk9.js → noisePaints-DV5jKo1A.js}

@@ -1,7 +1,6 @@
-import { $n as vec4f, En as cos, Fn as min, Gn as sqrt, In as mix, Jn as vec2f, Mn as fract, Nn as length, On as dot, Pn as max, Rn as pow, Tn as clamp, Un as sin, Vn as round, Wn as smoothstep, Wt as fbmGated, Xt as aspectOf, Zn as vec3f, bn as select, gr as i32, hr as f32, in as DEG_TO_RAD, jn as floor, kn as exp, ln as TAU, mn as typegpu_default, or as arrayOf, sn as PI, xn as abs } from "./lower-z2vuXP8M.js";
-import { d as mxNoiseFloat2, m as paper12, n as curl22, r as curl22z } from "./noise-B3Oq1k3_.js";
-import { i as toneRemap } from "./tone-BA0D_veZ.js";
-import { ht as gradientStopsInSpace, mt as MAX_COLOR_STOPS } from "./porters-B1UjrM1y.js";
+import { $n as clamp, An as DEG_TO_RAD, Br as f32, Jn as select, Kt as fbmGated, Mn as PI, Mr as arrayOf, Pn as TAU, Tr as vec4f, Vr as i32, Yn as abs, _r as smoothstep, ar as floor, cr as max, en as aspectOf, er as cos, fr as pow, gr as sin, ln as curl22, lr as min, mr as round, nr as dot, or as fract, rr as exp, sr as length, un as curl22z, ur as mix, vn as mxNoiseFloat2, vr as sqrt, wr as vec3f, xn as paper12, xr as vec2f, zn as typegpu_default } from "./lower-DSk_KxOY.js";
+import { a as toneRemap } from "./tone-Ax72n2WU.js";
+import { Et as gradientStopsInSpace, wt as MAX_COLOR_STOPS } from "./porters-j4QbEOqj.js";
 const cellHash2 = typegpu_default.fn([vec2f], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p) => {
 	"use gpu";
 	return fract(sin(vec2f(dot(p, vec2f(127.1, 311.7)), dot(p, vec2f(269.5, 183.3)))).mul(43758.5453));
@@ -2161,16 +2160,62 @@ const cellBorders = typegpu_default.fn([
 	},
 	externals: { "cellEdgeMask": () => cellEdgeMask }
 }) && $.f)({}));
-const marbleTurbulence = typegpu_default.fn([
+const toneLift = typegpu_default.fn([vec3f], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((rgb) => {
+	"use gpu";
+	return pow(rgb, vec3f(.85, .85, .85));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "rgb"
+		}],
+		"body": [0, [[10, [
+			6,
+			"std.pow",
+			["rgb", [
+				6,
+				"d.vec3f",
+				[
+					[5, "0.85"],
+					[5, "0.85"],
+					[5, "0.85"]
+				]
+			]]
+		]]]]
+	},
+	externals: {
+		"std.pow": () => pow,
+		"d.vec3f": () => vec3f
+	}
+}) && $.f)({}));
+var MAX = 8;
+if (8 !== MAX) throw new Error(`noisePaints: MAX (${MAX}) out of sync with MAX_COLOR_STOPS (8)`);
+const ribbonPathFrame = typegpu_default.fn([
+	vec2f,
+	vec2f,
+	vec2f,
 	vec2f,
-	f32,
 	f32
-], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((pos, seed, animTime) => {
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, start, end, pinFlag) => {
 	"use gpu";
-	const n1 = mxNoiseFloat2(vec2f(__tsover_add(pos.x, seed), __tsover_add(pos.y, animTime)));
-	const n2 = __tsover_mul(mxNoiseFloat2(vec2f(__tsover_add(__tsover_mul(pos.x, 2), __tsover_mul(seed, 1.7)), __tsover_add(__tsover_mul(pos.y, 2), __tsover_mul(animTime, .7)))), .5);
-	const n3 = __tsover_mul(mxNoiseFloat2(vec2f(__tsover_add(__tsover_mul(pos.x, 4), __tsover_mul(seed, 3.1)), __tsover_add(__tsover_mul(pos.y, 4), __tsover_mul(animTime, 1.3)))), .25);
-	return __tsover_add(__tsover_add(n1, n2), n3);
+	const aspectRatio = __tsover_div(viewport.x, max(viewport.y, 1e-6));
+	const startPos = vec2f(__tsover_mul(start.x, aspectRatio), __tsover_sub(1, start.y));
+	const endPos = vec2f(__tsover_mul(end.x, aspectRatio), __tsover_sub(1, end.y));
+	const aspectUV = vec2f(__tsover_mul(uv.x, aspectRatio), uv.y);
+	const direction = vec2f(__tsover_sub(endPos.x, startPos.x), __tsover_sub(endPos.y, startPos.y));
+	const len = max(length(direction), 1e-6);
+	const normalizedDir = vec2f(__tsover_div(direction.x, len), __tsover_div(direction.y, len));
+	const perpDir = vec2f(-normalizedDir.y, normalizedDir.x);
+	const relativePos = vec2f(__tsover_sub(aspectUV.x, startPos.x), __tsover_sub(aspectUV.y, startPos.y));
+	const progress = __tsover_div(dot(relativePos, normalizedDir), len);
+	const perpDist = dot(relativePos, perpDir);
+	const pinOn = pinFlag > 0;
+	const clampedProg = clamp(progress, 0, 1);
+	const pinch = select(f32(1), sin(__tsover_mul(clampedProg, PI)), pinOn);
+	const fade = __tsover_mul(smoothstep(0, .06, progress), __tsover_sub(1, smoothstep(.94, 1, progress)));
+	return vec4f(progress, perpDist, pinch, select(f32(1), fade, pinOn));
 }), {
 	v: 2,
 	name: void 0,
@@ -2178,405 +2223,402 @@ const marbleTurbulence = typegpu_default.fn([
 		"params": [
 			{
 				"type": "i",
-				"name": "pos"
+				"name": "uv"
 			},
 			{
 				"type": "i",
-				"name": "seed"
+				"name": "viewport"
 			},
 			{
 				"type": "i",
-				"name": "animTime"
+				"name": "start"
+			},
+			{
+				"type": "i",
+				"name": "end"
+			},
+			{
+				"type": "i",
+				"name": "pinFlag"
 			}
 		],
 		"body": [0, [
 			[
 				13,
-				"n1",
+				"aspectRatio",
+				[
+					1,
+					[
+						7,
+						"viewport",
+						"x"
+					],
+					"/",
+					[
+						6,
+						"std.max",
+						[[
+							7,
+							"viewport",
+							"y"
+						], [5, "0.000001"]]
+					]
+				]
+			],
+			[
+				13,
+				"startPos",
+				[
+					6,
+					"d.vec2f",
+					[[
+						1,
+						[
+							7,
+							"start",
+							"x"
+						],
+						"*",
+						"aspectRatio"
+					], [
+						1,
+						[5, "1"],
+						"-",
+						[
+							7,
+							"start",
+							"y"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"endPos",
 				[
 					6,
-					"mxNoiseFloat2",
+					"d.vec2f",
+					[[
+						1,
+						[
+							7,
+							"end",
+							"x"
+						],
+						"*",
+						"aspectRatio"
+					], [
+						1,
+						[5, "1"],
+						"-",
+						[
+							7,
+							"end",
+							"y"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"aspectUV",
+				[
+					6,
+					"d.vec2f",
+					[[
+						1,
+						[
+							7,
+							"uv",
+							"x"
+						],
+						"*",
+						"aspectRatio"
+					], [
+						7,
+						"uv",
+						"y"
+					]]
+				]
+			],
+			[
+				13,
+				"direction",
+				[
+					6,
+					"d.vec2f",
+					[[
+						1,
+						[
+							7,
+							"endPos",
+							"x"
+						],
+						"-",
+						[
+							7,
+							"startPos",
+							"x"
+						]
+					], [
+						1,
+						[
+							7,
+							"endPos",
+							"y"
+						],
+						"-",
+						[
+							7,
+							"startPos",
+							"y"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"len",
+				[
+					6,
+					"std.max",
 					[[
 						6,
-						"d.vec2f",
-						[[
-							1,
-							[
-								7,
-								"pos",
-								"x"
-							],
-							"+",
-							"seed"
-						], [
-							1,
-							[
-								7,
-								"pos",
-								"y"
-							],
-							"+",
-							"animTime"
-						]]
+						"std.length",
+						["direction"]
+					], [5, "0.000001"]]
+				]
+			],
+			[
+				13,
+				"normalizedDir",
+				[
+					6,
+					"d.vec2f",
+					[[
+						1,
+						[
+							7,
+							"direction",
+							"x"
+						],
+						"/",
+						"len"
+					], [
+						1,
+						[
+							7,
+							"direction",
+							"y"
+						],
+						"/",
+						"len"
+					]]
+				]
+			],
+			[
+				13,
+				"perpDir",
+				[
+					6,
+					"d.vec2f",
+					[[
+						4,
+						"-",
+						[
+							7,
+							"normalizedDir",
+							"y"
+						]
+					], [
+						7,
+						"normalizedDir",
+						"x"
+					]]
+				]
+			],
+			[
+				13,
+				"relativePos",
+				[
+					6,
+					"d.vec2f",
+					[[
+						1,
+						[
+							7,
+							"aspectUV",
+							"x"
+						],
+						"-",
+						[
+							7,
+							"startPos",
+							"x"
+						]
+					], [
+						1,
+						[
+							7,
+							"aspectUV",
+							"y"
+						],
+						"-",
+						[
+							7,
+							"startPos",
+							"y"
+						]
 					]]
 				]
 			],
 			[
 				13,
-				"n2",
+				"progress",
 				[
 					1,
 					[
 						6,
-						"mxNoiseFloat2",
-						[[
-							6,
-							"d.vec2f",
-							[[
-								1,
-								[
-									1,
-									[
-										7,
-										"pos",
-										"x"
-									],
-									"*",
-									[5, "2"]
-								],
-								"+",
-								[
-									1,
-									"seed",
-									"*",
-									[5, "1.7"]
-								]
-							], [
-								1,
-								[
-									1,
-									[
-										7,
-										"pos",
-										"y"
-									],
-									"*",
-									[5, "2"]
-								],
-								"+",
-								[
-									1,
-									"animTime",
-									"*",
-									[5, "0.7"]
-								]
-							]]
-						]]
+						"std.dot",
+						["relativePos", "normalizedDir"]
 					],
-					"*",
-					[5, "0.5"]
+					"/",
+					"len"
 				]
 			],
 			[
 				13,
-				"n3",
+				"perpDist",
 				[
-					1,
-					[
-						6,
-						"mxNoiseFloat2",
-						[[
-							6,
-							"d.vec2f",
-							[[
-								1,
-								[
-									1,
-									[
-										7,
-										"pos",
-										"x"
-									],
-									"*",
-									[5, "4"]
-								],
-								"+",
-								[
-									1,
-									"seed",
-									"*",
-									[5, "3.1"]
-								]
-							], [
-								1,
-								[
-									1,
-									[
-										7,
-										"pos",
-										"y"
-									],
-									"*",
-									[5, "4"]
-								],
-								"+",
-								[
-									1,
-									"animTime",
-									"*",
-									[5, "1.3"]
-								]
-							]]
-						]]
-					],
-					"*",
-					[5, "0.25"]
+					6,
+					"std.dot",
+					["relativePos", "perpDir"]
 				]
 			],
-			[10, [
-				1,
-				[
-					1,
-					"n1",
-					"+",
-					"n2"
-				],
-				"+",
-				"n3"
-			]]
-		]]
-	},
-	externals: {
-		"mxNoiseFloat2": () => mxNoiseFloat2,
-		"d.vec2f": () => vec2f
-	}
-}) && $.f)({}));
-const veinWave = typegpu_default.fn([
-	f32,
-	f32,
-	f32
-], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x, turb, turbulence) => {
-	"use gpu";
-	const marbleCoord = __tsover_add(__tsover_mul(x, PI), __tsover_mul(turb, turbulence));
-	return __tsover_add(__tsover_mul(sin(marbleCoord), .5), .5);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "x"
-			},
-			{
-				"type": "i",
-				"name": "turb"
-			},
-			{
-				"type": "i",
-				"name": "turbulence"
-			}
-		],
-		"body": [0, [[
-			13,
-			"marbleCoord",
 			[
-				1,
-				[
-					1,
-					"x",
-					"*",
-					"PI"
-				],
-				"+",
+				13,
+				"pinOn",
 				[
 					1,
-					"turb",
-					"*",
-					"turbulence"
+					"pinFlag",
+					">",
+					[5, "0"]
 				]
-			]
-		], [10, [
-			1,
+			],
 			[
-				1,
+				13,
+				"clampedProg",
 				[
 					6,
-					"std.sin",
-					["marbleCoord"]
-				],
-				"*",
-				[5, "0.5"]
+					"std.clamp",
+					[
+						"progress",
+						[5, "0"],
+						[5, "1"]
+					]
+				]
 			],
-			"+",
-			[5, "0.5"]
-		]]]]
-	},
-	externals: {
-		"PI": () => PI,
-		"std.sin": () => sin
-	}
-}) && $.f)({}));
-const veinDepth = typegpu_default.fn([vec2f, f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((pos, seed) => {
-	"use gpu";
-	return __tsover_add(__tsover_mul(mxNoiseFloat2(vec2f(__tsover_add(__tsover_mul(pos.y, 1.5), __tsover_mul(seed, 2)), __tsover_mul(pos.x, 1.2))), .3), .5);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "pos"
-		}, {
-			"type": "i",
-			"name": "seed"
-		}],
-		"body": [0, [[10, [
-			1,
 			[
-				1,
+				13,
+				"pinch",
 				[
 					6,
-					"mxNoiseFloat2",
-					[[
-						6,
-						"d.vec2f",
-						[[
-							1,
-							[
-								1,
-								[
-									7,
-									"pos",
-									"y"
-								],
-								"*",
-								[5, "1.5"]
-							],
-							"+",
-							[
+					"std.select",
+					[
+						[
+							6,
+							"d.f32",
+							[[5, "1"]]
+						],
+						[
+							6,
+							"std.sin",
+							[[
 								1,
-								"seed",
+								"clampedProg",
 								"*",
-								[5, "2"]
-							]
-						], [
-							1,
-							[
-								7,
-								"pos",
-								"x"
-							],
-							"*",
-							[5, "1.2"]
-						]]
-					]]
-				],
-				"*",
-				[5, "0.3"]
+								"PI"
+							]]
+						],
+						"pinOn"
+					]
+				]
 			],
-			"+",
-			[5, "0.5"]
-		]]]]
-	},
-	externals: {
-		"mxNoiseFloat2": () => mxNoiseFloat2,
-		"d.vec2f": () => vec2f
-	}
-}) && $.f)({}));
-const veinLadder = typegpu_default.fn([f32, f32], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((marbleT, depthVar) => {
-	"use gpu";
-	const t1 = smoothstep(.3, .6, marbleT);
-	const t2 = smoothstep(.6, .9, marbleT);
-	return vec2f(t1, __tsover_mul(t2, depthVar));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "marbleT"
-		}, {
-			"type": "i",
-			"name": "depthVar"
-		}],
-		"body": [0, [
 			[
 				13,
-				"t1",
+				"fade",
 				[
-					6,
-					"std.smoothstep",
+					1,
+					[
+						6,
+						"std.smoothstep",
+						[
+							[5, "0"],
+							[5, "0.06"],
+							"progress"
+						]
+					],
+					"*",
 					[
-						[5, "0.3"],
-						[5, "0.6"],
-						"marbleT"
+						1,
+						[5, "1"],
+						"-",
+						[
+							6,
+							"std.smoothstep",
+							[
+								[5, "0.94"],
+								[5, "1"],
+								"progress"
+							]
+						]
 					]
 				]
 			],
 			[
 				13,
-				"t2",
+				"edgeFade",
 				[
 					6,
-					"std.smoothstep",
+					"std.select",
 					[
-						[5, "0.6"],
-						[5, "0.9"],
-						"marbleT"
+						[
+							6,
+							"d.f32",
+							[[5, "1"]]
+						],
+						"fade",
+						"pinOn"
 					]
 				]
 			],
 			[10, [
 				6,
-				"d.vec2f",
-				["t1", [
-					1,
-					"t2",
-					"*",
-					"depthVar"
-				]]
-			]]
-		]]
-	},
-	externals: {
-		"std.smoothstep": () => smoothstep,
-		"d.vec2f": () => vec2f
-	}
-}) && $.f)({}));
-const strandsTonePow = typegpu_default.fn([vec3f], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((rgb) => {
-	"use gpu";
-	return pow(rgb, vec3f(.85, .85, .85));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "rgb"
-		}],
-		"body": [0, [[10, [
-			6,
-			"std.pow",
-			["rgb", [
-				6,
-				"d.vec3f",
+				"d.vec4f",
 				[
-					[5, "0.85"],
-					[5, "0.85"],
-					[5, "0.85"]
+					"progress",
+					"perpDist",
+					"pinch",
+					"edgeFade"
 				]
 			]]
-		]]]]
+		]]
 	},
 	externals: {
-		"std.pow": () => pow,
-		"d.vec3f": () => vec3f
+		"std.max": () => max,
+		"d.vec2f": () => vec2f,
+		"std.length": () => length,
+		"std.dot": () => dot,
+		"std.clamp": () => clamp,
+		"std.select": () => select,
+		"d.f32": () => f32,
+		"std.sin": () => sin,
+		"PI": () => PI,
+		"std.smoothstep": () => smoothstep,
+		"d.vec4f": () => vec4f
 	}
 }) && $.f)({}));
-var MAX = 8;
-if (8 !== MAX) throw new Error(`noisePaints: MAX (${MAX}) out of sync with MAX_COLOR_STOPS (8)`);
-const strandsField = typegpu_default.fn([
+const ribbonsField = typegpu_default.fn([
 	vec2f,
 	vec2f,
 	vec2f,
@@ -2597,25 +2639,14 @@ const strandsField = typegpu_default.fn([
 	const spread = packed2.y;
 	const colorScale = packed2.z;
 	const colorVariance = packed2.w;
-	const pinOn = packed3.x > 0;
 	const waveT = packed3.y;
 	const colorT = packed3.z;
 	const stopCount = packed3.w;
-	const aspectRatio = __tsover_div(viewport.x, max(viewport.y, 1e-6));
-	const startPos = vec2f(__tsover_mul(start.x, aspectRatio), __tsover_sub(1, start.y));
-	const endPos = vec2f(__tsover_mul(end.x, aspectRatio), __tsover_sub(1, end.y));
-	const aspectUV = vec2f(__tsover_mul(uv.x, aspectRatio), uv.y);
-	const direction = vec2f(__tsover_sub(endPos.x, startPos.x), __tsover_sub(endPos.y, startPos.y));
-	const len = max(length(direction), 1e-6);
-	const normalizedDir = vec2f(__tsover_div(direction.x, len), __tsover_div(direction.y, len));
-	const perpDir = vec2f(-normalizedDir.y, normalizedDir.x);
-	const relativePos = vec2f(__tsover_sub(aspectUV.x, startPos.x), __tsover_sub(aspectUV.y, startPos.y));
-	const progress = __tsover_div(dot(relativePos, normalizedDir), len);
-	const perpDist = dot(relativePos, perpDir);
-	const clampedProg = clamp(progress, 0, 1);
-	const pinch = select(f32(1), sin(__tsover_mul(clampedProg, PI)), pinOn);
-	const fade = __tsover_mul(smoothstep(0, .06, progress), __tsover_sub(1, smoothstep(.94, 1, progress)));
-	const edgeFade = select(f32(1), fade, pinOn);
+	const frame = ribbonPathFrame(uv, viewport, start, end, packed3.x);
+	const progress = frame.x;
+	const perpDist = frame.y;
+	const pinch = frame.z;
+	const edgeFade = frame.w;
 	const thickness = __tsover_mul(lineWidth, .07);
 	const softness = __tsover_add(__tsover_mul(softnessP, .08), 8e-4);
 	const denom = max(__tsover_sub(lineCount, 1), 1);
@@ -2712,435 +2743,137 @@ const strandsField = typegpu_default.fn([
 			[
 				13,
 				"lineCount",
-				[
-					7,
-					"packed1",
-					"z"
-				]
-			],
-			[
-				13,
-				"lineWidth",
-				[
-					7,
-					"packed1",
-					"w"
-				]
-			],
-			[
-				13,
-				"softnessP",
-				[
-					7,
-					"packed2",
-					"x"
-				]
-			],
-			[
-				13,
-				"spread",
-				[
-					7,
-					"packed2",
-					"y"
-				]
-			],
-			[
-				13,
-				"colorScale",
-				[
-					7,
-					"packed2",
-					"z"
-				]
-			],
-			[
-				13,
-				"colorVariance",
-				[
-					7,
-					"packed2",
-					"w"
-				]
-			],
-			[
-				13,
-				"pinOn",
-				[
-					1,
-					[
-						7,
-						"packed3",
-						"x"
-					],
-					">",
-					[5, "0"]
-				]
-			],
-			[
-				13,
-				"waveT",
-				[
-					7,
-					"packed3",
-					"y"
-				]
-			],
-			[
-				13,
-				"colorT",
-				[
-					7,
-					"packed3",
-					"z"
-				]
-			],
-			[
-				13,
-				"stopCount",
-				[
-					7,
-					"packed3",
-					"w"
-				]
-			],
-			[
-				13,
-				"aspectRatio",
-				[
-					1,
-					[
-						7,
-						"viewport",
-						"x"
-					],
-					"/",
-					[
-						6,
-						"std.max",
-						[[
-							7,
-							"viewport",
-							"y"
-						], [5, "0.000001"]]
-					]
-				]
-			],
-			[
-				13,
-				"startPos",
-				[
-					6,
-					"d.vec2f",
-					[[
-						1,
-						[
-							7,
-							"start",
-							"x"
-						],
-						"*",
-						"aspectRatio"
-					], [
-						1,
-						[5, "1"],
-						"-",
-						[
-							7,
-							"start",
-							"y"
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"endPos",
-				[
-					6,
-					"d.vec2f",
-					[[
-						1,
-						[
-							7,
-							"end",
-							"x"
-						],
-						"*",
-						"aspectRatio"
-					], [
-						1,
-						[5, "1"],
-						"-",
-						[
-							7,
-							"end",
-							"y"
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"aspectUV",
-				[
-					6,
-					"d.vec2f",
-					[[
-						1,
-						[
-							7,
-							"uv",
-							"x"
-						],
-						"*",
-						"aspectRatio"
-					], [
-						7,
-						"uv",
-						"y"
-					]]
+				[
+					7,
+					"packed1",
+					"z"
 				]
 			],
 			[
 				13,
-				"direction",
+				"lineWidth",
 				[
-					6,
-					"d.vec2f",
-					[[
-						1,
-						[
-							7,
-							"endPos",
-							"x"
-						],
-						"-",
-						[
-							7,
-							"startPos",
-							"x"
-						]
-					], [
-						1,
-						[
-							7,
-							"endPos",
-							"y"
-						],
-						"-",
-						[
-							7,
-							"startPos",
-							"y"
-						]
-					]]
+					7,
+					"packed1",
+					"w"
 				]
 			],
 			[
 				13,
-				"len",
+				"softnessP",
 				[
-					6,
-					"std.max",
-					[[
-						6,
-						"std.length",
-						["direction"]
-					], [5, "0.000001"]]
+					7,
+					"packed2",
+					"x"
 				]
 			],
 			[
 				13,
-				"normalizedDir",
+				"spread",
 				[
-					6,
-					"d.vec2f",
-					[[
-						1,
-						[
-							7,
-							"direction",
-							"x"
-						],
-						"/",
-						"len"
-					], [
-						1,
-						[
-							7,
-							"direction",
-							"y"
-						],
-						"/",
-						"len"
-					]]
+					7,
+					"packed2",
+					"y"
 				]
 			],
 			[
 				13,
-				"perpDir",
+				"colorScale",
 				[
-					6,
-					"d.vec2f",
-					[[
-						4,
-						"-",
-						[
-							7,
-							"normalizedDir",
-							"y"
-						]
-					], [
-						7,
-						"normalizedDir",
-						"x"
-					]]
+					7,
+					"packed2",
+					"z"
 				]
 			],
 			[
 				13,
-				"relativePos",
+				"colorVariance",
 				[
-					6,
-					"d.vec2f",
-					[[
-						1,
-						[
-							7,
-							"aspectUV",
-							"x"
-						],
-						"-",
-						[
-							7,
-							"startPos",
-							"x"
-						]
-					], [
-						1,
-						[
-							7,
-							"aspectUV",
-							"y"
-						],
-						"-",
-						[
-							7,
-							"startPos",
-							"y"
-						]
-					]]
+					7,
+					"packed2",
+					"w"
 				]
 			],
 			[
 				13,
-				"progress",
+				"waveT",
 				[
-					1,
-					[
-						6,
-						"std.dot",
-						["relativePos", "normalizedDir"]
-					],
-					"/",
-					"len"
+					7,
+					"packed3",
+					"y"
 				]
 			],
 			[
 				13,
-				"perpDist",
+				"colorT",
 				[
-					6,
-					"std.dot",
-					["relativePos", "perpDir"]
+					7,
+					"packed3",
+					"z"
 				]
 			],
 			[
 				13,
-				"clampedProg",
+				"stopCount",
 				[
-					6,
-					"std.clamp",
-					[
-						"progress",
-						[5, "0"],
-						[5, "1"]
-					]
+					7,
+					"packed3",
+					"w"
 				]
 			],
 			[
 				13,
-				"pinch",
+				"frame",
 				[
 					6,
-					"std.select",
+					"ribbonPathFrame",
 					[
+						"uv",
+						"viewport",
+						"start",
+						"end",
 						[
-							6,
-							"d.f32",
-							[[5, "1"]]
-						],
-						[
-							6,
-							"std.sin",
-							[[
-								1,
-								"clampedProg",
-								"*",
-								"PI"
-							]]
-						],
-						"pinOn"
+							7,
+							"packed3",
+							"x"
+						]
 					]
 				]
 			],
 			[
 				13,
-				"fade",
+				"progress",
 				[
-					1,
-					[
-						6,
-						"std.smoothstep",
-						[
-							[5, "0"],
-							[5, "0.06"],
-							"progress"
-						]
-					],
-					"*",
-					[
-						1,
-						[5, "1"],
-						"-",
-						[
-							6,
-							"std.smoothstep",
-							[
-								[5, "0.94"],
-								[5, "1"],
-								"progress"
-							]
-						]
-					]
+					7,
+					"frame",
+					"x"
+				]
+			],
+			[
+				13,
+				"perpDist",
+				[
+					7,
+					"frame",
+					"y"
+				]
+			],
+			[
+				13,
+				"pinch",
+				[
+					7,
+					"frame",
+					"z"
 				]
 			],
 			[
 				13,
 				"edgeFade",
 				[
-					6,
-					"std.select",
-					[
-						[
-							6,
-							"d.f32",
-							[[5, "1"]]
-						],
-						"fade",
-						"pinOn"
-					]
+					7,
+					"frame",
+					"w"
 				]
 			],
 			[
@@ -3654,23 +3387,19 @@ const strandsField = typegpu_default.fn([
 		]]
 	},
 	externals: {
+		"ribbonPathFrame": () => ribbonPathFrame,
 		"std.max": () => max,
-		"d.vec2f": () => vec2f,
-		"std.length": () => length,
-		"std.dot": () => dot,
-		"std.clamp": () => clamp,
-		"std.select": () => select,
-		"d.f32": () => f32,
-		"std.sin": () => sin,
-		"PI": () => PI,
-		"std.smoothstep": () => smoothstep,
 		"d.vec3f": () => vec3f,
+		"d.f32": () => f32,
 		"TAU": () => TAU,
 		"d.i32": () => i32,
 		"std.round": () => round,
+		"std.sin": () => sin,
 		"std.abs": () => abs,
+		"std.smoothstep": () => smoothstep,
 		"std.fract": () => fract,
 		"gradientStopsInSpace": () => gradientStopsInSpace,
+		"std.clamp": () => clamp,
 		"d.vec4f": () => vec4f
 	}
 }) && $.f)({}));
@@ -3887,4 +3616,4 @@ const paperSurface = typegpu_default.fn([
 		"d.vec3f": () => vec3f
 	}
 }) && $.f)({}));
-export { worleyModeScale as C, worleyModeNum as S, worleyTone as T, veinWave as _, fbmNormalize as a, worleyDistNum as b, paperSurface as c, strandsField as d, strandsTonePow as f, veinLadder as g, veinDepth as h, curlMagnitude as i, rawAspectScaledDomain as l, transformWorleyMode as m, cellBorders as n, fractalSum as o, transformWorleyDistance as p, cellFill as r, marbleTurbulence as s, aspectPlane as t, rotatedCenteredDomain as u, voronoiCells as v, worleyNormalize as w, worleyHash as x, worleyCells as y };
+export { worleyHash as _, fbmNormalize as a, worleyNormalize as b, rawAspectScaledDomain as c, toneLift as d, transformWorleyDistance as f, worleyDistNum as g, worleyCells as h, curlMagnitude as i, ribbonsField as l, voronoiCells as m, cellBorders as n, fractalSum as o, transformWorleyMode as p, cellFill as r, paperSurface as s, aspectPlane as t, rotatedCenteredDomain as u, worleyModeNum as v, worleyTone as x, worleyModeScale as y };