shaders 3.1.462 → 3.2.464

package/dist/core/{Shatter-CSR4Hrfn.js → Shatter-DQ1i7GCD.js}

@@ -1,399 +1,417 @@
-import { Ft as vec3f, Gt as textureStorage2d, Kt as arrayOf, Lt as vec4f, Mt as vec2f, Ot as smoothstep, P as unpremultiplyAlpha, Pt as vec2u, bt as normalize, d as ZERO, et as typegpu_default, gt as length, ln as u32, m as call, qt as struct, sn as f32, t as applyEdgeHandlingExpr, v as floatE } from "./edges-CV-BHMpI.js";
-import { A as toHalfFloat, M as createGuardedCompute, P as createStateBuffer, R as textureStore } from "./device-DKcu50_C.js";
-import { s as transformEdges } from "./transformations-u-UZrXjj.js";
-var seededRandom = (seed) => {
-	const x = Math.sin(seed) * 1e4;
-	return x - Math.floor(x);
-};
-var SHARD_COUNT = 16;
-var VORONOI_SIZE = 1024;
+import { $n as vec4f, Jn as vec2f, K as createStateBuffer, Nn as length, Pn as max, R as toHalfFloat, Tt as unpremultiplyAlpha, W as createGuardedCompute, Wn as smoothstep, Xn as vec2u, Zn as vec3f, _r as u32, ar as textureStorage2d, at as call, hr as f32, lt as floatE, mn as typegpu_default, nt as ZERO, or as arrayOf, q as applyEdgeHandlingExpr, sr as struct, t as defineStd, vn as textureStore } from "./lower-z2vuXP8M.js";
+import { s as transformEdges } from "./transformations-CoIwF5JU.js";
 var VORONOI_FORMAT = "rgba16float";
