shaders 3.2.464 → 3.2.465

package/dist/core/{patterns-CUWhLDh0.js → patterns-BAu9g0yn.js}

@@ -1,10 +1,9 @@
-import { $n as vec4f, $t as flooredMod1, En as cos, Fn as min, Gn as sqrt, In as mix, Jn as vec2f, Kn as step, Mn as fract, Nn as length, Nt as mixColorsLinear, On as dot, Pn as max, Pt as mixColorsVariants, Qt as directionalProjection, Tn as clamp, Un as sin, Vn as round, Wn as smoothstep, Xt as aspectOf, Yt as aspectCorrectedUVFlipY, Zn as vec3f, Zt as canvasCentredDelta, a as uniformOf, at as call, bn as select, cn as SQRT3, dt as vec4, en as flooredMod2, gr as i32, hr as f32, in as DEG_TO_RAD, jn as floor, ln as TAU, lt as floatE, mn as typegpu_default, nn as rotateAboutCanvasCentre, or as arrayOf, rt as arrayExpr, sr as struct, tn as rotate2, ut as mixExpr, xn as abs } from "./lower-z2vuXP8M.js";
-import { C as dpdx, T as fwidth, s as hash12, w as dpdy } from "./noise-B3Oq1k3_.js";
-import { a as lineMaskFromField, c as quilezStepFilter, i as footprint2, n as discCoverage, o as quilezCheckerFilter, r as footprint1, s as quilezLineFilterAxis, t as bandMask } from "./aa-BfXCHL6-.js";
-import { t as animatedTime } from "./porters-B1UjrM1y.js";
-import { _ as local } from "./math-BF-GBlb4.js";
-import { n as gather } from "./filter-Bw8Ogi4T.js";
-import { t as colorSpaceModeOf } from "./fields-Cg5kOBDV.js";
+import { $n as clamp, $t as aspectCorrectedUVFlipY, An as DEG_TO_RAD, Br as f32, Gn as dpdy, Jn as select, Kn as fwidth, Mr as arrayOf, Nn as SQRT3, Nr as struct, Pn as TAU, Tr as vec4f, Vr as i32, Wn as dpdx, Yn as abs, _r as smoothstep, an as rotate2, ar as floor, cr as max, dt as mixExpr, en as aspectOf, er as cos, ft as vec4, gr as sin, in as flooredMod2, it as arrayExpr, lr as min, mn as hash12, mr as round, n as paintFrame, nn as directionalProjection, nr as dot, o as uniformOf, on as rotateAboutCanvasCentre, or as fract, ot as call, rn as flooredMod1, sr as length, tn as canvasCentredDelta, ur as mix, ut as floatE, vr as sqrt, wr as vec3f, xr as vec2f, yr as step, zn as typegpu_default } from "./lower-DSk_KxOY.js";
+import { F as footprint2, I as lineMaskFromField, L as quilezCheckerFilter, M as bandMask, N as discCoverage, P as footprint1, R as quilezLineFilterAxis, z as quilezStepFilter } from "./gradientPaints-Du0XCNHB.js";
+import { t as animatedTime } from "./porters-j4QbEOqj.js";
+import { s as mixColorsIn } from "./fields-Cv-wBDLP.js";
+import { y as local } from "./math-DCQU6EQz.js";
+import { n as gather } from "./filter-VJlLs3Zs.js";
 var TWO_OVER_SQRT3 = 2 / Math.sqrt(3);
 const CellTile = struct({
 	cell: vec2f,
@@ -2266,6 +2265,266 @@ var colHash = typegpu_default.fn([f32], vec2f)(/* @__PURE__ */ (($) => (globalTh
 		"std.sin": () => sin
 	}
 }) && $.f)({}));
