shaders 3.2.474 → 4.0.0

package/dist/core/Shatter-Dz3sH2ON.js

@@ -1,1479 +0,0 @@
-import { Ar as vec2u, Br as struct, Gn as typegpu_default, Mr as vec4f, Or as vec2f, Ot as unpremultiplyAlpha, Rr as textureStorage2d, V as toHalfFloat, X as applyEdgeHandlingExpr, Y as createStateBuffer, Yn as textureStore, Yr as u32, at as ZERO, ct as call, ft as floatE, hr as max, jr as vec3f, mr as length, q as createGuardedCompute, qr as f32, t as defineStd, wr as smoothstep, zr as arrayOf } from "./lower-Bd2jez_2.js";
-import { s as transformEdges } from "./transformations-CzFmhZww.js";
-var VORONOI_FORMAT = "rgba16float";
-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,
-						"u",
-						[
-							1,
-							[
-								1,
-								[
-									6,
-									"d.f32",
-									["cx"]
-								],
-								"+",
-								[5, "0.5"]
-							],
-							"/",
-							"size"
-						]
-					],
-					[
-						13,
-						"v",
-						[
-							1,
-							[
-								1,
-								[
-									6,
-									"d.f32",
-									["cy"]
-								],
-								"+",
-								[5, "0.5"]
-							],
-							"/",
-							"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",
-							"<",
-							"count"
-						],
-						[
-							102,
-							"++",
-							"i"
-						],
-						[0, [
-							[
-								13,
-								"cellX",
-								[
-									8,
-									[
-										7,
-										[
-											7,
-											"layout",
-											"$"
-										],
-										"cellPos"
-									],
-									[
-										1,
-										"i",
-										"*",
-										[5, "2"]
-									]
-								]
-							],
-							[
-								13,
-								"cellY",
-								[
-									8,
-									[
-										7,
-										[
-											7,
-											"layout",
-											"$"
-										],
-										"cellPos"
-									],
-									[
-										1,
-										[
-											1,
-											"i",
-											"*",
-											[5, "2"]
-										],
-										"+",
-										[5, "1"]
-									]
-								]
-							],
-							[
-								13,
-								"ddx",
-								[
-									1,
-									"u",
-									"-",
-									"cellX"
-								]
-							],
-							[
-								13,
-								"ddy",
-								[
-									1,
-									"v",
-									"-",
-									"cellY"
-								]
-							],
-							[
-								13,
-								"distSq",
-								[
-									1,
-									[
-										1,
-										"ddx",
-										"*",
-										"ddx"
-									],
-									"+",
-									[
-										1,
-										"ddy",
-										"*",
-										"ddy"
-									]
-								]
-							],
-							[
-								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,
-						"std.textureStore",
-						[
-							[
-								7,
-								[
-									7,
-									"layout",
-									"$"
-								],
-								"voronoiTex"
-							],
-							[
-								6,
-								"d.vec2u",
-								["cx", "cy"]
-							],
-							[
-								6,
-								"d.vec4f",
-								[
-									"idx1",
-									"idx2",
-									[5, "0"],
-									[5, "0"]
-								]
-							]
-						]
-					]
-				]]
-			},
-			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);
-	}
-	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,
-							[
-								1,
-								"idx",
-								"*",
-								[5, "4"]
-							],
-							"+",
-							"field"
-						],
-						"+",
-						[5, "0.5"]
-					],
-					"/",
-					"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);
-	}
-	return fn;
-}
-const CrackGeom = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
-	crackIntensity: f32,
-	edgeNormal: vec2f,
-	displacedUV: vec2f,
-	disp: vec2f
-}), "CrackGeom");
-const crackGeom = typegpu_default.fn([
-	vec2f,
-	f32,
-	f32,
-	f32,
-	f32,
-	f32,
-	f32,
-	f32
-], 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 fromNearest = uv.sub(nearestPos);
-	const minDist1 = length(fromNearest);
-	const minDist2 = length(uv.sub(secondPos));
-	const displacementMag = length(disp);
-	const edgeDiff = __tsover_sub(minDist2, minDist1);
-	const crackThreshold = __tsover_mul(crackWidth, .005);
-	const baseCrackIntensity = __tsover_sub(1, smoothstep(0, crackThreshold, edgeDiff));
-	const displacementFactor = smoothstep(0, .01, displacementMag);
-	const crackIntensity = __tsover_mul(baseCrackIntensity, displacementFactor);
-	const toNearest = fromNearest.div(max(minDist1, 1e-5));
-	return CrackGeom({
-		crackIntensity,
-		edgeNormal: vec2f(__tsover_mul(toNearest.y, -1), toNearest.x),
-		displacedUV: uv.sub(disp),
-		disp
-	});
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "uv"
-			},
-			{
-				"type": "i",
-				"name": "nPosX"
-			},
-			{
-				"type": "i",
-				"name": "nPosY"
-			},
-			{
-				"type": "i",
-				"name": "sPosX"
-			},
-			{
-				"type": "i",
-				"name": "sPosY"
-			},
-			{
-				"type": "i",
-				"name": "dispX"
-			},
-			{
-				"type": "i",
-				"name": "dispY"
-			},
-			{
-				"type": "i",
-				"name": "crackWidth"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"nearestPos",
-				[
-					6,
-					"d.vec2f",
-					["nPosX", "nPosY"]
-				]
-			],
-			[
-				13,
-				"secondPos",
-				[
-					6,
-					"d.vec2f",
-					["sPosX", "sPosY"]
-				]
-			],
-			[
-				13,
-				"disp",
-				[
-					6,
-					"d.vec2f",
-					["dispX", "dispY"]
-				]
-			],
-			[
-				13,
-				"fromNearest",
-				[
-					6,
-					[
-						7,
-						"uv",
-						"sub"
-					],
-					["nearestPos"]
-				]
-			],
-			[
-				13,
-				"minDist1",
-				[
-					6,
-					"std.length",
-					["fromNearest"]
-				]
-			],
-			[
-				13,
-				"minDist2",
-				[
-					6,
-					"std.length",
-					[[
-						6,
-						[
-							7,
-							"uv",
-							"sub"
-						],
-						["secondPos"]
-					]]
-				]
-			],
-			[
-				13,
-				"displacementMag",
-				[
-					6,
-					"std.length",
-					["disp"]
-				]
-			],
-			[
-				13,
-				"edgeDiff",
-				[
-					1,
-					"minDist2",
-					"-",
-					"minDist1"
-				]
-			],
-			[
-				13,
-				"crackThreshold",
-				[
-					1,
-					"crackWidth",
-					"*",
-					[5, "0.005"]
-				]
-			],
-			[
-				13,
-				"baseCrackIntensity",
-				[
-					1,
-					[5, "1"],
-					"-",
-					[
-						6,
-						"std.smoothstep",
-						[
-							[5, "0"],
-							"crackThreshold",
-							"edgeDiff"
-						]
-					]
-				]
-			],
-			[
-				13,
-				"displacementFactor",
-				[
-					6,
-					"std.smoothstep",
-					[
-						[5, "0"],
-						[5, "0.01"],
-						"displacementMag"
-					]
-				]
-			],
-			[
-				13,
-				"crackIntensity",
-				[
-					1,
-					"baseCrackIntensity",
-					"*",
-					"displacementFactor"
-				]
-			],
-			[
-				13,
-				"toNearest",
-				[
-					6,
-					[
-						7,
-						"fromNearest",
-						"div"
-					],
-					[[
-						6,
-						"std.max",
-						["minDist1", [5, "0.00001"]]
-					]]
-				]
-			],
-			[
-				13,
-				"edgeNormal",
-				[
-					6,
-					"d.vec2f",
-					[[
-						1,
-						[
-							7,
-							"toNearest",
-							"y"
-						],
-						"*",
-						[
-							4,
-							"-",
-							[5, "1"]
-						]
-					], [
-						7,
-						"toNearest",
-						"x"
-					]]
-				]
-			],
-			[
-				13,
-				"displacedUV",
-				[
-					6,
-					[
-						7,
-						"uv",
-						"sub"
-					],
-					["disp"]
-				]
-			],
-			[10, [
-				6,
-				"CrackGeom",
-				[[104, {
-					"crackIntensity": "crackIntensity",
-					"edgeNormal": "edgeNormal",
-					"displacedUV": "displacedUV",
-					"disp": "disp"
-				}]]
-			]]
-		]]
-	},
-	externals: {
-		"d.vec2f": () => vec2f,
-		"std.length": () => length,
-		"std.smoothstep": () => smoothstep,
-		"std.max": () => max,
-		"CrackGeom": () => CrackGeom
-	}
-}) && $.f)({}));
-const crackRefractUV = typegpu_default.fn([
-	vec2f,
-	vec2f,
-	f32,
-	f32,
-	f32,
-	f32
-], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((displacedUV, edgeNormal, crackIntensity, refractionStrength, chromaticSplit, channel) => {
-	"use gpu";
-	const refractionOffset = edgeNormal.mul(__tsover_mul(refractionStrength, .01));
-	const chromaticOffset = __tsover_mul(chromaticSplit, .005);
-	const chromaShift = edgeNormal.mul(__tsover_mul(channel, chromaticOffset));
-	const offset = refractionOffset.add(chromaShift);
-	return displacedUV.add(offset.mul(crackIntensity));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "displacedUV"
-			},
-			{
-				"type": "i",
-				"name": "edgeNormal"
-			},
-			{
-				"type": "i",
-				"name": "crackIntensity"
-			},
-			{
-				"type": "i",
-				"name": "refractionStrength"
-			},
-			{
-				"type": "i",
-				"name": "chromaticSplit"
-			},
-			{
-				"type": "i",
-				"name": "channel"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"refractionOffset",
-				[
-					6,
-					[
-						7,
-						"edgeNormal",
-						"mul"
-					],
-					[[
-						1,
-						"refractionStrength",
-						"*",
-						[5, "0.01"]
-					]]
-				]
-			],
-			[
-				13,
-				"chromaticOffset",
-				[
-					1,
-					"chromaticSplit",
-					"*",
-					[5, "0.005"]
-				]
-			],
-			[
-				13,
-				"chromaShift",
-				[
-					6,
-					[
-						7,
-						"edgeNormal",
-						"mul"
-					],
-					[[
-						1,
-						"channel",
-						"*",
-						"chromaticOffset"
-					]]
-				]
-			],
-			[
-				13,
-				"offset",
-				[
-					6,
-					[
-						7,
-						"refractionOffset",
-						"add"
-					],
-					["chromaShift"]
-				]
-			],
-			[10, [
-				6,
-				[
-					7,
-					"displacedUV",
-					"add"
-				],
-				[[
-					6,
-					[
-						7,
-						"offset",
-						"mul"
-					],
-					["crackIntensity"]
-				]]
-			]]
-		]]
-	},
-	externals: {}
-}) && $.f)({}));
-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,
-	vec4f,
-	f32,
-	vec2f,
-	f32
-], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((normalColor, rFinal, gFinal, bFinal, crackIntensity, disp, shardLighting) => {
-	"use gpu";
-	const refractedRGB = vec3f(rFinal.x, gFinal.y, bFinal.z);
-	const shadedRGB = normalColor.xyz.mul(__tsover_sub(1, crackIntensity)).add(refractedRGB.mul(crackIntensity));
-	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 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));
-	return vec4f(shadedRGB.mul(finalLighting), normalColor.w);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "normalColor"
-			},
-			{
-				"type": "i",
-				"name": "rFinal"
-			},
-			{
-				"type": "i",
-				"name": "gFinal"
-			},
-			{
-				"type": "i",
-				"name": "bFinal"
-			},
-			{
-				"type": "i",
-				"name": "crackIntensity"
-			},
-			{
-				"type": "i",
-				"name": "disp"
-			},
-			{
-				"type": "i",
-				"name": "shardLighting"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"refractedRGB",
-				[
-					6,
-					"d.vec3f",
-					[
-						[
-							7,
-							"rFinal",
-							"x"
-						],
-						[
-							7,
-							"gFinal",
-							"y"
-						],
-						[
-							7,
-							"bFinal",
-							"z"
-						]
-					]
-				]
-			],
-			[
-				13,
-				"shadedRGB",
-				[
-					6,
-					[
-						7,
-						[
-							6,
-							[
-								7,
-								[
-									7,
-									"normalColor",
-									"xyz"
-								],
-								"mul"
-							],
-							[[
-								1,
-								[5, "1"],
-								"-",
-								"crackIntensity"
-							]]
-						],
-						"add"
-					],
-					[[
-						6,
-						[
-							7,
-							"refractedRGB",
-							"mul"
-						],
-						["crackIntensity"]
-					]]
-				]
-			],
-			[
-				13,
-				"displacementLength",
-				[
-					6,
-					"std.length",
-					["disp"]
-				]
-			],
-			[
-				13,
-				"tiltX",
-				[
-					1,
-					[
-						7,
-						"disp",
-						"x"
-					],
-					"/",
-					[
-						1,
-						"displacementLength",
-						"+",
-						[5, "0.001"]
-					]
-				]
-			],
-			[
-				13,
-				"tiltY",
-				[
-					1,
-					[
-						7,
-						"disp",
-						"y"
-					],
-					"/",
-					[
-						1,
-						"displacementLength",
-						"+",
-						[5, "0.001"]
-					]
-				]
-			],
-			[
-				13,
-				"normalDot",
-				[
-					1,
-					[
-						1,
-						"tiltX",
-						"*",
-						"SHARD_LIGHT_DIR_X"
-					],
-					"+",
-					[
-						1,
-						"tiltY",
-						"*",
-						"SHARD_LIGHT_DIR_Y"
-					]
-				]
-			],
-			[
-				13,
-				"lightingFactor",
-				[
-					1,
-					[5, "1"],
-					"+",
-					[
-						1,
-						"normalDot",
-						"*",
-						"shardLighting"
-					]
-				]
-			],
-			[
-				13,
-				"lightingIntensity",
-				[
-					6,
-					"std.smoothstep",
-					[
-						[5, "0"],
-						[5, "0.02"],
-						"displacementLength"
-					]
-				]
-			],
-			[
-				13,
-				"finalLighting",
-				[
-					1,
-					[5, "1"],
-					"+",
-					[
-						1,
-						[
-							1,
-							"lightingFactor",
-							"-",
-							[5, "1"]
-						],
-						"*",
-						"lightingIntensity"
-					]
-				]
-			],
-			[
-				13,
-				"finalRGB",
-				[
-					6,
-					[
-						7,
-						"shadedRGB",
-						"mul"
-					],
-					["finalLighting"]
-				]
-			],
-			[10, [
-				6,
-				"d.vec4f",
-				["finalRGB", [
-					7,
-					"normalColor",
-					"w"
-				]]
-			]]
-		]]
-	},
-	externals: {
-		"d.vec3f": () => vec3f,
-		"std.length": () => length,
-		"SHARD_LIGHT_DIR_X": () => SHARD_LIGHT_DIR_X,
-		"SHARD_LIGHT_DIR_Y": () => SHARD_LIGHT_DIR_Y,
-		"std.smoothstep": () => smoothstep,
-		"d.vec4f": () => vec4f
-	}
-}) && $.f)({}));
-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",
-	requiresRTT: true,
-	requiresChild: true,
-	usesPointer: true,
-	props: {
-		crackWidth: {
-			default: 1,
-			description: "Thickness of crack lines",
-			ui: {
-				type: ["range", "map"],
-				min: .5,
-				max: 5,
-				step: .1,
-				label: "Crack Width",
-				group: "Effect"
-			}
-		},
-		intensity: {
-			default: 4,
-			description: "How much shards shift",
-			ui: {
-				type: "range",
-				min: 0,
-				max: 20,
-				step: 1,
-				label: "Intensity",
-				group: "Effect"
-			}
-		},
-		radius: {
-			default: .4,
-			description: "Cursor influence radius",
-			ui: {
-				type: "range",
-				min: .1,
-				max: 1,
-				step: .1,
-				label: "Radius",
-				group: "Effect"
-			}
-		},
-		decay: {
-			default: 1,
-			description: "How fast shards return to rest",
-			ui: {
-				type: "range",
-				min: .1,
-				max: 10,
-				step: .1,
-				label: "Decay",
-				group: "Effect"
-			}
-		},
-		seed: {
-			default: 2,
-			description: "Random seed for pattern",
-			ui: {
-				type: "range",
-				min: 0,
-				max: 50,
-				step: 1,
-				label: "Seed",
-				group: "Effect"
-			}
-		},
-		chromaticSplit: {
-			default: 1,
-			description: "RGB separation for prismatic glass effect",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 5,
-				step: .1,
-				label: "Chromatic Split",
-				group: "Effect"
-			}
-		},
-		refractionStrength: {
-			default: 5,
-			description: "How much cracks bend/distort the underlying image",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 10,
-				step: .1,
-				label: "Refraction",
-				group: "Effect"
-			}
-		},
-		shardLighting: {
-			default: .1,
-			description: "Subtle lighting on tilted shards for 3D depth",
-			ui: {
-				type: "range",
-				min: 0,
-				max: .5,
-				step: .1,
-				label: "Shard Lighting",
-				group: "Effect"
-			}
-		},
-		edges: {
-			default: "mirror",
-			description: "How to handle edges when displacement pushes content out of bounds",
-			transform: transformEdges,
-			compileTime: true,
-			ui: {
-				type: "select",
-				options: [
-					{
-						label: "Stretch",
-						value: "stretch"
-					},
-					{
-						label: "Transparent",
-						value: "transparent"
-					},
-					{
-						label: "Mirror",
-						value: "mirror"
-					},
-					{
-						label: "Wrap",
-						value: "wrap"
-					}
-				],
-				label: "Edges",
-				group: "Effect"
-			}
-		}
-	},
-	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 { onBeforeRender, getCpuValue, dimensions } = params;
-		const edgeMode = propValues.edges ?? 0;
-		const physics = shardPhysics(getCpuValue);
-		const cells = shardDataTexture(params, physics);
-		const dataKit = cells.dataKit;
-		onBeforeRender((fp) => {
-			const { pointer, deltaTime } = fp;
-			const aspect = dimensions.width / Math.max(1, dimensions.height);
-			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(cellLaneUV, "cellLaneUV", [idx, floatE(field)]), nearestClamp).member("r");
-		const geom = call(crackGeom, "crackGeom", [
-			ctx.uv,
-			dataAt(nearestI, 0),
-			dataAt(nearestI, 1),
-			dataAt(secondI, 0),
-			dataAt(secondI, 1),
-			dataAt(nearestI, 2),
-			dataAt(nearestI, 3),
-			params.uniforms.crackWidth
-		]);
-		const crackIntensity = geom.member("crackIntensity");
-		const edgeNormal = geom.member("edgeNormal");
-		const displacedUV = geom.member("displacedUV");
-		const disp = geom.member("disp");
-		const sample = (uv) => applyEdgeHandlingExpr(uv, (u) => child.sample(u), edgeMode);
-		const normalColor = sample(displacedUV);
-		const refractUV = (channel) => call(crackRefractUV, "crackRefractUV", [
-			displacedUV,
-			edgeNormal,
-			crackIntensity,
-			params.uniforms.refractionStrength,
-			params.uniforms.chromaticSplit,
-			floatE(channel)
-		]);
-		return call(unpremultiplyAlpha, "unpremultiplyAlpha", [call(crackShardCompose, "crackShardCompose", [
-			normalColor,
-			sample(refractUV(1)),
-			sample(refractUV(0)),
-			sample(refractUV(-1)),
-			crackIntensity,
-			disp,
-			params.uniforms.shardLighting
-		])]);
-	} }
-});
-var Shatter_default = componentDefinition;
-export { componentDefinition as n, Shatter_default as t };