-var DATA_WIDTH = SHARD_COUNT * 4;
-var voronoiLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_default.bindGroupLayout({
-	cellPos: {
-		storage: arrayOf(f32, SHARD_COUNT * 2),
-		access: "readonly"
-	},
-	voronoiTex: { storageTexture: textureStorage2d(VORONOI_FORMAT, "write-only") }
-}), "voronoiLayout");
-const voronoiKernel = typegpu_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-	"use gpu";
-	const u = __tsover_div(__tsover_add(f32(cx), .5), VORONOI_SIZE);
-	const v = __tsover_div(__tsover_add(f32(cy), .5), VORONOI_SIZE);
-	let d1 = f32(99999);
-	let d2 = f32(99999);
-	let idx1 = f32(0);
-	let idx2 = f32(0);
-	for (let i = 0; i < SHARD_COUNT; i++) {
-		const cellX = voronoiLayout.$.cellPos[__tsover_mul(i, 2)];
-		const cellY = voronoiLayout.$.cellPos[__tsover_add(__tsover_mul(i, 2), 1)];
-		const ddx = __tsover_sub(u, cellX);
-		const ddy = __tsover_sub(v, cellY);
-		const distSq = __tsover_add(__tsover_mul(ddx, ddx), __tsover_mul(ddy, ddy));
-		if (distSq < d1) {
-			d2 = d1;
-			idx2 = idx1;
-			d1 = distSq;
-			idx1 = f32(i);
-		} else if (distSq < d2) {
-			d2 = distSq;
-			idx2 = f32(i);
-		}
-	}
-	textureStore(voronoiLayout.$.voronoiTex, vec2u(cx, cy), vec4f(idx1, idx2, 0, 0));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "cx"
-		}, {
-			"type": "i",
-			"name": "cy"
-		}],
-		"body": [0, [
-			[
-				13,
-				"u",
-				[
-					1,
-					[
-						1,
-						[
-							6,
-							"d.f32",
-							["cx"]
-						],
-						"+",
-						[5, "0.5"]
-					],
-					"/",
-					"VORONOI_SIZE"
-				]
-			],
-			[
-				13,
-				"v",
-				[
-					1,
-					[
-						1,
-						[
-							6,
-							"d.f32",
-							["cy"]
-						],
-						"+",
-						[5, "0.5"]
-					],
-					"/",
-					"VORONOI_SIZE"
-				]
-			],
-			[
-				12,
-				"d1",
-				[
-					6,
-					"d.f32",
-					[[5, "99999"]]
-				]
-			],
-			[
-				12,
-				"d2",
-				[
-					6,
-					"d.f32",
-					[[5, "99999"]]
-				]
-			],
-			[
-				12,
-				"idx1",
-				[
-					6,
-					"d.f32",
-					[[5, "0"]]
-				]
-			],
-			[
-				12,
-				"idx2",
-				[
-					6,
-					"d.f32",
-					[[5, "0"]]
-				]
-			],
-			[
-				14,
-				[
-					12,
-					"i",
-					[5, "0"]
-				],
-				[
-					1,
-					"i",
-					"<",
-					"SHARD_COUNT"
-				],
-				[
-					102,
-					"++",
-					"i"
-				],
-				[0, [
+function makeVoronoiGraph(count, size) {
+	const layout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_default.bindGroupLayout({
+		cellPos: {
+			storage: arrayOf(f32, count * 2),
+			access: "readonly"
+		},
+		voronoiTex: { storageTexture: textureStorage2d(VORONOI_FORMAT, "write-only") }
+	}), "layout");
+	return {
+		layout,
+		kernel: typegpu_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+			"use gpu";
+			const u = __tsover_div(__tsover_add(f32(cx), .5), size);
+			const v = __tsover_div(__tsover_add(f32(cy), .5), size);
+			let d1 = f32(99999);
+			let d2 = f32(99999);
+			let idx1 = f32(0);
+			let idx2 = f32(0);
+			for (let i = 0; i < count; i++) {
+				const cellX = layout.$.cellPos[__tsover_mul(i, 2)];
+				const cellY = layout.$.cellPos[__tsover_add(__tsover_mul(i, 2), 1)];
+				const ddx = __tsover_sub(u, cellX);
+				const ddy = __tsover_sub(v, cellY);
+				const distSq = __tsover_add(__tsover_mul(ddx, ddx), __tsover_mul(ddy, ddy));
+				if (distSq < d1) {
+					d2 = d1;
+					idx2 = idx1;
+					d1 = distSq;
+					idx1 = f32(i);
+				} else if (distSq < d2) {
+					d2 = distSq;
+					idx2 = f32(i);
+				}
+			}
+			textureStore(layout.$.voronoiTex, vec2u(cx, cy), vec4f(idx1, idx2, 0, 0));
+		}), {
+			v: 2,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "cx"
+				}, {
+					"type": "i",
+					"name": "cy"
+				}],
+				"body": [0, [
 					[
 						13,
-						"cellX",
+						"u",
 						[
-							8,
+							1,
 							[
-								7,
+								1,
 								[
-									7,
-									"voronoiLayout",
-									"$"
+									6,
+									"d.f32",
+									["cx"]
 								],
-								"cellPos"
+								"+",
+								[5, "0.5"]
 							],
-							[
-								1,
-								"i",
-								"*",
-								[5, "2"]
-							]
+							"/",
+							"size"
 						]
 					],
 					[
 						13,
-						"cellY",
+						"v",
 						[
-							8,
-							[
-								7,
-								[
-									7,
-									"voronoiLayout",
-									"$"
-								],
-								"cellPos"
-							],
+							1,
 							[
 								1,
 								[
-									1,
-									"i",
-									"*",
-									[5, "2"]
+									6,
+									"d.f32",
+									["cy"]
 								],
 								"+",
-								[5, "1"]
-							]
+								[5, "0.5"]
+							],
+							"/",
+							"size"
 						]
 					],
 					[
-						13,
-						"ddx",
+						12,
+						"d1",
 						[
-							1,
-							"u",
-							"-",
-							"cellX"
+							6,
+							"d.f32",
+							[[5, "99999"]]
 						]
 					],
 					[
-						13,
-						"ddy",
+						12,
+						"d2",
 						[
-							1,
-							"v",
-							"-",
-							"cellY"
+							6,
+							"d.f32",
+							[[5, "99999"]]
 						]
 					],
 					[
-						13,
-						"distSq",
+						12,
+						"idx1",
 						[
-							1,
-							[
-								1,
-								"ddx",
-								"*",
-								"ddx"
-							],
-							"+",
-							[
-								1,
-								"ddy",
-								"*",
-								"ddy"
-							]
+							6,
+							"d.f32",
+							[[5, "0"]]
 						]
 					],
 					[
-						11,
+						12,
+						"idx2",
+						[
+							6,
+							"d.f32",
+							[[5, "0"]]
+						]
+					],
+					[
+						14,
+						[
+							12,
+							"i",
+							[5, "0"]
+						],
 						[
 							1,
-							"distSq",
+							"i",
 							"<",
-							"d1"
+							"count"
+						],
+						[
+							102,
+							"++",
+							"i"
 						],
 						[0, [
 							[
-								2,
-								"d2",
-								"=",
-								"d1"
+								13,
+								"cellX",
+								[
+									8,
+									[
+										7,
+										[
+											7,
+											"layout",
+											"$"
+										],
+										"cellPos"
+									],
+									[
+										1,
+										"i",
+										"*",
+										[5, "2"]
+									]
+								]
 							],
 							[
-								2,
-								"idx2",
-								"=",
-								"idx1"
+								13,
+								"cellY",
+								[
+									8,
+									[
+										7,
+										[
+											7,
+											"layout",
+											"$"
+										],
+										"cellPos"
+									],
+									[
+										1,
+										[
+											1,
+											"i",
+											"*",
+											[5, "2"]
+										],
+										"+",
+										[5, "1"]
+									]
+								]
 							],
 							[
-								2,
-								"d1",
-								"=",
-								"distSq"
+								13,
+								"ddx",
+								[
+									1,
+									"u",
+									"-",
+									"cellX"
+								]
 							],
 							[
-								2,
-								"idx1",
-								"=",
+								13,
+								"ddy",
 								[
-									6,
-									"d.f32",
-									["i"]
+									1,
+									"v",
+									"-",
+									"cellY"
 								]
-							]
-						]],
-						[0, [[
-							11,
+							],
 							[
-								1,
+								13,
 								"distSq",
-								"<",
-								"d2"
-							],
-							[0, [[
-								2,
-								"d2",
-								"=",
-								"distSq"
-							], [
-								2,
-								"idx2",
-								"=",
 								[
-									6,
-									"d.f32",
-									["i"]
+									1,
+									[
+										1,
+										"ddx",
+										"*",
+										"ddx"
+									],
+									"+",
+									[
+										1,
+										"ddy",
+										"*",
+										"ddy"
+									]
 								]
-							]]]
-						]]]
-					]
-				]]
-			],
-			[
-				6,
-				"std.textureStore",
-				[
-					[
-						7,
-						[
-							7,
-							"voronoiLayout",
-							"$"
-						],
-						"voronoiTex"
-					],
-					[
-						6,
-						"d.vec2u",
-						["cx", "cy"]
+							],
+							[
+								11,
+								[
+									1,
+									"distSq",
+									"<",
+									"d1"
+								],
+								[0, [
+									[
+										2,
+										"d2",
+										"=",
+										"d1"
+									],
+									[
+										2,
+										"idx2",
+										"=",
+										"idx1"
+									],
+									[
+										2,
+										"d1",
+										"=",
+										"distSq"
+									],
+									[
+										2,
+										"idx1",
+										"=",
+										[
+											6,
+											"d.f32",
+											["i"]
+										]
+									]
+								]],
+								[0, [[
+									11,
+									[
+										1,
+										"distSq",
+										"<",
+										"d2"
+									],
+									[0, [[
+										2,
+										"d2",
+										"=",
+										"distSq"
+									], [
+										2,
+										"idx2",
+										"=",
+										[
+											6,
+											"d.f32",
+											["i"]
+										]
+									]]]
+								]]]
+							]
+						]]
 					],
 					[
 						6,
-						"d.vec4f",
+						"std.textureStore",
 						[
-							"idx1",
-							"idx2",
-							[5, "0"],
-							[5, "0"]
+							[
+								7,
+								[
+									7,
+									"layout",
+									"$"
+								],
+								"voronoiTex"
+							],
+							[
+								6,
+								"d.vec2u",
+								["cx", "cy"]
+							],
+							[
+								6,
+								"d.vec4f",
+								[
+									"idx1",
+									"idx2",
+									[5, "0"],
+									[5, "0"]
+								]
+							]
 						]
 					]