+const fallingCapAlpha = typegpu_default.fn([
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((vPeriodic, trailLen, density, hw, rounding, fwU, distFromCenter) => {
+	"use gpu";
+	const maxDepth = __tsover_mul(hw, rounding);
+	const gapDist = __tsover_mul(max(__tsover_sub(vPeriodic, trailLen), 0), density);
+	const tcap = clamp(__tsover_div(gapDist, max(maxDepth, 1e-4)), 0, 1);
+	const capHW = __tsover_mul(hw, sqrt(max(__tsover_sub(1, __tsover_mul(tcap, tcap)), 0)));
+	return __tsover_mul(__tsover_sub(1, smoothstep(max(__tsover_sub(capHW, fwU), 0), max(__tsover_add(capHW, fwU), .001), distFromCenter)), smoothstep(0, fwU, capHW));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "vPeriodic"
+			},
+			{
+				"type": "i",
+				"name": "trailLen"
+			},
+			{
+				"type": "i",
+				"name": "density"
+			},
+			{
+				"type": "i",
+				"name": "hw"
+			},
+			{
+				"type": "i",
+				"name": "rounding"
+			},
+			{
+				"type": "i",
+				"name": "fwU"
+			},
+			{
+				"type": "i",
+				"name": "distFromCenter"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"maxDepth",
+				[
+					1,
+					"hw",
+					"*",
+					"rounding"
+				]
+			],
+			[
+				13,
+				"gapDist",
+				[
+					1,
+					[
+						6,
+						"std.max",
+						[[
+							1,
+							"vPeriodic",
+							"-",
+							"trailLen"
+						], [5, "0"]]
+					],
+					"*",
+					"density"
+				]
+			],
+			[
+				13,
+				"tcap",
+				[
+					6,
+					"std.clamp",
+					[
+						[
+							1,
+							"gapDist",
+							"/",
+							[
+								6,
+								"std.max",
+								["maxDepth", [5, "0.0001"]]
+							]
+						],
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"capHW",
+				[
+					1,
+					"hw",
+					"*",
+					[
+						6,
+						"std.sqrt",
+						[[
+							6,
+							"std.max",
+							[[
+								1,
+								[5, "1"],
+								"-",
+								[
+									1,
+									"tcap",
+									"*",
+									"tcap"
+								]
+							], [5, "0"]]
+						]]
+					]
+				]
+			],
+			[10, [
+				1,
+				[
+					1,
+					[5, "1"],
+					"-",
+					[
+						6,
+						"std.smoothstep",
+						[
+							[
+								6,
+								"std.max",
+								[[
+									1,
+									"capHW",
+									"-",
+									"fwU"
+								], [5, "0"]]
+							],
+							[
+								6,
+								"std.max",
+								[[
+									1,
+									"capHW",
+									"+",
+									"fwU"
+								], [5, "0.001"]]
+							],
+							"distFromCenter"
+						]
+					]
+				],
+				"*",
+				[
+					6,
+					"std.smoothstep",
+					[
+						[5, "0"],
+						"fwU",
+						"capHW"
+					]
+				]
+			]]
+		]]
+	},
+	externals: {
+		"std.max": () => max,
+		"std.clamp": () => clamp,
+		"std.sqrt": () => sqrt,
+		"std.smoothstep": () => smoothstep
+	}
+}) && $.f)({}));
+const fallingBalanceRemap = typegpu_default.fn([f32, f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((withinStreak, balance) => {
+	"use gpu";
+	const balanceNum = __tsover_sub(__tsover_mul(2, balance), 1);
+	const balanceDen = max(__tsover_mul(2, __tsover_sub(1, balance)), .001);
+	return clamp(__tsover_div(__tsover_add(withinStreak, balanceNum), balanceDen), 0, 1);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "withinStreak"
+		}, {
+			"type": "i",
+			"name": "balance"
+		}],
+		"body": [0, [
+			[
+				13,
+				"balanceNum",
+				[
+					1,
+					[
+						1,
+						[5, "2"],
+						"*",
+						"balance"
+					],
+					"-",
+					[5, "1"]
+				]
+			],
+			[
+				13,
+				"balanceDen",
+				[
+					6,
+					"std.max",
+					[[
+						1,
+						[5, "2"],
+						"*",
+						[
+							1,
+							[5, "1"],
+							"-",
+							"balance"
+						]
+					], [5, "0.001"]]
+				]
+			],
+			[10, [
+				6,
+				"std.clamp",
+				[
+					[
+						1,
+						[
+							1,
+							"withinStreak",
+							"+",
+							"balanceNum"
+						],
+						"/",
+						"balanceDen"
+					],
+					[5, "0"],
+					[5, "1"]
+				]
+			]]
+		]]
+	},
+	externals: {
+		"std.max": () => max,
+		"std.clamp": () => clamp
+	}
+}) && $.f)({}));
 const fallingLinesField = typegpu_default.fn([
 	vec2f,
 	vec2f,
@@ -2302,15 +2561,7 @@ const fallingLinesField = typegpu_default.fn([
 	const hw = __tsover_mul(strokeWidth, .5);
 	const distFromCenter = abs(__tsover_sub(colLocalU, .5));
 	const widthMask = __tsover_sub(1, smoothstep(__tsover_sub(hw, fwU), __tsover_add(hw, fwU), distFromCenter));
-	const rectMask = __tsover_mul(streakMask, widthMask);
-	const maxDepth = __tsover_mul(hw, rounding);
-	const gapDist = __tsover_mul(max(__tsover_sub(vPeriodic, trailLen), 0), density);
-	const tcap = clamp(__tsover_div(gapDist, max(maxDepth, 1e-4)), 0, 1);
-	const capHW = __tsover_mul(hw, sqrt(max(__tsover_sub(1, __tsover_mul(tcap, tcap)), 0)));
-	const finalMask = max(rectMask, __tsover_mul(__tsover_sub(1, smoothstep(max(__tsover_sub(capHW, fwU), 0), max(__tsover_add(capHW, fwU), .001), distFromCenter)), smoothstep(0, fwU, capHW)));
-	const balanceNum = __tsover_sub(__tsover_mul(2, balance), 1);
-	const balanceDen = max(__tsover_mul(2, __tsover_sub(1, balance)), .001);
-	return vec2f(finalMask, clamp(__tsover_div(__tsover_add(withinStreak, balanceNum), balanceDen), 0, 1));
+	return vec2f(max(__tsover_mul(streakMask, widthMask), fallingCapAlpha(vPeriodic, trailLen, density, hw, rounding, fwU, distFromCenter)), fallingBalanceRemap(withinStreak, balance));
 }), {
 	v: 2,
 	name: void 0,
@@ -2757,202 +3008,38 @@ const fallingLinesField = typegpu_default.fn([
 			],
 			[
 				13,
-				"maxDepth",
+				"capAlpha",
 				[
-					1,
-					"hw",
-					"*",
-					"rounding"
+					6,
+					"fallingCapAlpha",
+					[
+						"vPeriodic",
+						"trailLen",
+						"density",
+						"hw",
+						"rounding",
+						"fwU",
+						"distFromCenter"
+					]
 				]
 			],
 			[
 				13,
-				"gapDist",
-				[
-					1,
-					[
-						6,
-						"std.max",
-						[[
-							1,
-							"vPeriodic",
-							"-",
-							"trailLen"
-						], [5, "0"]]
-					],
-					"*",
-					"density"
-				]
-			],
-			[
-				13,
-				"tcap",
-				[
-					6,
-					"std.clamp",
-					[
-						[
-							1,
-							"gapDist",
-							"/",
-							[
-								6,
-								"std.max",
-								["maxDepth", [5, "0.0001"]]
-							]
-						],
-						[5, "0"],
-						[5, "1"]
-					]
-				]
-			],
-			[
-				13,
-				"capHW",
-				[
-					1,
-					"hw",
-					"*",
-					[
-						6,
-						"std.sqrt",
-						[[
-							6,
-							"std.max",
-							[[
-								1,
-								[5, "1"],
-								"-",
-								[
-									1,
-									"tcap",
-									"*",
-									"tcap"
-								]
-							], [5, "0"]]
-						]]
-					]
-				]
-			],
-			[
-				13,
-				"capAlpha",
-				[
-					1,
-					[
-						1,
-						[5, "1"],
-						"-",
-						[
-							6,
-							"std.smoothstep",
-							[
-								[
-									6,
-									"std.max",
-									[[
-										1,
-										"capHW",
-										"-",
-										"fwU"
-									], [5, "0"]]
-								],
-								[
-									6,
-									"std.max",
-									[[
-										1,
-										"capHW",
-										"+",
-										"fwU"
-									], [5, "0.001"]]
-								],
-								"distFromCenter"
-							]
-						]
-					],
-					"*",
-					[
-						6,
-						"std.smoothstep",
-						[
-							[5, "0"],
-							"fwU",
-							"capHW"
-						]
-					]
-				]
-			],
-			[
-				13,
-				"finalMask",
+				"finalMask",
 				[
 					6,
 					"std.max",
 					["rectMask", "capAlpha"]
 				]
 			],
-			[
-				13,
-				"balanceNum",
-				[
-					1,
-					[
-						1,
-						[5, "2"],
-						"*",
-						"balance"
-					],
-					"-",
-					[5, "1"]
-				]
-			],
-			[
-				13,
-				"balanceDen",
-				[
-					6,
-					"std.max",
-					[[
-						1,
-						[5, "2"],
-						"*",
-						[
-							1,
-							[5, "1"],
-							"-",
-							"balance"
-						]
-					], [5, "0.001"]]
-				]
-			],
-			[
-				13,
-				"balancedT",
-				[
-					6,
-					"std.clamp",
-					[
-						[
-							1,
-							[
-								1,
-								"withinStreak",
-								"+",
-								"balanceNum"
-							],
-							"/",
-							"balanceDen"
-						],
-						[5, "0"],
-						[5, "1"]
-					]
-				]
-			],
 			[10, [
 				6,
 				"d.vec2f",
-				["finalMask", "balancedT"]
+				["finalMask", [
+					6,
+					"fallingBalanceRemap",
+					["withinStreak", "balance"]
+				]]
 			]]
 		]]
 	},
@@ -2969,8 +3056,9 @@ const fallingLinesField = typegpu_default.fn([
 		"std.fwidth": () => fwidth,
 		"std.smoothstep": () => smoothstep,
 		"std.abs": () => abs,
+		"fallingCapAlpha": () => fallingCapAlpha,
 		"std.max": () => max,
-		"std.sqrt": () => sqrt
+		"fallingBalanceRemap": () => fallingBalanceRemap
 	}
 }) && $.f)({}));
 const gridCellCenterUV = typegpu_default.fn([
@@ -4226,27 +4314,406 @@ const triangularGridField = typegpu_default.fn([
 				]
 			],
 			[10, [
-				6,
-				"d.vec2f",
-				["lineMask", "variedFactor"]
+				6,
+				"d.vec2f",
+				["lineMask", "variedFactor"]
+			]]
+		]]
+	},
+	externals: {
+		"triLattice": () => triLattice,
+		"std.floor": () => floor,
+		"rowSpeedMultiplier": () => rowSpeedMultiplier,
+		"rowSpeedHash": () => rowSpeedHash,
+		"d.vec2f": () => vec2f,
+		"std.fract": () => fract,
+		"std.step": () => step,
+		"cellVariation": () => cellVariation,
+		"std.min": () => min,
+		"std.abs": () => abs,
+		"std.max": () => max,
+		"std.fwidth": () => fwidth,
+		"strokeBandSymmetric": () => strokeBandSymmetric
+	}
+}) && $.f)({}));
+const brickFrame = typegpu_default.fn([
+	vec2f,
+	vec2f,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, rotation) => {
+	"use gpu";
+	const aspect = aspectOf(viewport);
+	const centred = canvasCentredDelta(uv, aspect);
+	const rotRad = __tsover_mul(rotation, DEG_TO_RAD);
+	const rot = rotate2(centred, cos(rotRad), -sin(rotRad));
+	return vec2f(__tsover_add(__tsover_div(rot.x, aspect), .5), __tsover_add(rot.y, .5));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "viewport"
+			},
+			{
+				"type": "i",
+				"name": "rotation"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"aspect",
+				[
+					6,
+					"aspectOf",
+					["viewport"]
+				]
+			],
+			[
+				13,
+				"centred",
+				[
+					6,
+					"canvasCentredDelta",
+					["uv", "aspect"]
+				]
+			],
+			[
+				13,
+				"rotRad",
+				[
+					1,
+					"rotation",
+					"*",
+					"DEG_TO_RAD"
+				]
+			],
+			[
+				13,
+				"cosR",
+				[
+					6,
+					"std.cos",
+					["rotRad"]
+				]
+			],
+			[
+				13,
+				"sinR",
+				[
+					6,
+					"std.sin",
+					["rotRad"]
+				]
+			],
+			[
+				13,
+				"rot",
+				[
+					6,
+					"rotate2",
+					[
+						"centred",
+						"cosR",
+						[
+							4,
+							"-",
+							"sinR"
+						]
+					]
+				]
+			],
+			[10, [
+				6,
+				"d.vec2f",
+				[[
+					1,
+					[
+						1,
+						[
+							7,
+							"rot",
+							"x"
+						],
+						"/",
+						"aspect"
+					],
+					"+",
+					[5, "0.5"]
+				], [
+					1,
+					[
+						7,
+						"rot",
+						"y"
+					],
+					"+",
+					[5, "0.5"]
+				]]
+			]]
+		]]
+	},
+	externals: {
+		"aspectOf": () => aspectOf,
+		"canvasCentredDelta": () => canvasCentredDelta,
+		"DEG_TO_RAD": () => DEG_TO_RAD,
+		"std.cos": () => cos,
+		"std.sin": () => sin,
+		"rotate2": () => rotate2,
+		"d.vec2f": () => vec2f
+	}
+}) && $.f)({}));
+const brickRowStagger = typegpu_default.fn([
+	f32,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((row, seed, speedVariance) => {
+	"use gpu";
+	const rowMod2 = flooredMod1(row, 2);
+	return vec2f(__tsover_mul(rowMod2, .5), mix(__tsover_sub(__tsover_mul(rowMod2, 2), 1), __tsover_mul(__tsover_sub(fract(__tsover_mul(sin(__tsover_add(row, __tsover_mul(seed, .137))), 43758.5453)), .5), 2), speedVariance));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "row"
+			},
+			{
+				"type": "i",
+				"name": "seed"
+			},
+			{
+				"type": "i",
+				"name": "speedVariance"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"rowMod2",
+				[
+					6,
+					"flooredMod1",
+					["row", [5, "2"]]
+				]
+			],
+			[
+				13,
+				"rowOffset",
+				[
+					1,
+					"rowMod2",
+					"*",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"rowDir",
+				[
+					1,
+					[
+						1,
+						"rowMod2",
+						"*",
+						[5, "2"]
+					],
+					"-",
+					[5, "1"]
+				]
+			],
+			[
+				13,
+				"rowHash",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							"std.fract",
+							[[
+								1,
+								[
+									6,
+									"std.sin",
+									[[
+										1,
+										"row",
+										"+",
+										[
+											1,
+											"seed",
+											"*",
+											[5, "0.137"]
+										]
+									]]
+								],
+								"*",
+								[5, "43758.5453"]
+							]]
+						],
+						"-",
+						[5, "0.5"]
+					],
+					"*",
+					[5, "2"]
+				]
+			],
+			[10, [
+				6,
+				"d.vec2f",
+				["rowOffset", [
+					6,
+					"std.mix",
+					[
+						"rowDir",
+						"rowHash",
+						"speedVariance"
+					]
+				]]
+			]]
+		]]
+	},
+	externals: {
+		"flooredMod1": () => flooredMod1,
+		"std.fract": () => fract,
+		"std.sin": () => sin,
+		"d.vec2f": () => vec2f,
+		"std.mix": () => mix
+	}
+}) && $.f)({}));
+const brickMortarMask = typegpu_default.fn([
+	vec2f,
+	vec2f,
+	vec2f
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cellUV, mortarUV, aaUV) => {
+	"use gpu";
+	const brickU = bandMask(cellUV.x, __tsover_sub(mortarUV.x, aaUV.x), __tsover_add(mortarUV.x, aaUV.x));
+	const brickV = bandMask(cellUV.y, __tsover_sub(mortarUV.y, aaUV.y), __tsover_add(mortarUV.y, aaUV.y));
+	return __tsover_mul(brickU, brickV);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "cellUV"
+			},
+			{
+				"type": "i",
+				"name": "mortarUV"
+			},
+			{
+				"type": "i",
+				"name": "aaUV"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"brickU",
+				[
+					6,
+					"bandMask",
+					[
+						[
+							7,
+							"cellUV",
+							"x"
+						],
+						[
+							1,
+							[
+								7,
+								"mortarUV",
+								"x"
+							],
+							"-",
+							[
+								7,
+								"aaUV",
+								"x"
+							]
+						],
+						[
+							1,
+							[
+								7,
+								"mortarUV",
+								"x"
+							],
+							"+",
+							[
+								7,
+								"aaUV",
+								"x"
+							]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"brickV",
+				[
+					6,
+					"bandMask",
+					[
+						[
+							7,
+							"cellUV",
+							"y"
+						],
+						[
+							1,
+							[
+								7,
+								"mortarUV",
+								"y"
+							],
+							"-",
+							[
+								7,
+								"aaUV",
+								"y"
+							]
+						],
+						[
+							1,
+							[
+								7,
+								"mortarUV",
+								"y"
+							],
+							"+",
+							[
+								7,
+								"aaUV",
+								"y"
+							]
+						]
+					]
+				]
+			],
+			[10, [
+				1,
+				"brickU",
+				"*",
+				"brickV"
 			]]
 		]]
 	},
-	externals: {
-		"triLattice": () => triLattice,
-		"std.floor": () => floor,
-		"rowSpeedMultiplier": () => rowSpeedMultiplier,
-		"rowSpeedHash": () => rowSpeedHash,
-		"d.vec2f": () => vec2f,
-		"std.fract": () => fract,
-		"std.step": () => step,
-		"cellVariation": () => cellVariation,
-		"std.min": () => min,
-		"std.abs": () => abs,
-		"std.max": () => max,
-		"std.fwidth": () => fwidth,
-		"strokeBandSymmetric": () => strokeBandSymmetric
-	}
+	externals: { "bandMask": () => bandMask }
 }) && $.f)({}));
 const brickField = typegpu_default.fn([
 	vec2f,
@@ -4264,27 +4731,21 @@ const brickField = typegpu_default.fn([
 ], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, cellsX, cellsY, mortar, softness, variation, rotation, offset, speedVariance, seed, animTime) => {
 	"use gpu";
 	const aspect = aspectOf(viewport);
-	const centred = canvasCentredDelta(uv, aspect);
-	const rotRad = __tsover_mul(rotation, DEG_TO_RAD);
-	const rot = rotate2(centred, cos(rotRad), -sin(rotRad));
-	const u = __tsover_add(__tsover_div(rot.x, aspect), .5);
-	const v = __tsover_add(rot.y, .5);
+	const frame = brickFrame(uv, viewport, rotation);
+	const u = frame.x;
+	const v = frame.y;
 	const mortarU = __tsover_mul(mortar, .3);
 	const mortarV = __tsover_div(__tsover_mul(__tsover_mul(mortarU, aspect), cellsY), cellsX);
 	const row = floor(__tsover_mul(v, cellsY));
-	const rowMod2 = flooredMod1(row, 2);
-	const rowOffset = __tsover_mul(rowMod2, .5);
-	const rowSpeedMult = mix(__tsover_sub(__tsover_mul(rowMod2, 2), 1), __tsover_mul(__tsover_sub(fract(__tsover_mul(sin(__tsover_add(row, __tsover_mul(seed, .137))), 43758.5453)), .5), 2), speedVariance);
-	const brickArg = __tsover_add(__tsover_add(__tsover_add(__tsover_mul(u, cellsX), rowOffset), __tsover_mul(animTime, rowSpeedMult)), offset);
+	const stagger = brickRowStagger(row, seed, speedVariance);
+	const brickArg = __tsover_add(__tsover_add(__tsover_add(__tsover_mul(u, cellsX), stagger.x), __tsover_mul(animTime, stagger.y)), offset);
 	const vScaled = __tsover_mul(v, cellsY);
 	const cellU = fract(brickArg);
 	const cellV = fract(vScaled);
 	const soft = __tsover_mul(softness, .5);
 	const aaU = __tsover_add(fwidth(brickArg), soft);
 	const aaV = __tsover_add(fwidth(vScaled), soft);
-	const brickU = bandMask(cellU, __tsover_sub(mortarU, aaU), __tsover_add(mortarU, aaU));
-	const brickV = bandMask(cellV, __tsover_sub(mortarV, aaV), __tsover_add(mortarV, aaV));
-	return vec2f(__tsover_mul(brickU, brickV), cellVariation(vec2f(floor(brickArg), row), variation));
+	return vec2f(brickMortarMask(vec2f(cellU, cellV), vec2f(mortarU, mortarV), vec2f(aaU, aaV)), cellVariation(vec2f(floor(brickArg), row), variation));
 }), {
 	v: 2,
 	name: void 0,
@@ -4351,55 +4812,14 @@ const brickField = typegpu_default.fn([
 			],
 			[
 				13,
-				"centred",
-				[
-					6,
-					"canvasCentredDelta",
-					["uv", "aspect"]
-				]
-			],
-			[
-				13,
-				"rotRad",
-				[
-					1,
-					"rotation",
-					"*",
-					"DEG_TO_RAD"
-				]
-			],
-			[
-				13,
-				"cosR",
-				[
-					6,
-					"std.cos",
-					["rotRad"]
-				]
-			],
-			[
-				13,
-				"sinR",
-				[
-					6,
-					"std.sin",
-					["rotRad"]
-				]
-			],
-			[
-				13,
-				"rot",
+				"frame",
 				[
 					6,
-					"rotate2",
+					"brickFrame",
 					[
-						"centred",
-						"cosR",
-						[
-							4,
-							"-",
-							"sinR"
-						]
+						"uv",
+						"viewport",
+						"rotation"
 					]
 				]
 			],
@@ -4407,33 +4827,18 @@ const brickField = typegpu_default.fn([
 				13,
 				"u",
 				[
-					1,
-					[
-						1,
-						[
-							7,
-							"rot",
-							"x"
-						],
-						"/",
-						"aspect"
-					],
-					"+",
-					[5, "0.5"]
+					7,
+					"frame",
+					"x"
 				]
 			],
 			[
 				13,
 				"v",
 				[
-					1,
-					[
-						7,
-						"rot",
-						"y"
-					],
-					"+",
-					[5, "0.5"]
+					7,
+					"frame",
+					"y"
 				]
 			],
 			[
@@ -4482,85 +4887,13 @@ const brickField = typegpu_default.fn([
 			],
 			[
 				13,
-				"rowMod2",
-				[
-					6,
-					"flooredMod1",
-					["row", [5, "2"]]
-				]
-			],
-			[
-				13,
-				"rowOffset",
-				[
-					1,
-					"rowMod2",
-					"*",
-					[5, "0.5"]
-				]
-			],
-			[
-				13,
-				"rowDir",
-				[
-					1,
-					[
-						1,
-						"rowMod2",
-						"*",
-						[5, "2"]
-					],
-					"-",
-					[5, "1"]
-				]
-			],
-			[
-				13,
-				"rowHash",
-				[
-					1,
-					[
-						1,
-						[
-							6,
-							"std.fract",
-							[[
-								1,
-								[
-									6,
-									"std.sin",
-									[[
-										1,
-										"row",
-										"+",
-										[
-											1,
-											"seed",
-											"*",
-											[5, "0.137"]
-										]
-									]]
-								],
-								"*",
-								[5, "43758.5453"]
-							]]
-						],
-						"-",
-						[5, "0.5"]
-					],
-					"*",
-					[5, "2"]
-				]
-			],
-			[
-				13,
-				"rowSpeedMult",
+				"stagger",
 				[
 					6,
-					"std.mix",
+					"brickRowStagger",
 					[
-						"rowDir",
-						"rowHash",
+						"row",
+						"seed",
 						"speedVariance"
 					]
 				]
@@ -4581,14 +4914,22 @@ const brickField = typegpu_default.fn([
 								"cellsX"
 							],
 							"+",
-							"rowOffset"
+							[
+								7,
+								"stagger",
+								"x"
+							]
 						],
 						"+",
 						[
 							1,
 							"animTime",
 							"*",
-							"rowSpeedMult"
+							[
+								7,
+								"stagger",
+								"y"
+							]
 						]
 					],
 					"+",
@@ -4663,60 +5004,29 @@ const brickField = typegpu_default.fn([
 			],
 			[
 				13,
-				"brickU",
+				"brickMask",
 				[
 					6,
-					"bandMask",
+					"brickMortarMask",
 					[
-						"cellU",
 						[
-							1,
-							"mortarU",
-							"-",
-							"aaU"
+							6,
+							"d.vec2f",
+							["cellU", "cellV"]
 						],
 						[
-							1,
-							"mortarU",
-							"+",
-							"aaU"
-						]
-					]
-				]
-			],
-			[
-				13,
-				"brickV",
-				[
-					6,
-					"bandMask",
-					[
-						"cellV",
-						[
-							1,
-							"mortarV",
-							"-",
-							"aaV"
+							6,
+							"d.vec2f",
+							["mortarU", "mortarV"]
 						],
 						[
-							1,
-							"mortarV",
-							"+",
-							"aaV"
+							6,
+							"d.vec2f",
+							["aaU", "aaV"]
 						]
 					]
 				]
 			],
-			[
-				13,
-				"brickMask",
-				[
-					1,
-					"brickU",
-					"*",
-					"brickV"
-				]
-			],
 			[
 				13,
 				"brickId",
@@ -4748,17 +5058,12 @@ const brickField = typegpu_default.fn([
 	},
 	externals: {
 		"aspectOf": () => aspectOf,
-		"canvasCentredDelta": () => canvasCentredDelta,
-		"DEG_TO_RAD": () => DEG_TO_RAD,
-		"std.cos": () => cos,
-		"std.sin": () => sin,
-		"rotate2": () => rotate2,
+		"brickFrame": () => brickFrame,
 		"std.floor": () => floor,
-		"flooredMod1": () => flooredMod1,
+		"brickRowStagger": () => brickRowStagger,
 		"std.fract": () => fract,
-		"std.mix": () => mix,
 		"std.fwidth": () => fwidth,
-		"bandMask": () => bandMask,
+		"brickMortarMask": () => brickMortarMask,
 		"d.vec2f": () => vec2f,
 		"cellVariation": () => cellVariation
 	}
@@ -8983,15 +9288,6 @@ function shared(build) {
 		return e;
 	};
 }
-function paintFrame(params) {
-	return {
-		uv: params.uvContext ?? params.ctx.uv,
-		viewport: params.effectiveViewportSize ?? params.ctx.viewportSize
-	};
-}
-function mixColorsIn(space, params) {
-	return mixColorsVariants[space ? colorSpaceModeOf(params.propValues[space.name]) : 0] ?? mixColorsLinear;
-}
 var FRAME_BODIES = {
 	flippedY: {
 		fn: () => latticeFrameFlipY,