-				]
-			]
-		]]
-	},
-	externals: {
-		"d.f32": () => f32,
-		"VORONOI_SIZE": () => VORONOI_SIZE,
-		"SHARD_COUNT": () => SHARD_COUNT,
-		"voronoiLayout": () => voronoiLayout,
-		"std.textureStore": () => textureStore,
-		"d.vec2u": () => vec2u,
-		"d.vec4f": () => vec4f
+				]]
+			},
+			externals: {
+				"d.f32": () => f32,
+				"size": () => size,
+				"count": () => count,
+				"layout": () => layout,
+				"std.textureStore": () => textureStore,
+				"d.vec2u": () => vec2u,
+				"d.vec4f": () => vec4f
+			}
+		}) && $.f)({})).$name("voronoiNearest2")
+	};
+}
+var voronoiGraphCache = /* @__PURE__ */ new Map();
+function voronoiNearest2Graph(count, size) {
+	const key = `${count}|${size}`;
+	let g = voronoiGraphCache.get(key);
+	if (!g) {
+		g = makeVoronoiGraph(count, size);
+		voronoiGraphCache.set(key, g);
 	}
-}) && $.f)({})).$name("shatterVoronoi");
-const cellDataUV = typegpu_default.fn([f32, f32], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((idx, field) => {
-	"use gpu";
-	return vec2f(__tsover_div(__tsover_add(__tsover_add(__tsover_mul(idx, 4), field), .5), DATA_WIDTH), .5);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "idx"
-		}, {
-			"type": "i",
-			"name": "field"
-		}],
-		"body": [0, [[10, [
-			6,
-			"d.vec2f",
-			[[
-				1,
-				[
+	return g;
+}
+var cellLaneUVCache = /* @__PURE__ */ new Map();
+function makeCellLaneUV(laneWidth) {
+	return typegpu_default.fn([f32, f32], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((idx, field) => {
+		"use gpu";
+		return vec2f(__tsover_div(__tsover_add(__tsover_add(__tsover_mul(idx, 4), field), .5), laneWidth), .5);
+	}), {
+		v: 2,
+		name: void 0,
+		ast: {
+			"params": [{
+				"type": "i",
+				"name": "idx"
+			}, {
+				"type": "i",
+				"name": "field"
+			}],
+			"body": [0, [[10, [
+				6,
+				"d.vec2f",
+				[[
 					1,
 					[
 						1,
 						[
 							1,
-							"idx",
-							"*",
-							[5, "4"]
+							[
+								1,
+								"idx",
+								"*",
+								[5, "4"]
+							],
+							"+",
+							"field"
 						],
 						"+",
-						"field"
+						[5, "0.5"]
 					],
-					"+",
-					[5, "0.5"]
-				],
-				"/",
-				"DATA_WIDTH"
-			], [5, "0.5"]]
-		]]]]
-	},
-	externals: {
-		"d.vec2f": () => vec2f,
-		"DATA_WIDTH": () => DATA_WIDTH
+					"/",
+					"laneWidth"
+				], [5, "0.5"]]
+			]]]]
+		},
+		externals: {
+			"d.vec2f": () => vec2f,
+			"laneWidth": () => laneWidth
+		}
+	}) && $.f)({}));
+}
+function cellLaneUVFor(laneWidth) {
+	let fn = cellLaneUVCache.get(laneWidth);
+	if (!fn) {
+		fn = makeCellLaneUV(laneWidth);
+		cellLaneUVCache.set(laneWidth, fn);
 	}
-}) && $.f)({}));
-const ShatterGeom = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+	return fn;
+}
+const CrackGeom = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
 	crackIntensity: f32,
 	edgeNormal: vec2f,
 	displacedUV: vec2f,
 	disp: vec2f
-}), "ShatterGeom");
-const shatterGeom = typegpu_default.fn([
+}), "CrackGeom");
+const crackGeom = typegpu_default.fn([
 	vec2f,
 	f32,
 	f32,
@@ -402,12 +420,13 @@ const shatterGeom = typegpu_default.fn([
 	f32,
 	f32,
 	f32
-], ShatterGeom)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, nPosX, nPosY, sPosX, sPosY, dispX, dispY, crackWidth) => {
+], CrackGeom)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, nPosX, nPosY, sPosX, sPosY, dispX, dispY, crackWidth) => {
 	"use gpu";
 	const nearestPos = vec2f(nPosX, nPosY);
 	const secondPos = vec2f(sPosX, sPosY);
 	const disp = vec2f(dispX, dispY);
-	const minDist1 = length(uv.sub(nearestPos));
+	const fromNearest = uv.sub(nearestPos);
+	const minDist1 = length(fromNearest);
 	const minDist2 = length(uv.sub(secondPos));
 	const displacementMag = length(disp);
 	const edgeDiff = __tsover_sub(minDist2, minDist1);
@@ -415,8 +434,8 @@ const shatterGeom = typegpu_default.fn([
 	const baseCrackIntensity = __tsover_sub(1, smoothstep(0, crackThreshold, edgeDiff));
 	const displacementFactor = smoothstep(0, .01, displacementMag);
 	const crackIntensity = __tsover_mul(baseCrackIntensity, displacementFactor);
-	const toNearest = normalize(uv.sub(nearestPos));
-	return ShatterGeom({
+	const toNearest = fromNearest.div(max(minDist1, 1e-5));
+	return CrackGeom({
 		crackIntensity,
 		edgeNormal: vec2f(__tsover_mul(toNearest.y, -1), toNearest.x),
 		displacedUV: uv.sub(disp),
@@ -488,21 +507,26 @@ const shatterGeom = typegpu_default.fn([
 					["dispX", "dispY"]
 				]
 			],
+			[
+				13,
+				"fromNearest",
+				[
+					6,
+					[
+						7,
+						"uv",
+						"sub"
+					],
+					["nearestPos"]
+				]
+			],
 			[
 				13,
 				"minDist1",
 				[
 					6,
 					"std.length",
-					[[
-						6,
-						[
-							7,
-							"uv",
-							"sub"
-						],
-						["nearestPos"]
-					]]
+					["fromNearest"]
 				]
 			],
 			[
@@ -597,15 +621,15 @@ const shatterGeom = typegpu_default.fn([
 				"toNearest",
 				[
 					6,
-					"std.normalize",
-					[[
-						6,
-						[
-							7,
-							"uv",
-							"sub"
-						],
-						["nearestPos"]
+					[
+						7,
+						"fromNearest",
+						"div"
+					],
+					[[
+						6,
+						"std.max",
+						["minDist1", [5, "0.00001"]]
 					]]
 				]
 			],
@@ -650,7 +674,7 @@ const shatterGeom = typegpu_default.fn([
 			],
 			[10, [
 				6,
-				"ShatterGeom",
+				"CrackGeom",
 				[[104, {
 					"crackIntensity": "crackIntensity",
 					"edgeNormal": "edgeNormal",
@@ -664,11 +688,11 @@ const shatterGeom = typegpu_default.fn([
 		"d.vec2f": () => vec2f,
 		"std.length": () => length,
 		"std.smoothstep": () => smoothstep,
-		"std.normalize": () => normalize,
-		"ShatterGeom": () => ShatterGeom
+		"std.max": () => max,
+		"CrackGeom": () => CrackGeom
 	}
 }) && $.f)({}));
-const shatterRefractUV = typegpu_default.fn([
+const crackRefractUV = typegpu_default.fn([
 	vec2f,
 	vec2f,
 	f32,
@@ -793,7 +817,9 @@ const shatterRefractUV = typegpu_default.fn([
 	},
 	externals: {}
 }) && $.f)({}));
-const shatterCompose = typegpu_default.fn([
+var SHARD_LIGHT_DIR_X = .3 / Math.hypot(.3, .6);
+var SHARD_LIGHT_DIR_Y = .6 / Math.hypot(.3, .6);
+const crackShardCompose = typegpu_default.fn([
 	vec4f,
 	vec4f,
 	vec4f,
@@ -808,8 +834,7 @@ const shatterCompose = typegpu_default.fn([
 	const displacementLength = length(disp);
 	const tiltX = __tsover_div(disp.x, __tsover_add(displacementLength, .001));
 	const tiltY = __tsover_div(disp.y, __tsover_add(displacementLength, .001));
-	const lightDir3D = normalize(vec2f(.3, .6));
-	const normalDot = __tsover_add(__tsover_mul(tiltX, lightDir3D.x), __tsover_mul(tiltY, lightDir3D.y));
+	const normalDot = __tsover_add(__tsover_mul(tiltX, SHARD_LIGHT_DIR_X), __tsover_mul(tiltY, SHARD_LIGHT_DIR_Y));
 	const lightingFactor = __tsover_add(1, __tsover_mul(normalDot, shardLighting));
 	const lightingIntensity = smoothstep(0, .02, displacementLength);
 	const finalLighting = __tsover_add(1, __tsover_mul(__tsover_sub(lightingFactor, 1), lightingIntensity));
@@ -959,19 +984,6 @@ const shatterCompose = typegpu_default.fn([
 					]
 				]
 			],
-			[
-				13,
-				"lightDir3D",
-				[
-					6,
-					"std.normalize",
-					[[
-						6,
-						"d.vec2f",
-						[[5, "0.3"], [5, "0.6"]]
-					]]
-				]
-			],
 			[
 				13,
 				"normalDot",
@@ -981,22 +993,14 @@ const shatterCompose = typegpu_default.fn([
 						1,
 						"tiltX",
 						"*",
-						[
-							7,
-							"lightDir3D",
-							"x"
-						]
+						"SHARD_LIGHT_DIR_X"
 					],
 					"+",
 					[
 						1,
 						"tiltY",
 						"*",
-						[
-							7,
-							"lightDir3D",
-							"y"
-						]
+						"SHARD_LIGHT_DIR_Y"
 					]
 				]
 			],
@@ -1075,14 +1079,204 @@ const shatterCompose = typegpu_default.fn([
 	externals: {
 		"d.vec3f": () => vec3f,
 		"std.length": () => length,
-		"std.normalize": () => normalize,
-		"d.vec2f": () => vec2f,
+		"SHARD_LIGHT_DIR_X": () => SHARD_LIGHT_DIR_X,
+		"SHARD_LIGHT_DIR_Y": () => SHARD_LIGHT_DIR_Y,
 		"std.smoothstep": () => smoothstep,
 		"d.vec4f": () => vec4f
 	}
 }) && $.f)({}));
-const componentDefinition = {
+function voronoiRegionField(opts) {
+	return (params) => {
+		const { gpu, registerComputeTexture, getCpuValue, onCleanup } = params;
+		const root = gpu?.root;
+		if (!root) return null;
+		const { layout, kernel } = voronoiNearest2Graph(opts.count, opts.size);
+		const cellPos = createStateBuffer(root, f32, opts.count * 2);
+		const voronoiTex = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
+			size: [opts.size, opts.size],
+			format: VORONOI_FORMAT
+		}).$usage("storage", "sampled"), "voronoiTex");
+		onCleanup(() => voronoiTex.destroy());
+		const field = registerComputeTexture(voronoiTex);
+		const bindGroup = root.createBindGroup(layout, {
+			cellPos,
+			voronoiTex
+		});
+		const pipeline = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+			"use gpu";
+			kernel(cx, cy);
+		}), {
+			v: 2,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "cx"
+				}, {
+					"type": "i",
+					"name": "cy"
+				}],
+				"body": [0, [[
+					6,
+					"kernel",
+					["cx", "cy"]
+				]]]
+			},
+			externals: { "kernel": () => kernel }
+		}) && $.f)({}), {
+			size: [opts.size, opts.size],
+			bindGroup
+		});
+		const generateCells = (seed) => {
+			cellPos.write(opts.sites(seed));
+		};
+		let currentSeed = getCpuValue(opts.seedProp) ?? opts.seedDefault;
+		generateCells(currentSeed);
+		let needsDispatch = true;
+		return {
+			outputs: { [opts.output]: field },
+			getComputeNodes: () => {
+				const newSeed = getCpuValue(opts.seedProp) ?? opts.seedDefault;
+				if (newSeed !== currentSeed) {
+					currentSeed = newSeed;
+					generateCells(currentSeed);
+					needsDispatch = true;
+				}
+				if (needsDispatch) {
+					needsDispatch = false;
+					return [pipeline];
+				}
+				return null;
+			}
+		};
+	};
+}
+var seededRandom = (seed) => {
+	const x = Math.sin(seed) * 1e4;
+	return x - Math.floor(x);
+};
+var SHARD_COUNT = 16;
+var VORONOI_SIZE = 1024;
+var DATA_WIDTH = SHARD_COUNT * 4;
+var cellLaneUV = cellLaneUVFor(DATA_WIDTH);
+var shardSites = (seed) => {
+	const positions = new Float32Array(SHARD_COUNT * 2);
+	for (let i = 0; i < SHARD_COUNT; i++) {
+		positions[i * 2] = seededRandom(seed + i * 2);
+		positions[i * 2 + 1] = seededRandom(seed + i * 2 + 1);
+	}
+	return positions;
+};
+function shardPhysics(getCpuValue) {
+	const cellData = new Float32Array(SHARD_COUNT * 4);
+	const displacementData = new Float32Array(SHARD_COUNT * 4);
+	const generateCells = (seed) => {
+		const sites = shardSites(seed);
+		for (let i = 0; i < SHARD_COUNT; i++) {
+			cellData[i * 4] = sites[i * 2];
+			cellData[i * 4 + 1] = sites[i * 2 + 1];
+			cellData[i * 4 + 2] = seededRandom(seed + i * 3);
+			cellData[i * 4 + 3] = seededRandom(seed + i * 3 + 1);
+		}
+	};
+	let currentSeed = getCpuValue("seed") ?? 2;
+	generateCells(currentSeed);
+	const FRICTION = 1;
+	let prevX = .5;
+	let prevY = .5;
+	return {
+		cellData,
+		displacementData,
+		step(pointer, deltaTime, aspect) {
+			const dt = Math.min(deltaTime, .016);
+			const newSeed = getCpuValue("seed") ?? 2;
+			if (newSeed !== currentSeed) {
+				currentSeed = newSeed;
+				generateCells(currentSeed);
+				displacementData.fill(0);
+			}
+			const intensity = getCpuValue("intensity") ?? 4;
+			const radius = getCpuValue("radius") ?? .4;
+			const decay = getCpuValue("decay") ?? 1;
+			let velX = dt > 0 ? (pointer.x - prevX) / dt : 0;
+			let velY = dt > 0 ? (pointer.y - prevY) / dt : 0;
+			let speed = Math.sqrt(velX * velX + velY * velY);
+			const maxVelocity = 5 + intensity * 2;
+			if (speed > maxVelocity) {
+				const scale = maxVelocity / speed;
+				velX *= scale;
+				velY *= scale;
+				speed = maxVelocity;
+			}
+			for (let i = 0; i < SHARD_COUNT; i++) {
+				const cellX = cellData[i * 4];
+				const cellY = cellData[i * 4 + 1];
+				const randomDirX = cellData[i * 4 + 2] - .5;
+				const randomDirY = cellData[i * 4 + 3] - .5;
+				const dx = aspect >= 1 ? (cellX - pointer.x) * aspect : cellX - pointer.x;
+				const dy = aspect >= 1 ? cellY - pointer.y : (cellY - pointer.y) / aspect;
+				const dist = Math.sqrt(dx * dx + dy * dy);
+				let currentDx = displacementData[i * 4];
+				let currentDy = displacementData[i * 4 + 1];
+				const decayTime = Math.max(.01, decay);
+				const decayFactor = Math.exp(-dt / decayTime);
+				currentDx *= decayFactor;
+				currentDy *= decayFactor;
+				let velocityDx = 0;
+				let velocityDy = 0;
+				if (dist < radius && speed > .01) {
+					const influence = Math.max(0, 1 - dist / radius);
+					const influenceCurve = influence * influence;
+					const pushForce = influenceCurve * speed * intensity * dt * .5;
+					velocityDx = velX * pushForce;
+					velocityDy = velY * pushForce;
+					const jitterForce = influenceCurve * speed * intensity * dt * .1;
+					velocityDx += randomDirX * jitterForce;
+					velocityDy += randomDirY * jitterForce;
+				}
+				const lerpFactor = Math.min(1, FRICTION * dt);
+				displacementData[i * 4] = currentDx + velocityDx * lerpFactor;
+				displacementData[i * 4 + 1] = currentDy + velocityDy * lerpFactor;
+			}
+			prevX = pointer.x;
+			prevY = pointer.y;
+		}
+	};
+}
+function shardDataTexture(params, physics) {
+	const { createDataTexture, registerMediaTexture, onCleanup } = params;
+	const dataMirror = new Float32Array(DATA_WIDTH);
+	const texData = new Uint16Array(DATA_WIDTH);
+	const packMirror = () => {
+		for (let i = 0; i < SHARD_COUNT; i++) {
+			dataMirror[i * 4] = physics.cellData[i * 4];
+			dataMirror[i * 4 + 1] = physics.cellData[i * 4 + 1];
+			dataMirror[i * 4 + 2] = physics.displacementData[i * 4];
+			dataMirror[i * 4 + 3] = physics.displacementData[i * 4 + 1];
+		}
+		for (let i = 0; i < DATA_WIDTH; i++) texData[i] = toHalfFloat(dataMirror[i]);
+	};
+	packMirror();
+	const dataTex = createDataTexture({
+		width: DATA_WIDTH,
+		height: 1,
+		format: "r16float",
+		data: texData,
+		label: "shatter-cells"
+	});
+	onCleanup(() => dataTex.destroy());
+	return {
+		dataKit: registerMediaTexture(() => dataTex.texture),
+		upload() {
+			packMirror();
+			dataTex.write(texData);
+		}
+	};
+}
+const componentDefinition = defineStd({
 	name: "Shatter",
+	role: "simulation",
+	species: "custom",
 	boundingBoxDeclaration: { aspectRatio: null },
 	category: "Interactive",
 	description: "Broken glass effect with tectonic plate displacement",
@@ -1216,182 +1410,37 @@ const componentDefinition = {
 			}
 		}
 	},
-	compute: (params) => {
-		const { gpu, registerComputeTexture, getCpuValue, onCleanup } = params;
-		const root = gpu?.root;
-		if (!root) return null;
-		const cellPos = createStateBuffer(root, f32, SHARD_COUNT * 2);
-		const voronoiTex = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
-			size: [VORONOI_SIZE, VORONOI_SIZE],
-			format: VORONOI_FORMAT
-		}).$usage("storage", "sampled"), "voronoiTex");
-		onCleanup(() => voronoiTex.destroy());
-		const voronoiField = registerComputeTexture(voronoiTex);
-		const bindGroup = root.createBindGroup(voronoiLayout, {
-			cellPos,
-			voronoiTex
-		});
-		const pipeline = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-			"use gpu";
-			voronoiKernel(cx, cy);
-		}), {
-			v: 2,
-			name: void 0,
-			ast: {
-				"params": [{
-					"type": "i",
-					"name": "cx"
-				}, {
-					"type": "i",
-					"name": "cy"
-				}],
-				"body": [0, [[
-					6,
-					"voronoiKernel",
-					["cx", "cy"]
-				]]]
-			},
-			externals: { "voronoiKernel": () => voronoiKernel }
-		}) && $.f)({}), {
-			size: [VORONOI_SIZE, VORONOI_SIZE],
-			bindGroup
-		});
-		const generateCells = (seed) => {
-			const positions = new Float32Array(SHARD_COUNT * 2);
-			for (let i = 0; i < SHARD_COUNT; i++) {
-				positions[i * 2] = seededRandom(seed + i * 2);
-				positions[i * 2 + 1] = seededRandom(seed + i * 2 + 1);
-			}
-			cellPos.write(positions);
-		};
-		let currentSeed = getCpuValue("seed") ?? 2;
-		generateCells(currentSeed);
-		let needsDispatch = true;
-		return {
-			outputs: { voronoiField },
-			getComputeNodes: () => {
-				const newSeed = getCpuValue("seed") ?? 2;
-				if (newSeed !== currentSeed) {
-					currentSeed = newSeed;
-					generateCells(currentSeed);
-					needsDispatch = true;
-				}
-				if (needsDispatch) {
-					needsDispatch = false;
-					return [pipeline];
-				}
-				return null;
-			}
-		};
-	},
-	fragment: (params) => {
+	compute: voronoiRegionField({
+		count: SHARD_COUNT,
+		size: VORONOI_SIZE,
+		sites: shardSites,
+		seedProp: "seed",
+		seedDefault: 2,
+		output: "voronoiField"
+	}),
+	gpu: { fragment: (params) => {
 		const { childNode, ctx, computeOutputs, propValues, convertToTexture } = params;
 		if (!childNode) return ZERO;
 		const child = convertToTexture(childNode);
 		const voronoiField = computeOutputs?.voronoiField;
 		if (!voronoiField) return call(unpremultiplyAlpha, "unpremultiplyAlpha", [child.sample(ctx.uv)]);
-		const { createDataTexture, registerMediaTexture, onBeforeRender, onCleanup, getCpuValue, dimensions } = params;
+		const { onBeforeRender, getCpuValue, dimensions } = params;
 		const edgeMode = propValues.edges ?? 0;
-		const dataMirror = new Float32Array(DATA_WIDTH);
-		const texData = new Uint16Array(DATA_WIDTH);
-		const cellData = new Float32Array(SHARD_COUNT * 4);
-		const displacementData = new Float32Array(SHARD_COUNT * 4);
-		const generateCells = (seed) => {
-			for (let i = 0; i < SHARD_COUNT; i++) {
-				cellData[i * 4] = seededRandom(seed + i * 2);
-				cellData[i * 4 + 1] = seededRandom(seed + i * 2 + 1);
-				cellData[i * 4 + 2] = seededRandom(seed + i * 3);
-				cellData[i * 4 + 3] = seededRandom(seed + i * 3 + 1);
-			}
-		};
-		const packMirror = () => {
-			for (let i = 0; i < SHARD_COUNT; i++) {
-				dataMirror[i * 4] = cellData[i * 4];
-				dataMirror[i * 4 + 1] = cellData[i * 4 + 1];
-				dataMirror[i * 4 + 2] = displacementData[i * 4];
-				dataMirror[i * 4 + 3] = displacementData[i * 4 + 1];
-			}
-			for (let i = 0; i < DATA_WIDTH; i++) texData[i] = toHalfFloat(dataMirror[i]);
-		};
-		let currentSeed = getCpuValue("seed") ?? 2;
-		generateCells(currentSeed);
-		packMirror();
-		const dataTex = createDataTexture({
-			width: DATA_WIDTH,
-			height: 1,
-			format: "r16float",
-			data: texData,
-			label: "shatter-cells"
-		});
-		onCleanup(() => dataTex.destroy());
-		const dataKit = registerMediaTexture(() => dataTex.texture);
-		const FRICTION = 1;
-		let prevX = .5;
-		let prevY = .5;
+		const physics = shardPhysics(getCpuValue);
+		const cells = shardDataTexture(params, physics);
+		const dataKit = cells.dataKit;
 		onBeforeRender((fp) => {
 			const { pointer, deltaTime } = fp;
-			const dt = Math.min(deltaTime, .016);
 			const aspect = dimensions.width / Math.max(1, dimensions.height);
-			const newSeed = getCpuValue("seed") ?? 2;
-			if (newSeed !== currentSeed) {
-				currentSeed = newSeed;
-				generateCells(currentSeed);
-				displacementData.fill(0);
-			}
-			const intensity = getCpuValue("intensity") ?? 4;
-			const radius = getCpuValue("radius") ?? .4;
-			const decay = getCpuValue("decay") ?? 1;
-			let velX = dt > 0 ? (pointer.x - prevX) / dt : 0;
-			let velY = dt > 0 ? (pointer.y - prevY) / dt : 0;
-			let speed = Math.sqrt(velX * velX + velY * velY);
-			const maxVelocity = 5 + intensity * 2;
-			if (speed > maxVelocity) {
-				const scale = maxVelocity / speed;
-				velX *= scale;
-				velY *= scale;
-				speed = maxVelocity;
-			}
-			for (let i = 0; i < SHARD_COUNT; i++) {
-				const cellX = cellData[i * 4];
-				const cellY = cellData[i * 4 + 1];
-				const randomDirX = cellData[i * 4 + 2] - .5;
-				const randomDirY = cellData[i * 4 + 3] - .5;
-				const dx = aspect >= 1 ? (cellX - pointer.x) * aspect : cellX - pointer.x;
-				const dy = aspect >= 1 ? cellY - pointer.y : (cellY - pointer.y) / aspect;
-				const dist = Math.sqrt(dx * dx + dy * dy);
-				let currentDx = displacementData[i * 4];
-				let currentDy = displacementData[i * 4 + 1];
-				const decayTime = Math.max(.01, decay);
-				const decayFactor = Math.exp(-dt / decayTime);
-				currentDx *= decayFactor;
-				currentDy *= decayFactor;
-				let velocityDx = 0;
-				let velocityDy = 0;
-				if (dist < radius && speed > .01) {
-					const influence = Math.max(0, 1 - dist / radius);
-					const influenceCurve = influence * influence;
-					const pushForce = influenceCurve * speed * intensity * dt * .5;
-					velocityDx = velX * pushForce;
-					velocityDy = velY * pushForce;
-					const jitterForce = influenceCurve * speed * intensity * dt * .1;
-					velocityDx += randomDirX * jitterForce;
-					velocityDy += randomDirY * jitterForce;
-				}
-				const lerpFactor = Math.min(1, FRICTION * dt);
-				displacementData[i * 4] = currentDx + velocityDx * lerpFactor;
-				displacementData[i * 4 + 1] = currentDy + velocityDy * lerpFactor;
-			}
-			packMirror();
-			dataTex.write(texData);
-			prevX = pointer.x;
-			prevY = pointer.y;
+			physics.step(pointer, deltaTime, aspect);
+			cells.upload();
 		});
 		const vSample = voronoiField.sample(ctx.uv, "nearestClamp");
 		const nearestI = vSample.member("r");
 		const secondI = vSample.member("g");
 		const nearestClamp = "nearestClamp";
-		const dataAt = (idx, field) => dataKit.sample(call(cellDataUV, "cellDataUV", [idx, floatE(field)]), nearestClamp).member("r");
-		const geom = call(shatterGeom, "shatterGeom", [
+		const dataAt = (idx, field) => dataKit.sample(call(cellLaneUV, "cellLaneUV", [idx, floatE(field)]), nearestClamp).member("r");
+		const geom = call(crackGeom, "crackGeom", [
 			ctx.uv,
 			dataAt(nearestI, 0),
 			dataAt(nearestI, 1),
@@ -1407,7 +1456,7 @@ const componentDefinition = {
 		const disp = geom.member("disp");
 		const sample = (uv) => applyEdgeHandlingExpr(uv, (u) => child.sample(u), edgeMode);
 		const normalColor = sample(displacedUV);
-		const refractUV = (channel) => call(shatterRefractUV, "shatterRefractUV", [
+		const refractUV = (channel) => call(crackRefractUV, "crackRefractUV", [
 			displacedUV,
 			edgeNormal,
 			crackIntensity,
@@ -1415,7 +1464,7 @@ const componentDefinition = {
 			params.uniforms.chromaticSplit,
 			floatE(channel)
 		]);
-		return call(unpremultiplyAlpha, "unpremultiplyAlpha", [call(shatterCompose, "shatterCompose", [
+		return call(unpremultiplyAlpha, "unpremultiplyAlpha", [call(crackShardCompose, "crackShardCompose", [
 			normalColor,
 			sample(refractUV(1)),
 			sample(refractUV(0)),
@@ -1424,7 +1473,7 @@ const componentDefinition = {
 			disp,
 			params.uniforms.shardLighting
 		])]);
-	}
-};
+	} }
+});
 var Shatter_default = componentDefinition;
-export { shatterCompose as a, voronoiKernel as c, componentDefinition as i, Shatter_default as n, shatterGeom as o, cellDataUV as r, shatterRefractUV as s, ShatterGeom as t };
+export { componentDefinition as n, Shatter_default as t };