shaders 2.5.135 → 3.0.437

package/dist/core/Surface3D-ZtGSv9V6.js

@@ -0,0 +1,4946 @@
+import { At as call, B as createGuardedCompute, Ct as edgeMirrorUV, Et as edges_exports, It as vec4, Ot as ZERO, R as std, Tt as edgeWrapUV, V as createStateBuffer, Wt as unpremultiplyAlpha, et as mxNoiseFloat2, n as tgpu, on as d, rt as noise_exports } from "./coords-BlwgBpJf.js";
+import { a as transformColor, s as transformEdges } from "./transformations-fqzznt4g.js";
+var WAVE_GRID = 256;
+var WAVE_CELLS = WAVE_GRID * WAVE_GRID;
+var WAVE_MAX = WAVE_GRID - 1;
+var WAVE_HALFEXTENT = 3;
+var COMPUTE_W = 1600;
+var COMPUTE_H = 900;
+var STATE_FORMAT = "rgba16float";
+var DEG_TO_RAD = Math.PI / 180;
+var TWO_PI = Math.PI * 2;
+var S3Params = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(d.struct({
+	amp: d.f32,
+	freq: d.f32,
+	seed: d.f32,
+	edgePin: d.f32,
+	cursorIntensity: d.f32,
+	t: d.f32,
+	aspect: d.f32,
+	focal: d.f32,
+	camPos: d.vec3f,
+	camForward: d.vec3f,
+	camRight: d.vec3f,
+	camUp: d.vec3f,
+	lighting: d.f32,
+	glossiness: d.f32,
+	highlights: d.f32,
+	lightX: d.f32,
+	lightY: d.f32,
+	lightZ: d.f32,
+	lightColor: d.vec3f,
+	nearCutoff: d.f32,
+	farCutoff: d.f32,
+	cursorWaveX: d.f32,
+	cursorWaveY: d.f32,
+	mouseSpeed: d.f32,
+	dt: d.f32,
+	decay: d.f32,
+	radius: d.f32,
+	waveSpeed: d.f32
+}), "S3Params");
+var propagateLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+	readSrc: {
+		storage: d.arrayOf(d.f32, WAVE_CELLS),
+		access: "readonly"
+	},
+	writeBuf: {
+		storage: d.arrayOf(d.f32, WAVE_CELLS),
+		access: "mutable"
+	},
+	readBuf: {
+		storage: d.arrayOf(d.f32, WAVE_CELLS),
+		access: "mutable"
+	},
+	params: { uniform: S3Params }
+}), "propagateLayout");
+var computeLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+	readBuf: {
+		storage: d.arrayOf(d.f32, WAVE_CELLS),
+		access: "readonly"
+	},
+	params: { uniform: S3Params },
+	uvMaskTex: { storageTexture: d.textureStorage2d(STATE_FORMAT, "write-only") },
+	litTex: { storageTexture: d.textureStorage2d(STATE_FORMAT, "write-only") }
+}), "computeLayout");
+function buildHeightFn(waveType, octaveCount, cursorEnabled) {
+	const invTotalWeight = 1 / (2 - Math.pow(.5, Math.max(octaveCount, 1) - 1));
+	return tgpu.fn([d.vec2f], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv) => {
+		"use gpu";
+		const p = computeLayout.$.params;
+		const u = uv.x;
+		const v = uv.y;
+		const amp = p.amp;
+		const freq = p.freq;
+		const seedU = p.seed;
+		let waveVal = d.f32(0);
+		if (waveType === 1) {
+			let accSin = d.f32(0);
+			for (let i = 0; i < octaveCount; i++) {
+				const iF = d.f32(i);
+				const scale = std.exp2(iF);
+				const weight = std.exp2(__tsover_mul(iF, -1));
+				const cu$1 = std.cos(__tsover_mul(iF, 1.111));
+				const su = std.sin(__tsover_mul(iF, 1.111));
+				const ru = __tsover_sub(__tsover_mul(u, cu$1), __tsover_mul(v, su));
+				const phase = __tsover_add(__tsover_add(__tsover_mul(__tsover_mul(__tsover_mul(ru, freq), scale), TWO_PI), __tsover_mul(p.t, __tsover_add(1, __tsover_mul(iF, .2)))), __tsover_mul(seedU, __tsover_add(1, __tsover_mul(iF, .5))));
+				accSin = __tsover_add(accSin, __tsover_mul(std.sin(phase), weight));
+			}
+			waveVal = __tsover_mul(accSin, invTotalWeight);
+		} else if (waveType === 2) {
+			let accR = d.f32(0);
+			for (let i = 0; i < octaveCount; i++) {
+				const iF = d.f32(i);
+				const scale = std.exp2(iF);
+				const weight = std.exp2(__tsover_mul(iF, -1));
+				const driftX = std.cos(__tsover_mul(iF, 2.39996));
+				const driftY = std.sin(__tsover_mul(iF, 2.39996));
+				const coord = d.vec2f(__tsover_add(__tsover_add(__tsover_mul(__tsover_mul(u, freq), scale), __tsover_mul(p.t, __tsover_mul(driftX, .3))), seedU), __tsover_add(__tsover_add(__tsover_mul(__tsover_mul(v, freq), scale), __tsover_mul(p.t, __tsover_mul(driftY, .3))), __tsover_mul(seedU, .7)));
+				accR = __tsover_add(accR, __tsover_mul(mxNoiseFloat2(coord), weight));
+			}
+			const n = __tsover_mul(accR, invTotalWeight);
+			waveVal = __tsover_sub(__tsover_mul(__tsover_sub(1, std.abs(n)), 2), 1);
+		} else {
+			const warpFreq = __tsover_mul(freq, .5);
+			const wx = mxNoiseFloat2(d.vec2f(__tsover_add(__tsover_add(__tsover_mul(u, warpFreq), __tsover_mul(p.t, .1)), seedU), __tsover_add(__tsover_mul(v, warpFreq), __tsover_mul(seedU, 1.3))));
+			const wy = mxNoiseFloat2(d.vec2f(__tsover_add(__tsover_add(__tsover_mul(u, warpFreq), seedU), 17.3), __tsover_add(__tsover_add(__tsover_add(__tsover_mul(v, warpFreq), __tsover_mul(p.t, .07)), seedU), 31.1)));
+			const wu = __tsover_add(u, __tsover_mul(wx, .4));
+			const wv = __tsover_add(v, __tsover_mul(wy, .4));
+			let accW = d.f32(0);
+			for (let i = 0; i < octaveCount; i++) {
+				const iF = d.f32(i);
+				const scale = std.exp2(iF);
+				const weight = std.exp2(__tsover_mul(iF, -1));
+				const driftX = std.cos(__tsover_mul(iF, 2.39996));
+				const driftY = std.sin(__tsover_mul(iF, 2.39996));
+				const coord = d.vec2f(__tsover_add(__tsover_add(__tsover_mul(__tsover_mul(wu, freq), scale), __tsover_mul(p.t, __tsover_mul(driftX, .3))), seedU), __tsover_add(__tsover_add(__tsover_mul(__tsover_mul(wv, freq), scale), __tsover_mul(p.t, __tsover_mul(driftY, .3))), __tsover_mul(seedU, .7)));
+				accW = __tsover_add(accW, __tsover_mul(mxNoiseFloat2(coord), weight));
+			}
+			waveVal = __tsover_mul(accW, invTotalWeight);
+		}
+		const cu = __tsover_mul(__tsover_sub(u, .5), 2);
+		const cv = __tsover_mul(__tsover_sub(v, .5), 2);
+		const inner = std.max(std.abs(cu), std.abs(cv));
+		const pinFalloff = std.smoothstep(.6, 1, inner);
+		const pinMask = std.mix(d.f32(1), __tsover_sub(1, pinFalloff), p.edgePin);
+		const baseHeight = __tsover_mul(__tsover_mul(waveVal, amp), pinMask);
+		if (cursorEnabled) {
+			const H = d.f32(WAVE_HALFEXTENT);
+			const waveU = __tsover_add(__tsover_div(__tsover_sub(uv.x, .5), H), .5);
+			const waveV = __tsover_add(__tsover_div(__tsover_sub(uv.y, .5), H), .5);
+			const Nm1 = d.f32(WAVE_MAX);
+			const gx = __tsover_mul(std.clamp(waveU, 0, 1), Nm1);
+			const gy = __tsover_mul(std.clamp(waveV, 0, 1), Nm1);
+			const ix = d.u32(std.clamp(gx, 0, Nm1));
+			const iy = d.u32(std.clamp(gy, 0, Nm1));
+			const ix1 = std.min(__tsover_add(ix, d.u32(1)), d.u32(WAVE_MAX));
+			const iy1 = std.min(__tsover_add(iy, d.u32(1)), d.u32(WAVE_MAX));
+			const fx = __tsover_sub(gx, std.floor(gx));
+			const fy = __tsover_sub(gy, std.floor(gy));
+			const W = d.u32(WAVE_GRID);
+			const v00 = computeLayout.$.readBuf[__tsover_add(__tsover_mul(iy, W), ix)];
+			const v10 = computeLayout.$.readBuf[__tsover_add(__tsover_mul(iy, W), ix1)];
+			const v01 = computeLayout.$.readBuf[__tsover_add(__tsover_mul(iy1, W), ix)];
+			const v11 = computeLayout.$.readBuf[__tsover_add(__tsover_mul(iy1, W), ix1)];
+			const waveSample = std.mix(std.mix(v00, v10, fx), std.mix(v01, v11, fx), fy);
+			return __tsover_add(baseHeight, __tsover_mul(waveSample, __tsover_mul(p.cursorIntensity, .05)));
+		} else return baseHeight;
+	}), {
+		v: 1,
+		name: void 0,
+		ast: {
+			"params": [{
+				"type": "i",
+				"name": "uv"
+			}],
+			"body": [0, [
+				[
+					13,
+					"p",
+					[
+						7,
+						[
+							7,
+							"computeLayout",
+							"$"
+						],
+						"params"
+					]
+				],
+				[
+					13,
+					"u",
+					[
+						7,
+						"uv",
+						"x"
+					]
+				],
+				[
+					13,
+					"v",
+					[
+						7,
+						"uv",
+						"y"
+					]
+				],
+				[
+					13,
+					"amp",
+					[
+						7,
+						"p",
+						"amp"
+					]
+				],
+				[
+					13,
+					"freq",
+					[
+						7,
+						"p",
+						"freq"
+					]
+				],
+				[
+					13,
+					"seedU",
+					[
+						7,
+						"p",
+						"seed"
+					]
+				],
+				[
+					12,
+					"waveVal",
+					[
+						6,
+						[
+							7,
+							"d",
+							"f32"
+						],
+						[[5, "0"]]
+					]
+				],
+				[
+					11,
+					[
+						1,
+						"waveType",
+						"===",
+						[5, "1"]
+					],
+					[0, [
+						[
+							12,
+							"accSin",
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[5, "0"]]
+							]
+						],
+						[
+							14,
+							[
+								12,
+								"i",
+								[5, "0"]
+							],
+							[
+								1,
+								"i",
+								"<",
+								"octaveCount"
+							],
+							[
+								102,
+								"++",
+								"i"
+							],
+							[0, [
+								[
+									13,
+									"iF",
+									[
+										6,
+										[
+											7,
+											"d",
+											"f32"
+										],
+										["i"]
+									]
+								],
+								[
+									13,
+									"scale",
+									[
+										6,
+										[
+											7,
+											"std",
+											"exp2"
+										],
+										["iF"]
+									]
+								],
+								[
+									13,
+									"weight",
+									[
+										6,
+										[
+											7,
+											"std",
+											"exp2"
+										],
+										[[
+											1,
+											"iF",
+											"*",
+											[
+												4,
+												"-",
+												[5, "1"]
+											]
+										]]
+									]
+								],
+								[
+									13,
+									"cu",
+									[
+										6,
+										[
+											7,
+											"std",
+											"cos"
+										],
+										[[
+											1,
+											"iF",
+											"*",
+											[5, "1.111"]
+										]]
+									]
+								],
+								[
+									13,
+									"su",
+									[
+										6,
+										[
+											7,
+											"std",
+											"sin"
+										],
+										[[
+											1,
+											"iF",
+											"*",
+											[5, "1.111"]
+										]]
+									]
+								],
+								[
+									13,
+									"ru",
+									[
+										1,
+										[
+											1,
+											"u",
+											"*",
+											"cu"
+										],
+										"-",
+										[
+											1,
+											"v",
+											"*",
+											"su"
+										]
+									]
+								],
+								[
+									13,
+									"phase",
+									[
+										1,
+										[
+											1,
+											[
+												1,
+												[
+													1,
+													[
+														1,
+														"ru",
+														"*",
+														"freq"
+													],
+													"*",
+													"scale"
+												],
+												"*",
+												"TWO_PI"
+											],
+											"+",
+											[
+												1,
+												[
+													7,
+													"p",
+													"t"
+												],
+												"*",
+												[
+													1,
+													[5, "1"],
+													"+",
+													[
+														1,
+														"iF",
+														"*",
+														[5, "0.2"]
+													]
+												]
+											]
+										],
+										"+",
+										[
+											1,
+											"seedU",
+											"*",
+											[
+												1,
+												[5, "1"],
+												"+",
+												[
+													1,
+													"iF",
+													"*",
+													[5, "0.5"]
+												]
+											]
+										]
+									]
+								],
+								[
+									2,
+									"accSin",
+									"=",
+									[
+										1,
+										"accSin",
+										"+",
+										[
+											1,
+											[
+												6,
+												[
+													7,
+													"std",
+													"sin"
+												],
+												["phase"]
+											],
+											"*",
+											"weight"
+										]
+									]
+								]
+							]]
+						],
+						[
+							2,
+							"waveVal",
+							"=",
+							[
+								1,
+								"accSin",
+								"*",
+								"invTotalWeight"
+							]
+						]
+					]],
+					[
+						11,
+						[
+							1,
+							"waveType",
+							"===",
+							[5, "2"]
+						],
+						[0, [
+							[
+								12,
+								"accR",
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									[[5, "0"]]
+								]
+							],
+							[
+								14,
+								[
+									12,
+									"i",
+									[5, "0"]
+								],
+								[
+									1,
+									"i",
+									"<",
+									"octaveCount"
+								],
+								[
+									102,
+									"++",
+									"i"
+								],
+								[0, [
+									[
+										13,
+										"iF",
+										[
+											6,
+											[
+												7,
+												"d",
+												"f32"
+											],
+											["i"]
+										]
+									],
+									[
+										13,
+										"scale",
+										[
+											6,
+											[
+												7,
+												"std",
+												"exp2"
+											],
+											["iF"]
+										]
+									],
+									[
+										13,
+										"weight",
+										[
+											6,
+											[
+												7,
+												"std",
+												"exp2"
+											],
+											[[
+												1,
+												"iF",
+												"*",
+												[
+													4,
+													"-",
+													[5, "1"]
+												]
+											]]
+										]
+									],
+									[
+										13,
+										"driftX",
+										[
+											6,
+											[
+												7,
+												"std",
+												"cos"
+											],
+											[[
+												1,
+												"iF",
+												"*",
+												[5, "2.39996"]
+											]]
+										]
+									],
+									[
+										13,
+										"driftY",
+										[
+											6,
+											[
+												7,
+												"std",
+												"sin"
+											],
+											[[
+												1,
+												"iF",
+												"*",
+												[5, "2.39996"]
+											]]
+										]
+									],
+									[
+										13,
+										"coord",
+										[
+											6,
+											[
+												7,
+												"d",
+												"vec2f"
+											],
+											[[
+												1,
+												[
+													1,
+													[
+														1,
+														[
+															1,
+															"u",
+															"*",
+															"freq"
+														],
+														"*",
+														"scale"
+													],
+													"+",
+													[
+														1,
+														[
+															7,
+															"p",
+															"t"
+														],
+														"*",
+														[
+															1,
+															"driftX",
+															"*",
+															[5, "0.3"]
+														]
+													]
+												],
+												"+",
+												"seedU"
+											], [
+												1,
+												[
+													1,
+													[
+														1,
+														[
+															1,
+															"v",
+															"*",
+															"freq"
+														],
+														"*",
+														"scale"
+													],
+													"+",
+													[
+														1,
+														[
+															7,
+															"p",
+															"t"
+														],
+														"*",
+														[
+															1,
+															"driftY",
+															"*",
+															[5, "0.3"]
+														]
+													]
+												],
+												"+",
+												[
+													1,
+													"seedU",
+													"*",
+													[5, "0.7"]
+												]
+											]]
+										]
+									],
+									[
+										2,
+										"accR",
+										"=",
+										[
+											1,
+											"accR",
+											"+",
+											[
+												1,
+												[
+													6,
+													[
+														7,
+														"noise",
+														"mxNoiseFloat2"
+													],
+													["coord"]
+												],
+												"*",
+												"weight"
+											]
+										]
+									]
+								]]
+							],
+							[
+								13,
+								"n",
+								[
+									1,
+									"accR",
+									"*",
+									"invTotalWeight"
+								]
+							],
+							[
+								2,
+								"waveVal",
+								"=",
+								[
+									1,
+									[
+										1,
+										[
+											1,
+											[5, "1"],
+											"-",
+											[
+												6,
+												[
+													7,
+													"std",
+													"abs"
+												],
+												["n"]
+											]
+										],
+										"*",
+										[5, "2"]
+									],
+									"-",
+									[5, "1"]
+								]
+							]
+						]],
+						[0, [
+							[
+								13,
+								"warpFreq",
+								[
+									1,
+									"freq",
+									"*",
+									[5, "0.5"]
+								]
+							],
+							[
+								13,
+								"wx",
+								[
+									6,
+									[
+										7,
+										"noise",
+										"mxNoiseFloat2"
+									],
+									[[
+										6,
+										[
+											7,
+											"d",
+											"vec2f"
+										],
+										[[
+											1,
+											[
+												1,
+												[
+													1,
+													"u",
+													"*",
+													"warpFreq"
+												],
+												"+",
+												[
+													1,
+													[
+														7,
+														"p",
+														"t"
+													],
+													"*",
+													[5, "0.1"]
+												]
+											],
+											"+",
+											"seedU"
+										], [
+											1,
+											[
+												1,
+												"v",
+												"*",
+												"warpFreq"
+											],
+											"+",
+											[
+												1,
+												"seedU",
+												"*",
+												[5, "1.3"]
+											]
+										]]
+									]]
+								]
+							],
+							[
+								13,
+								"wy",
+								[
+									6,
+									[
+										7,
+										"noise",
+										"mxNoiseFloat2"
+									],
+									[[
+										6,
+										[
+											7,
+											"d",
+											"vec2f"
+										],
+										[[
+											1,
+											[
+												1,
+												[
+													1,
+													"u",
+													"*",
+													"warpFreq"
+												],
+												"+",
+												"seedU"
+											],
+											"+",
+											[5, "17.3"]
+										], [
+											1,
+											[
+												1,
+												[
+													1,
+													[
+														1,
+														"v",
+														"*",
+														"warpFreq"
+													],
+													"+",
+													[
+														1,
+														[
+															7,
+															"p",
+															"t"
+														],
+														"*",
+														[5, "0.07"]
+													]
+												],
+												"+",
+												"seedU"
+											],
+											"+",
+											[5, "31.1"]
+										]]
+									]]
+								]
+							],
+							[
+								13,
+								"wu",
+								[
+									1,
+									"u",
+									"+",
+									[
+										1,
+										"wx",
+										"*",
+										[5, "0.4"]
+									]
+								]
+							],
+							[
+								13,
+								"wv",
+								[
+									1,
+									"v",
+									"+",
+									[
+										1,
+										"wy",
+										"*",
+										[5, "0.4"]
+									]
+								]
+							],
+							[
+								12,
+								"accW",
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									[[5, "0"]]
+								]
+							],
+							[
+								14,
+								[
+									12,
+									"i",
+									[5, "0"]
+								],
+								[
+									1,
+									"i",
+									"<",
+									"octaveCount"
+								],
+								[
+									102,
+									"++",
+									"i"
+								],
+								[0, [
+									[
+										13,
+										"iF",
+										[
+											6,
+											[
+												7,
+												"d",
+												"f32"
+											],
+											["i"]
+										]
+									],
+									[
+										13,
+										"scale",
+										[
+											6,
+											[
+												7,
+												"std",
+												"exp2"
+											],
+											["iF"]
+										]
+									],
+									[
+										13,
+										"weight",
+										[
+											6,
+											[
+												7,
+												"std",
+												"exp2"
+											],
+											[[
+												1,
+												"iF",
+												"*",
+												[
+													4,
+													"-",
+													[5, "1"]
+												]
+											]]
+										]
+									],
+									[
+										13,
+										"driftX",
+										[
+											6,
+											[
+												7,
+												"std",
+												"cos"
+											],
+											[[
+												1,
+												"iF",
+												"*",
+												[5, "2.39996"]
+											]]
+										]
+									],
+									[
+										13,
+										"driftY",
+										[
+											6,
+											[
+												7,
+												"std",
+												"sin"
+											],
+											[[
+												1,
+												"iF",
+												"*",
+												[5, "2.39996"]
+											]]
+										]
+									],
+									[
+										13,
+										"coord",
+										[
+											6,
+											[
+												7,
+												"d",
+												"vec2f"
+											],
+											[[
+												1,
+												[
+													1,
+													[
+														1,
+														[
+															1,
+															"wu",
+															"*",
+															"freq"
+														],
+														"*",
+														"scale"
+													],
+													"+",
+													[
+														1,
+														[
+															7,
+															"p",
+															"t"
+														],
+														"*",
+														[
+															1,
+															"driftX",
+															"*",
+															[5, "0.3"]
+														]
+													]
+												],
+												"+",
+												"seedU"
+											], [
+												1,
+												[
+													1,
+													[
+														1,
+														[
+															1,
+															"wv",
+															"*",
+															"freq"
+														],
+														"*",
+														"scale"
+													],
+													"+",
+													[
+														1,
+														[
+															7,
+															"p",
+															"t"
+														],
+														"*",
+														[
+															1,
+															"driftY",
+															"*",
+															[5, "0.3"]
+														]
+													]
+												],
+												"+",
+												[
+													1,
+													"seedU",
+													"*",
+													[5, "0.7"]
+												]
+											]]
+										]
+									],
+									[
+										2,
+										"accW",
+										"=",
+										[
+											1,
+											"accW",
+											"+",
+											[
+												1,
+												[
+													6,
+													[
+														7,
+														"noise",
+														"mxNoiseFloat2"
+													],
+													["coord"]
+												],
+												"*",
+												"weight"
+											]
+										]
+									]
+								]]
+							],
+							[
+								2,
+								"waveVal",
+								"=",
+								[
+									1,
+									"accW",
+									"*",
+									"invTotalWeight"
+								]
+							]
+						]]
+					]
+				],
+				[
+					13,
+					"cu",
+					[
+						1,
+						[
+							1,
+							"u",
+							"-",
+							[5, "0.5"]
+						],
+						"*",
+						[5, "2"]
+					]
+				],
+				[
+					13,
+					"cv",
+					[
+						1,
+						[
+							1,
+							"v",
+							"-",
+							[5, "0.5"]
+						],
+						"*",
+						[5, "2"]
+					]
+				],
+				[
+					13,
+					"inner",
+					[
+						6,
+						[
+							7,
+							"std",
+							"max"
+						],
+						[[
+							6,
+							[
+								7,
+								"std",
+								"abs"
+							],
+							["cu"]
+						], [
+							6,
+							[
+								7,
+								"std",
+								"abs"
+							],
+							["cv"]
+						]]
+					]
+				],
+				[
+					13,
+					"pinFalloff",
+					[
+						6,
+						[
+							7,
+							"std",
+							"smoothstep"
+						],
+						[
+							[5, "0.6"],
+							[5, "1"],
+							"inner"
+						]
+					]
+				],
+				[
+					13,
+					"pinMask",
+					[
+						6,
+						[
+							7,
+							"std",
+							"mix"
+						],
+						[
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[5, "1"]]
+							],
+							[
+								1,
+								[5, "1"],
+								"-",
+								"pinFalloff"
+							],
+							[
+								7,
+								"p",
+								"edgePin"
+							]
+						]
+					]
+				],
+				[
+					13,
+					"baseHeight",
+					[
+						1,
+						[
+							1,
+							"waveVal",
+							"*",
+							"amp"
+						],
+						"*",
+						"pinMask"
+					]
+				],
+				[
+					11,
+					"cursorEnabled",
+					[0, [
+						[
+							13,
+							"H",
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								["WAVE_HALFEXTENT"]
+							]
+						],
+						[
+							13,
+							"waveU",
+							[
+								1,
+								[
+									1,
+									[
+										1,
+										[
+											7,
+											"uv",
+											"x"
+										],
+										"-",
+										[5, "0.5"]
+									],
+									"/",
+									"H"
+								],
+								"+",
+								[5, "0.5"]
+							]
+						],
+						[
+							13,
+							"waveV",
+							[
+								1,
+								[
+									1,
+									[
+										1,
+										[
+											7,
+											"uv",
+											"y"
+										],
+										"-",
+										[5, "0.5"]
+									],
+									"/",
+									"H"
+								],
+								"+",
+								[5, "0.5"]
+							]
+						],
+						[
+							13,
+							"Nm1",
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								["WAVE_MAX"]
+							]
+						],
+						[
+							13,
+							"gx",
+							[
+								1,
+								[
+									6,
+									[
+										7,
+										"std",
+										"clamp"
+									],
+									[
+										"waveU",
+										[5, "0"],
+										[5, "1"]
+									]
+								],
+								"*",
+								"Nm1"
+							]
+						],
+						[
+							13,
+							"gy",
+							[
+								1,
+								[
+									6,
+									[
+										7,
+										"std",
+										"clamp"
+									],
+									[
+										"waveV",
+										[5, "0"],
+										[5, "1"]
+									]
+								],
+								"*",
+								"Nm1"
+							]
+						],
+						[
+							13,
+							"ix",
+							[
+								6,
+								[
+									7,
+									"d",
+									"u32"
+								],
+								[[
+									6,
+									[
+										7,
+										"std",
+										"clamp"
+									],
+									[
+										"gx",
+										[5, "0"],
+										"Nm1"
+									]
+								]]
+							]
+						],
+						[
+							13,
+							"iy",
+							[
+								6,
+								[
+									7,
+									"d",
+									"u32"
+								],
+								[[
+									6,
+									[
+										7,
+										"std",
+										"clamp"
+									],
+									[
+										"gy",
+										[5, "0"],
+										"Nm1"
+									]
+								]]
+							]
+						],
+						[
+							13,
+							"ix1",
+							[
+								6,
+								[
+									7,
+									"std",
+									"min"
+								],
+								[[
+									1,
+									"ix",
+									"+",
+									[
+										6,
+										[
+											7,
+											"d",
+											"u32"
+										],
+										[[5, "1"]]
+									]
+								], [
+									6,
+									[
+										7,
+										"d",
+										"u32"
+									],
+									["WAVE_MAX"]
+								]]
+							]
+						],
+						[
+							13,
+							"iy1",
+							[
+								6,
+								[
+									7,
+									"std",
+									"min"
+								],
+								[[
+									1,
+									"iy",
+									"+",
+									[
+										6,
+										[
+											7,
+											"d",
+											"u32"
+										],
+										[[5, "1"]]
+									]
+								], [
+									6,
+									[
+										7,
+										"d",
+										"u32"
+									],
+									["WAVE_MAX"]
+								]]
+							]
+						],
+						[
+							13,
+							"fx",
+							[
+								1,
+								"gx",
+								"-",
+								[
+									6,
+									[
+										7,
+										"std",
+										"floor"
+									],
+									["gx"]
+								]
+							]
+						],
+						[
+							13,
+							"fy",
+							[
+								1,
+								"gy",
+								"-",
+								[
+									6,
+									[
+										7,
+										"std",
+										"floor"
+									],
+									["gy"]
+								]
+							]
+						],
+						[
+							13,
+							"W",
+							[
+								6,
+								[
+									7,
+									"d",
+									"u32"
+								],
+								["WAVE_GRID"]
+							]
+						],
+						[
+							13,
+							"v00",
+							[
+								8,
+								[
+									7,
+									[
+										7,
+										"computeLayout",
+										"$"
+									],
+									"readBuf"
+								],
+								[
+									1,
+									[
+										1,
+										"iy",
+										"*",
+										"W"
+									],
+									"+",
+									"ix"
+								]
+							]
+						],
+						[
+							13,
+							"v10",
+							[
+								8,
+								[
+									7,
+									[
+										7,
+										"computeLayout",
+										"$"
+									],
+									"readBuf"
+								],
+								[
+									1,
+									[
+										1,
+										"iy",
+										"*",
+										"W"
+									],
+									"+",
+									"ix1"
+								]
+							]
+						],
+						[
+							13,
+							"v01",
+							[
+								8,
+								[
+									7,
+									[
+										7,
+										"computeLayout",
+										"$"
+									],
+									"readBuf"
+								],
+								[
+									1,
+									[
+										1,
+										"iy1",
+										"*",
+										"W"
+									],
+									"+",
+									"ix"
+								]
+							]
+						],
+						[
+							13,
+							"v11",
+							[
+								8,
+								[
+									7,
+									[
+										7,
+										"computeLayout",
+										"$"
+									],
+									"readBuf"
+								],
+								[
+									1,
+									[
+										1,
+										"iy1",
+										"*",
+										"W"
+									],
+									"+",
+									"ix1"
+								]
+							]
+						],
+						[
+							13,
+							"waveSample",
+							[
+								6,
+								[
+									7,
+									"std",
+									"mix"
+								],
+								[
+									[
+										6,
+										[
+											7,
+											"std",
+											"mix"
+										],
+										[
+											"v00",
+											"v10",
+											"fx"
+										]
+									],
+									[
+										6,
+										[
+											7,
+											"std",
+											"mix"
+										],
+										[
+											"v01",
+											"v11",
+											"fx"
+										]
+									],
+									"fy"
+								]
+							]
+						],
+						[10, [
+							1,
+							"baseHeight",
+							"+",
+							[
+								1,
+								"waveSample",
+								"*",
+								[
+									1,
+									[
+										7,
+										"p",
+										"cursorIntensity"
+									],
+									"*",
+									[5, "0.05"]
+								]
+							]
+						]]
+					]],
+					[0, [[10, "baseHeight"]]]
+				]
+			]],
+			"externalNames": [
+				"computeLayout",
+				"d",
+				"waveType",
+				"octaveCount",
+				"std",
+				"TWO_PI",
+				"invTotalWeight",
+				"noise",
+				"cursorEnabled",
+				"WAVE_HALFEXTENT",
+				"WAVE_MAX",
+				"WAVE_GRID"
+			]
+		},
+		externals: () => ({
+			computeLayout,
+			d,
+			waveType,
+			octaveCount,
+			std,
+			TWO_PI,
+			invTotalWeight,
+			noise: noise_exports,
+			cursorEnabled,
+			WAVE_HALFEXTENT,
+			WAVE_MAX,
+			WAVE_GRID
+		})
+	}) && $.f)({})).$name("surface3dHeight");
+}
+function makePropagateKernel() {
+	return tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+		"use gpu";
+		if (cx > d.u32(0) && cx < d.u32(WAVE_MAX) && cy > d.u32(0) && cy < d.u32(WAVE_MAX)) {
+			const p = propagateLayout.$.params;
+			const gs = d.u32(WAVE_GRID);
+			const idx = __tsover_add(__tsover_mul(cy, gs), cx);
+			const left = propagateLayout.$.readSrc[__tsover_sub(idx, d.u32(1))];
+			const right = propagateLayout.$.readSrc[__tsover_add(idx, d.u32(1))];
+			const up = propagateLayout.$.readSrc[__tsover_sub(idx, gs)];
+			const down = propagateLayout.$.readSrc[__tsover_add(idx, gs)];
+			const center = propagateLayout.$.readSrc[idx];
+			const sum = __tsover_add(__tsover_add(__tsover_add(left, right), up), down);
+			const prev = propagateLayout.$.writeBuf[idx];
+			const dampFactor = __tsover_sub(1, __tsover_mul(p.decay, .004));
+			const k2 = __tsover_mul(.5, __tsover_mul(p.waveSpeed, p.waveSpeed));
+			const lap = __tsover_sub(sum, __tsover_mul(center, 4));
+			let next = __tsover_mul(__tsover_sub(__tsover_add(__tsover_mul(center, 2), __tsover_mul(lap, k2)), prev), dampFactor);
+			const cellU = __tsover_div(__tsover_add(d.f32(cx), .5), d.f32(WAVE_GRID));
+			const cellV = __tsover_div(__tsover_add(d.f32(cy), .5), d.f32(WAVE_GRID));
+			const ddx = __tsover_sub(cellU, p.cursorWaveX);
+			const ddy = __tsover_sub(cellV, p.cursorWaveY);
+			const distSq = __tsover_add(__tsover_mul(ddx, ddx), __tsover_mul(ddy, ddy));
+			const influenceRadius = __tsover_mul(p.radius, 3);
+			if (distSq < __tsover_mul(influenceRadius, influenceRadius) && p.mouseSpeed > .01) {
+				const influence = std.exp(__tsover_mul(__tsover_div(distSq, std.max(__tsover_mul(p.radius, p.radius), d.f32(1e-4))), -1));
+				next = __tsover_sub(next, __tsover_mul(__tsover_mul(__tsover_mul(influence, p.mouseSpeed), p.dt), 3));
+			}
+			propagateLayout.$.writeBuf[idx] = next;
+			propagateLayout.$.readBuf[idx] = next;
+		}
+	}), {
+		v: 1,
+		name: void 0,
+		ast: {
+			"params": [{
+				"type": "i",
+				"name": "cx"
+			}, {
+				"type": "i",
+				"name": "cy"
+			}],
+			"body": [0, [[
+				11,
+				[
+					3,
+					[
+						3,
+						[
+							3,
+							[
+								1,
+								"cx",
+								">",
+								[
+									6,
+									[
+										7,
+										"d",
+										"u32"
+									],
+									[[5, "0"]]
+								]
+							],
+							"&&",
+							[
+								1,
+								"cx",
+								"<",
+								[
+									6,
+									[
+										7,
+										"d",
+										"u32"
+									],
+									["WAVE_MAX"]
+								]
+							]
+						],
+						"&&",
+						[
+							1,
+							"cy",
+							">",
+							[
+								6,
+								[
+									7,
+									"d",
+									"u32"
+								],
+								[[5, "0"]]
+							]
+						]
+					],
+					"&&",
+					[
+						1,
+						"cy",
+						"<",
+						[
+							6,
+							[
+								7,
+								"d",
+								"u32"
+							],
+							["WAVE_MAX"]
+						]
+					]
+				],
+				[0, [
+					[
+						13,
+						"p",
+						[
+							7,
+							[
+								7,
+								"propagateLayout",
+								"$"
+							],
+							"params"
+						]
+					],
+					[
+						13,
+						"gs",
+						[
+							6,
+							[
+								7,
+								"d",
+								"u32"
+							],
+							["WAVE_GRID"]
+						]
+					],
+					[
+						13,
+						"idx",
+						[
+							1,
+							[
+								1,
+								"cy",
+								"*",
+								"gs"
+							],
+							"+",
+							"cx"
+						]
+					],
+					[
+						13,
+						"left",
+						[
+							8,
+							[
+								7,
+								[
+									7,
+									"propagateLayout",
+									"$"
+								],
+								"readSrc"
+							],
+							[
+								1,
+								"idx",
+								"-",
+								[
+									6,
+									[
+										7,
+										"d",
+										"u32"
+									],
+									[[5, "1"]]
+								]
+							]
+						]
+					],
+					[
+						13,
+						"right",
+						[
+							8,
+							[
+								7,
+								[
+									7,
+									"propagateLayout",
+									"$"
+								],
+								"readSrc"
+							],
+							[
+								1,
+								"idx",
+								"+",
+								[
+									6,
+									[
+										7,
+										"d",
+										"u32"
+									],
+									[[5, "1"]]
+								]
+							]
+						]
+					],
+					[
+						13,
+						"up",
+						[
+							8,
+							[
+								7,
+								[
+									7,
+									"propagateLayout",
+									"$"
+								],
+								"readSrc"
+							],
+							[
+								1,
+								"idx",
+								"-",
+								"gs"
+							]
+						]
+					],
+					[
+						13,
+						"down",
+						[
+							8,
+							[
+								7,
+								[
+									7,
+									"propagateLayout",
+									"$"
+								],
+								"readSrc"
+							],
+							[
+								1,
+								"idx",
+								"+",
+								"gs"
+							]
+						]
+					],
+					[
+						13,
+						"center",
+						[
+							8,
+							[
+								7,
+								[
+									7,
+									"propagateLayout",
+									"$"
+								],
+								"readSrc"
+							],
+							"idx"
+						]
+					],
+					[
+						13,
+						"sum",
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									"left",
+									"+",
+									"right"
+								],
+								"+",
+								"up"
+							],
+							"+",
+							"down"
+						]
+					],
+					[
+						13,
+						"prev",
+						[
+							8,
+							[
+								7,
+								[
+									7,
+									"propagateLayout",
+									"$"
+								],
+								"writeBuf"
+							],
+							"idx"
+						]
+					],
+					[
+						13,
+						"dampFactor",
+						[
+							1,
+							[5, "1"],
+							"-",
+							[
+								1,
+								[
+									7,
+									"p",
+									"decay"
+								],
+								"*",
+								[5, "0.004"]
+							]
+						]
+					],
+					[
+						13,
+						"k2",
+						[
+							1,
+							[5, "0.5"],
+							"*",
+							[
+								1,
+								[
+									7,
+									"p",
+									"waveSpeed"
+								],
+								"*",
+								[
+									7,
+									"p",
+									"waveSpeed"
+								]
+							]
+						]
+					],
+					[
+						13,
+						"lap",
+						[
+							1,
+							"sum",
+							"-",
+							[
+								1,
+								"center",
+								"*",
+								[5, "4"]
+							]
+						]
+					],
+					[
+						12,
+						"next",
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									[
+										1,
+										"center",
+										"*",
+										[5, "2"]
+									],
+									"+",
+									[
+										1,
+										"lap",
+										"*",
+										"k2"
+									]
+								],
+								"-",
+								"prev"
+							],
+							"*",
+							"dampFactor"
+						]
+					],
+					[
+						13,
+						"cellU",
+						[
+							1,
+							[
+								1,
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									["cx"]
+								],
+								"+",
+								[5, "0.5"]
+							],
+							"/",
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								["WAVE_GRID"]
+							]
+						]
+					],
+					[
+						13,
+						"cellV",
+						[
+							1,
+							[
+								1,
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									["cy"]
+								],
+								"+",
+								[5, "0.5"]
+							],
+							"/",
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								["WAVE_GRID"]
+							]
+						]
+					],
+					[
+						13,
+						"ddx",
+						[
+							1,
+							"cellU",
+							"-",
+							[
+								7,
+								"p",
+								"cursorWaveX"
+							]
+						]
+					],
+					[
+						13,
+						"ddy",
+						[
+							1,
+							"cellV",
+							"-",
+							[
+								7,
+								"p",
+								"cursorWaveY"
+							]
+						]
+					],
+					[
+						13,
+						"distSq",
+						[
+							1,
+							[
+								1,
+								"ddx",
+								"*",
+								"ddx"
+							],
+							"+",
+							[
+								1,
+								"ddy",
+								"*",
+								"ddy"
+							]
+						]
+					],
+					[
+						13,
+						"influenceRadius",
+						[
+							1,
+							[
+								7,
+								"p",
+								"radius"
+							],
+							"*",
+							[5, "3"]
+						]
+					],
+					[
+						11,
+						[
+							3,
+							[
+								1,
+								"distSq",
+								"<",
+								[
+									1,
+									"influenceRadius",
+									"*",
+									"influenceRadius"
+								]
+							],
+							"&&",
+							[
+								1,
+								[
+									7,
+									"p",
+									"mouseSpeed"
+								],
+								">",
+								[5, "0.01"]
+							]
+						],
+						[0, [[
+							13,
+							"influence",
+							[
+								6,
+								[
+									7,
+									"std",
+									"exp"
+								],
+								[[
+									1,
+									[
+										1,
+										"distSq",
+										"/",
+										[
+											6,
+											[
+												7,
+												"std",
+												"max"
+											],
+											[[
+												1,
+												[
+													7,
+													"p",
+													"radius"
+												],
+												"*",
+												[
+													7,
+													"p",
+													"radius"
+												]
+											], [
+												6,
+												[
+													7,
+													"d",
+													"f32"
+												],
+												[[5, "0.0001"]]
+											]]
+										]
+									],
+									"*",
+									[
+										4,
+										"-",
+										[5, "1"]
+									]
+								]]
+							]
+						], [
+							2,
+							"next",
+							"=",
+							[
+								1,
+								"next",
+								"-",
+								[
+									1,
+									[
+										1,
+										[
+											1,
+											"influence",
+											"*",
+											[
+												7,
+												"p",
+												"mouseSpeed"
+											]
+										],
+										"*",
+										[
+											7,
+											"p",
+											"dt"
+										]
+									],
+									"*",
+									[5, "3"]
+								]
+							]
+						]]]
+					],
+					[
+						2,
+						[
+							8,
+							[
+								7,
+								[
+									7,
+									"propagateLayout",
+									"$"
+								],
+								"writeBuf"
+							],
+							"idx"
+						],
+						"=",
+						"next"
+					],
+					[
+						2,
+						[
+							8,
+							[
+								7,
+								[
+									7,
+									"propagateLayout",
+									"$"
+								],
+								"readBuf"
+							],
+							"idx"
+						],
+						"=",
+						"next"
+					]
+				]]
+			]]],
+			"externalNames": [
+				"d",
+				"WAVE_MAX",
+				"propagateLayout",
+				"WAVE_GRID",
+				"std"
+			]
+		},
+		externals: () => ({
+			d,
+			WAVE_MAX,
+			propagateLayout,
+			WAVE_GRID,
+			std
+		})
+	}) && $.f)({})).$name("surface3dPropagate");
+}
+function makeComputeKernel(waveType, octaveCount, edgeMode, lightingEnabled, cursorEnabled) {
+	const heightFn = buildHeightFn(waveType, octaveCount, cursorEnabled);
+	return tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+		"use gpu";
+		const p = computeLayout.$.params;
+		const screenU = __tsover_div(__tsover_add(d.f32(cx), .5), d.f32(COMPUTE_W));
+		const screenV = __tsover_div(__tsover_add(d.f32(cy), .5), d.f32(COMPUTE_H));
+		const ndcX = __tsover_mul(__tsover_mul(__tsover_sub(screenU, .5), 2), p.aspect);
+		const ndcY = __tsover_mul(__tsover_mul(__tsover_sub(screenV, .5), 2), -1);
+		const rayDir = std.normalize(p.camForward.mul(p.focal).add(p.camRight.mul(ndcX)).add(p.camUp.mul(ndcY)));
+		const STEPS = 32;
+		const REFINE = 6;
+		const rayDownComp = std.max(__tsover_mul(rayDir.z, -1), d.f32(.05));
+		const tToBase = __tsover_div(p.camPos.z, rayDownComp);
+		const marchTotal = std.min(__tsover_add(tToBase, 1.5), 15);
+		const stepSize = __tsover_div(marchTotal, d.f32(STEPS));
+		let tMarch = d.f32(0);
+		let hit = d.f32(0);
+		const u0 = __tsover_add(__tsover_mul(p.camPos.x, .5), .5);
+		const v0 = __tsover_add(__tsover_mul(p.camPos.y, .5), .5);
+		let prevDiff = __tsover_sub(p.camPos.z, heightFn(d.vec2f(u0, v0)));
+		for (let s = 0; s < STEPS; s++) {
+			tMarch = __tsover_add(tMarch, stepSize);
+			const pos = p.camPos.add(rayDir.mul(tMarch));
+			const h = heightFn(d.vec2f(__tsover_add(__tsover_mul(pos.x, .5), .5), __tsover_add(__tsover_mul(pos.y, .5), .5)));
+			const diff = __tsover_sub(pos.z, h);
+			if (diff < 0 && prevDiff > 0) {
+				hit = 1;
+				break;
+			}
+			prevDiff = diff;
+		}
+		let tLow = __tsover_sub(tMarch, stepSize);
+		let tHigh = tMarch;
+		for (let r = 0; r < REFINE; r++) {
+			const tMid = __tsover_mul(__tsover_add(tLow, tHigh), .5);
+			const pMid = p.camPos.add(rayDir.mul(tMid));
+			if (__tsover_sub(pMid.z, heightFn(d.vec2f(__tsover_add(__tsover_mul(pMid.x, .5), .5), __tsover_add(__tsover_mul(pMid.y, .5), .5)))) > 0) tLow = tMid;
+			else tHigh = tMid;
+		}
+		const finalT = __tsover_mul(__tsover_add(tLow, tHigh), .5);
+		const hitPos = p.camPos.add(rayDir.mul(finalT));
+		const hitU = __tsover_add(__tsover_mul(hitPos.x, .5), .5);
+		const hitV = __tsover_add(__tsover_mul(hitPos.y, .5), .5);
+		const rawSampleUV = d.vec2f(hitU, __tsover_sub(1, hitV));
+		let finalUV = d.vec2f(rawSampleUV.x, rawSampleUV.y);
+		let outOfBoundsMask = d.f32(1);
+		if (edgeMode === 2) finalUV = edgeMirrorUV(rawSampleUV);
+		else if (edgeMode === 3) finalUV = edgeWrapUV(rawSampleUV);
+		else if (edgeMode === 1) {
+			const inside = rawSampleUV.x >= 0 && rawSampleUV.x <= 1 && rawSampleUV.y >= 0 && rawSampleUV.y <= 1;
+			outOfBoundsMask = std.select(d.f32(0), d.f32(1), inside);
+		} else finalUV = std.clamp(rawSampleUV, d.vec2f(0, 0), d.vec2f(1, 1));
+		let lit = d.vec3f(1, 1, 1);
+		if (lightingEnabled) {
+			const normalEps = .01;
+			const hC = heightFn(d.vec2f(hitU, hitV));
+			const hR = heightFn(d.vec2f(__tsover_add(hitU, normalEps), hitV));
+			const hUp = heightFn(d.vec2f(hitU, __tsover_add(hitV, normalEps)));
+			const dhdu = __tsover_div(__tsover_sub(hR, hC), normalEps);
+			const dhdv = __tsover_div(__tsover_sub(hUp, hC), normalEps);
+			const nrm = std.normalize(d.vec3f(__tsover_mul(dhdu, -.5), __tsover_mul(dhdv, -.5), 1));
+			const lightDir = std.normalize(d.vec3f(p.lightX, p.lightY, p.lightZ));
+			const viewDir = rayDir.mul(-1);
+			const diffuse = std.clamp(std.dot(nrm, lightDir), 0, 1);
+			const halfVec = std.normalize(lightDir.add(viewDir));
+			const specPow = __tsover_add(__tsover_mul(p.glossiness, 128), 4);
+			const specular = __tsover_mul(std.pow(std.clamp(std.dot(nrm, halfVec), 0, 1), specPow), p.highlights);
+			const ambient = d.vec3f(.4, .4, .4);
+			const tintedDiffuse = p.lightColor.mul(__tsover_mul(diffuse, .6));
+			const tintedSpec = p.lightColor.mul(specular);
+			const totalLight = ambient.add(tintedDiffuse).add(tintedSpec);
+			lit = std.clamp(std.mix(d.vec3f(1, 1, 1), totalLight, p.lighting), d.vec3f(0, 0, 0), d.vec3f(3, 3, 3));
+		}
+		const CUTOFF_RANGE = d.f32(15);
+		const edgeAA = .05;
+		const nearT = __tsover_mul(p.nearCutoff, CUTOFF_RANGE);
+		const farT = __tsover_mul(p.farCutoff, CUTOFF_RANGE);
+		const nearMask = std.smoothstep(__tsover_sub(nearT, edgeAA), __tsover_add(nearT, edgeAA), finalT);
+		const farMask = std.smoothstep(__tsover_add(farT, edgeAA), __tsover_sub(farT, edgeAA), finalT);
+		const finalMask = __tsover_mul(__tsover_mul(hit, outOfBoundsMask), __tsover_mul(nearMask, farMask));
+		std.textureStore(computeLayout.$.uvMaskTex, d.vec2u(cx, cy), d.vec4f(finalUV.x, finalUV.y, finalMask, 0));
+		std.textureStore(computeLayout.$.litTex, d.vec2u(cx, cy), d.vec4f(lit, 0));
+	}), {
+		v: 1,
+		name: void 0,
+		ast: {
+			"params": [{
+				"type": "i",
+				"name": "cx"
+			}, {
+				"type": "i",
+				"name": "cy"
+			}],
+			"body": [0, [
+				[
+					13,
+					"p",
+					[
+						7,
+						[
+							7,
+							"computeLayout",
+							"$"
+						],
+						"params"
+					]
+				],
+				[
+					13,
+					"screenU",
+					[
+						1,
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								["cx"]
+							],
+							"+",
+							[5, "0.5"]
+						],
+						"/",
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							["COMPUTE_W"]
+						]
+					]
+				],
+				[
+					13,
+					"screenV",
+					[
+						1,
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								["cy"]
+							],
+							"+",
+							[5, "0.5"]
+						],
+						"/",
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							["COMPUTE_H"]
+						]
+					]
+				],
+				[
+					13,
+					"ndcX",
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								"screenU",
+								"-",
+								[5, "0.5"]
+							],
+							"*",
+							[5, "2"]
+						],
+						"*",
+						[
+							7,
+							"p",
+							"aspect"
+						]
+					]
+				],
+				[
+					13,
+					"ndcY",
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								"screenV",
+								"-",
+								[5, "0.5"]
+							],
+							"*",
+							[5, "2"]
+						],
+						"*",
+						[
+							4,
+							"-",
+							[5, "1"]
+						]
+					]
+				],
+				[
+					13,
+					"rayDir",
+					[
+						6,
+						[
+							7,
+							"std",
+							"normalize"
+						],
+						[[
+							6,
+							[
+								7,
+								[
+									6,
+									[
+										7,
+										[
+											6,
+											[
+												7,
+												[
+													7,
+													"p",
+													"camForward"
+												],
+												"mul"
+											],
+											[[
+												7,
+												"p",
+												"focal"
+											]]
+										],
+										"add"
+									],
+									[[
+										6,
+										[
+											7,
+											[
+												7,
+												"p",
+												"camRight"
+											],
+											"mul"
+										],
+										["ndcX"]
+									]]
+								],
+								"add"
+							],
+							[[
+								6,
+								[
+									7,
+									[
+										7,
+										"p",
+										"camUp"
+									],
+									"mul"
+								],
+								["ndcY"]
+							]]
+						]]
+					]
+				],
+				[
+					13,
+					"STEPS",
+					[5, "32"]
+				],
+				[
+					13,
+					"REFINE",
+					[5, "6"]
+				],
+				[
+					13,
+					"rayDownComp",
+					[
+						6,
+						[
+							7,
+							"std",
+							"max"
+						],
+						[[
+							1,
+							[
+								7,
+								"rayDir",
+								"z"
+							],
+							"*",
+							[
+								4,
+								"-",
+								[5, "1"]
+							]
+						], [
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "0.05"]]
+						]]
+					]
+				],
+				[
+					13,
+					"tToBase",
+					[
+						1,
+						[
+							7,
+							[
+								7,
+								"p",
+								"camPos"
+							],
+							"z"
+						],
+						"/",
+						"rayDownComp"
+					]
+				],
+				[
+					13,
+					"marchTotal",
+					[
+						6,
+						[
+							7,
+							"std",
+							"min"
+						],
+						[[
+							1,
+							"tToBase",
+							"+",
+							[5, "1.5"]
+						], [5, "15"]]
+					]
+				],
+				[
+					13,
+					"stepSize",
+					[
+						1,
+						"marchTotal",
+						"/",
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							["STEPS"]
+						]
+					]
+				],
+				[
+					12,
+					"tMarch",
+					[
+						6,
+						[
+							7,
+							"d",
+							"f32"
+						],
+						[[5, "0"]]
+					]
+				],
+				[
+					12,
+					"hit",
+					[
+						6,
+						[
+							7,
+							"d",
+							"f32"
+						],
+						[[5, "0"]]
+					]
+				],
+				[
+					13,
+					"u0",
+					[
+						1,
+						[
+							1,
+							[
+								7,
+								[
+									7,
+									"p",
+									"camPos"
+								],
+								"x"
+							],
+							"*",
+							[5, "0.5"]
+						],
+						"+",
+						[5, "0.5"]
+					]
+				],
+				[
+					13,
+					"v0",
+					[
+						1,
+						[
+							1,
+							[
+								7,
+								[
+									7,
+									"p",
+									"camPos"
+								],
+								"y"
+							],
+							"*",
+							[5, "0.5"]
+						],
+						"+",
+						[5, "0.5"]
+					]
+				],
+				[
+					12,
+					"prevDiff",
+					[
+						1,
+						[
+							7,
+							[
+								7,
+								"p",
+								"camPos"
+							],
+							"z"
+						],
+						"-",
+						[
+							6,
+							"heightFn",
+							[[
+								6,
+								[
+									7,
+									"d",
+									"vec2f"
+								],
+								["u0", "v0"]
+							]]
+						]
+					]
+				],
+				[
+					14,
+					[
+						12,
+						"s",
+						[5, "0"]
+					],
+					[
+						1,
+						"s",
+						"<",
+						"STEPS"
+					],
+					[
+						102,
+						"++",
+						"s"
+					],
+					[0, [
+						[
+							2,
+							"tMarch",
+							"=",
+							[
+								1,
+								"tMarch",
+								"+",
+								"stepSize"
+							]
+						],
+						[
+							13,
+							"pos",
+							[
+								6,
+								[
+									7,
+									[
+										7,
+										"p",
+										"camPos"
+									],
+									"add"
+								],
+								[[
+									6,
+									[
+										7,
+										"rayDir",
+										"mul"
+									],
+									["tMarch"]
+								]]
+							]
+						],
+						[
+							13,
+							"h",
+							[
+								6,
+								"heightFn",
+								[[
+									6,
+									[
+										7,
+										"d",
+										"vec2f"
+									],
+									[[
+										1,
+										[
+											1,
+											[
+												7,
+												"pos",
+												"x"
+											],
+											"*",
+											[5, "0.5"]
+										],
+										"+",
+										[5, "0.5"]
+									], [
+										1,
+										[
+											1,
+											[
+												7,
+												"pos",
+												"y"
+											],
+											"*",
+											[5, "0.5"]
+										],
+										"+",
+										[5, "0.5"]
+									]]
+								]]
+							]
+						],
+						[
+							13,
+							"diff",
+							[
+								1,
+								[
+									7,
+									"pos",
+									"z"
+								],
+								"-",
+								"h"
+							]
+						],
+						[
+							11,
+							[
+								3,
+								[
+									1,
+									"diff",
+									"<",
+									[5, "0"]
+								],
+								"&&",
+								[
+									1,
+									"prevDiff",
+									">",
+									[5, "0"]
+								]
+							],
+							[0, [[
+								2,
+								"hit",
+								"=",
+								[5, "1"]
+							], [17]]]
+						],
+						[
+							2,
+							"prevDiff",
+							"=",
+							"diff"
+						]
+					]]
+				],
+				[
+					12,
+					"tLow",
+					[
+						1,
+						"tMarch",
+						"-",
+						"stepSize"
+					]
+				],
+				[
+					12,
+					"tHigh",
+					"tMarch"
+				],
+				[
+					14,
+					[
+						12,
+						"r",
+						[5, "0"]
+					],
+					[
+						1,
+						"r",
+						"<",
+						"REFINE"
+					],
+					[
+						102,
+						"++",
+						"r"
+					],
+					[0, [
+						[
+							13,
+							"tMid",
+							[
+								1,
+								[
+									1,
+									"tLow",
+									"+",
+									"tHigh"
+								],
+								"*",
+								[5, "0.5"]
+							]
+						],
+						[
+							13,
+							"pMid",
+							[
+								6,
+								[
+									7,
+									[
+										7,
+										"p",
+										"camPos"
+									],
+									"add"
+								],
+								[[
+									6,
+									[
+										7,
+										"rayDir",
+										"mul"
+									],
+									["tMid"]
+								]]
+							]
+						],
+						[
+							13,
+							"dMid",
+							[
+								1,
+								[
+									7,
+									"pMid",
+									"z"
+								],
+								"-",
+								[
+									6,
+									"heightFn",
+									[[
+										6,
+										[
+											7,
+											"d",
+											"vec2f"
+										],
+										[[
+											1,
+											[
+												1,
+												[
+													7,
+													"pMid",
+													"x"
+												],
+												"*",
+												[5, "0.5"]
+											],
+											"+",
+											[5, "0.5"]
+										], [
+											1,
+											[
+												1,
+												[
+													7,
+													"pMid",
+													"y"
+												],
+												"*",
+												[5, "0.5"]
+											],
+											"+",
+											[5, "0.5"]
+										]]
+									]]
+								]
+							]
+						],
+						[
+							11,
+							[
+								1,
+								"dMid",
+								">",
+								[5, "0"]
+							],
+							[0, [[
+								2,
+								"tLow",
+								"=",
+								"tMid"
+							]]],
+							[0, [[
+								2,
+								"tHigh",
+								"=",
+								"tMid"
+							]]]
+						]
+					]]
+				],
+				[
+					13,
+					"finalT",
+					[
+						1,
+						[
+							1,
+							"tLow",
+							"+",
+							"tHigh"
+						],
+						"*",
+						[5, "0.5"]
+					]
+				],
+				[
+					13,
+					"hitPos",
+					[
+						6,
+						[
+							7,
+							[
+								7,
+								"p",
+								"camPos"
+							],
+							"add"
+						],
+						[[
+							6,
+							[
+								7,
+								"rayDir",
+								"mul"
+							],
+							["finalT"]
+						]]
+					]
+				],
+				[
+					13,
+					"hitU",
+					[
+						1,
+						[
+							1,
+							[
+								7,
+								"hitPos",
+								"x"
+							],
+							"*",
+							[5, "0.5"]
+						],
+						"+",
+						[5, "0.5"]
+					]
+				],
+				[
+					13,
+					"hitV",
+					[
+						1,
+						[
+							1,
+							[
+								7,
+								"hitPos",
+								"y"
+							],
+							"*",
+							[5, "0.5"]
+						],
+						"+",
+						[5, "0.5"]
+					]
+				],
+				[
+					13,
+					"rawSampleUV",
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec2f"
+						],
+						["hitU", [
+							1,
+							[5, "1"],
+							"-",
+							"hitV"
+						]]
+					]
+				],
+				[
+					12,
+					"finalUV",
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec2f"
+						],
+						[[
+							7,
+							"rawSampleUV",
+							"x"
+						], [
+							7,
+							"rawSampleUV",
+							"y"
+						]]
+					]
+				],
+				[
+					12,
+					"outOfBoundsMask",
+					[
+						6,
+						[
+							7,
+							"d",
+							"f32"
+						],
+						[[5, "1"]]
+					]
+				],
+				[
+					11,
+					[
+						1,
+						"edgeMode",
+						"===",
+						[5, "2"]
+					],
+					[0, [[
+						2,
+						"finalUV",
+						"=",
+						[
+							6,
+							[
+								7,
+								"edges",
+								"edgeMirrorUV"
+							],
+							["rawSampleUV"]
+						]
+					]]],
+					[
+						11,
+						[
+							1,
+							"edgeMode",
+							"===",
+							[5, "3"]
+						],
+						[0, [[
+							2,
+							"finalUV",
+							"=",
+							[
+								6,
+								[
+									7,
+									"edges",
+									"edgeWrapUV"
+								],
+								["rawSampleUV"]
+							]
+						]]],
+						[
+							11,
+							[
+								1,
+								"edgeMode",
+								"===",
+								[5, "1"]
+							],
+							[0, [[
+								13,
+								"inside",
+								[
+									3,
+									[
+										3,
+										[
+											3,
+											[
+												1,
+												[
+													7,
+													"rawSampleUV",
+													"x"
+												],
+												">=",
+												[5, "0"]
+											],
+											"&&",
+											[
+												1,
+												[
+													7,
+													"rawSampleUV",
+													"x"
+												],
+												"<=",
+												[5, "1"]
+											]
+										],
+										"&&",
+										[
+											1,
+											[
+												7,
+												"rawSampleUV",
+												"y"
+											],
+											">=",
+											[5, "0"]
+										]
+									],
+									"&&",
+									[
+										1,
+										[
+											7,
+											"rawSampleUV",
+											"y"
+										],
+										"<=",
+										[5, "1"]
+									]
+								]
+							], [
+								2,
+								"outOfBoundsMask",
+								"=",
+								[
+									6,
+									[
+										7,
+										"std",
+										"select"
+									],
+									[
+										[
+											6,
+											[
+												7,
+												"d",
+												"f32"
+											],
+											[[5, "0"]]
+										],
+										[
+											6,
+											[
+												7,
+												"d",
+												"f32"
+											],
+											[[5, "1"]]
+										],
+										"inside"
+									]
+								]
+							]]],
+							[0, [[
+								2,
+								"finalUV",
+								"=",
+								[
+									6,
+									[
+										7,
+										"std",
+										"clamp"
+									],
+									[
+										"rawSampleUV",
+										[
+											6,
+											[
+												7,
+												"d",
+												"vec2f"
+											],
+											[[5, "0"], [5, "0"]]
+										],
+										[
+											6,
+											[
+												7,
+												"d",
+												"vec2f"
+											],
+											[[5, "1"], [5, "1"]]
+										]
+									]
+								]
+							]]]
+						]
+					]
+				],
+				[
+					12,
+					"lit",
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec3f"
+						],
+						[
+							[5, "1"],
+							[5, "1"],
+							[5, "1"]
+						]
+					]
+				],
+				[
+					11,
+					"lightingEnabled",
+					[0, [
+						[
+							13,
+							"normalEps",
+							[5, "0.01"]
+						],
+						[
+							13,
+							"hC",
+							[
+								6,
+								"heightFn",
+								[[
+									6,
+									[
+										7,
+										"d",
+										"vec2f"
+									],
+									["hitU", "hitV"]
+								]]
+							]
+						],
+						[
+							13,
+							"hR",
+							[
+								6,
+								"heightFn",
+								[[
+									6,
+									[
+										7,
+										"d",
+										"vec2f"
+									],
+									[[
+										1,
+										"hitU",
+										"+",
+										"normalEps"
+									], "hitV"]
+								]]
+							]
+						],
+						[
+							13,
+							"hUp",
+							[
+								6,
+								"heightFn",
+								[[
+									6,
+									[
+										7,
+										"d",
+										"vec2f"
+									],
+									["hitU", [
+										1,
+										"hitV",
+										"+",
+										"normalEps"
+									]]
+								]]
+							]
+						],
+						[
+							13,
+							"dhdu",
+							[
+								1,
+								[
+									1,
+									"hR",
+									"-",
+									"hC"
+								],
+								"/",
+								"normalEps"
+							]
+						],
+						[
+							13,
+							"dhdv",
+							[
+								1,
+								[
+									1,
+									"hUp",
+									"-",
+									"hC"
+								],
+								"/",
+								"normalEps"
+							]
+						],
+						[
+							13,
+							"nrm",
+							[
+								6,
+								[
+									7,
+									"std",
+									"normalize"
+								],
+								[[
+									6,
+									[
+										7,
+										"d",
+										"vec3f"
+									],
+									[
+										[
+											1,
+											"dhdu",
+											"*",
+											[
+												4,
+												"-",
+												[5, "0.5"]
+											]
+										],
+										[
+											1,
+											"dhdv",
+											"*",
+											[
+												4,
+												"-",
+												[5, "0.5"]
+											]
+										],
+										[5, "1"]
+									]
+								]]
+							]
+						],
+						[
+							13,
+							"lightDir",
+							[
+								6,
+								[
+									7,
+									"std",
+									"normalize"
+								],
+								[[
+									6,
+									[
+										7,
+										"d",
+										"vec3f"
+									],
+									[
+										[
+											7,
+											"p",
+											"lightX"
+										],
+										[
+											7,
+											"p",
+											"lightY"
+										],
+										[
+											7,
+											"p",
+											"lightZ"
+										]
+									]
+								]]
+							]
+						],
+						[
+							13,
+							"viewDir",
+							[
+								6,
+								[
+									7,
+									"rayDir",
+									"mul"
+								],
+								[[
+									4,
+									"-",
+									[5, "1"]
+								]]
+							]
+						],
+						[
+							13,
+							"diffuse",
+							[
+								6,
+								[
+									7,
+									"std",
+									"clamp"
+								],
+								[
+									[
+										6,
+										[
+											7,
+											"std",
+											"dot"
+										],
+										["nrm", "lightDir"]
+									],
+									[5, "0"],
+									[5, "1"]
+								]
+							]
+						],
+						[
+							13,
+							"halfVec",
+							[
+								6,
+								[
+									7,
+									"std",
+									"normalize"
+								],
+								[[
+									6,
+									[
+										7,
+										"lightDir",
+										"add"
+									],
+									["viewDir"]
+								]]
+							]
+						],
+						[
+							13,
+							"specPow",
+							[
+								1,
+								[
+									1,
+									[
+										7,
+										"p",
+										"glossiness"
+									],
+									"*",
+									[5, "128"]
+								],
+								"+",
+								[5, "4"]
+							]
+						],
+						[
+							13,
+							"specular",
+							[
+								1,
+								[
+									6,
+									[
+										7,
+										"std",
+										"pow"
+									],
+									[[
+										6,
+										[
+											7,
+											"std",
+											"clamp"
+										],
+										[
+											[
+												6,
+												[
+													7,
+													"std",
+													"dot"
+												],
+												["nrm", "halfVec"]
+											],
+											[5, "0"],
+											[5, "1"]
+										]
+									], "specPow"]
+								],
+								"*",
+								[
+									7,
+									"p",
+									"highlights"
+								]
+							]
+						],
+						[
+							13,
+							"ambient",
+							[
+								6,
+								[
+									7,
+									"d",
+									"vec3f"
+								],
+								[
+									[5, "0.4"],
+									[5, "0.4"],
+									[5, "0.4"]
+								]
+							]
+						],
+						[
+							13,
+							"tintedDiffuse",
+							[
+								6,
+								[
+									7,
+									[
+										7,
+										"p",
+										"lightColor"
+									],
+									"mul"
+								],
+								[[
+									1,
+									"diffuse",
+									"*",
+									[5, "0.6"]
+								]]
+							]
+						],
+						[
+							13,
+							"tintedSpec",
+							[
+								6,
+								[
+									7,
+									[
+										7,
+										"p",
+										"lightColor"
+									],
+									"mul"
+								],
+								["specular"]
+							]
+						],
+						[
+							13,
+							"totalLight",
+							[
+								6,
+								[
+									7,
+									[
+										6,
+										[
+											7,
+											"ambient",
+											"add"
+										],
+										["tintedDiffuse"]
+									],
+									"add"
+								],
+								["tintedSpec"]
+							]
+						],
+						[
+							2,
+							"lit",
+							"=",
+							[
+								6,
+								[
+									7,
+									"std",
+									"clamp"
+								],
+								[
+									[
+										6,
+										[
+											7,
+											"std",
+											"mix"
+										],
+										[
+											[
+												6,
+												[
+													7,
+													"d",
+													"vec3f"
+												],
+												[
+													[5, "1"],
+													[5, "1"],
+													[5, "1"]
+												]
+											],
+											"totalLight",
+											[
+												7,
+												"p",
+												"lighting"
+											]
+										]
+									],
+									[
+										6,
+										[
+											7,
+											"d",
+											"vec3f"
+										],
+										[
+											[5, "0"],
+											[5, "0"],
+											[5, "0"]
+										]
+									],
+									[
+										6,
+										[
+											7,
+											"d",
+											"vec3f"
+										],
+										[
+											[5, "3"],
+											[5, "3"],
+											[5, "3"]
+										]
+									]
+								]
+							]
+						]
+					]]
+				],
+				[
+					13,
+					"CUTOFF_RANGE",
+					[
+						6,
+						[
+							7,
+							"d",
+							"f32"
+						],
+						[[5, "15"]]
+					]
+				],
+				[
+					13,
+					"edgeAA",
+					[5, "0.05"]
+				],
+				[
+					13,
+					"nearT",
+					[
+						1,
+						[
+							7,
+							"p",
+							"nearCutoff"
+						],
+						"*",
+						"CUTOFF_RANGE"
+					]
+				],
+				[
+					13,
+					"farT",
+					[
+						1,
+						[
+							7,
+							"p",
+							"farCutoff"
+						],
+						"*",
+						"CUTOFF_RANGE"
+					]
+				],
+				[
+					13,
+					"nearMask",
+					[
+						6,
+						[
+							7,
+							"std",
+							"smoothstep"
+						],
+						[
+							[
+								1,
+								"nearT",
+								"-",
+								"edgeAA"
+							],
+							[
+								1,
+								"nearT",
+								"+",
+								"edgeAA"
+							],
+							"finalT"
+						]
+					]
+				],
+				[
+					13,
+					"farMask",
+					[
+						6,
+						[
+							7,
+							"std",
+							"smoothstep"
+						],
+						[
+							[
+								1,
+								"farT",
+								"+",
+								"edgeAA"
+							],
+							[
+								1,
+								"farT",
+								"-",
+								"edgeAA"
+							],
+							"finalT"
+						]
+					]
+				],
+				[
+					13,
+					"finalMask",
+					[
+						1,
+						[
+							1,
+							"hit",
+							"*",
+							"outOfBoundsMask"
+						],
+						"*",
+						[
+							1,
+							"nearMask",
+							"*",
+							"farMask"
+						]
+					]
+				],
+				[
+					6,
+					[
+						7,
+						"std",
+						"textureStore"
+					],
+					[
+						[
+							7,
+							[
+								7,
+								"computeLayout",
+								"$"
+							],
+							"uvMaskTex"
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec2u"
+							],
+							["cx", "cy"]
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec4f"
+							],
+							[
+								[
+									7,
+									"finalUV",
+									"x"
+								],
+								[
+									7,
+									"finalUV",
+									"y"
+								],
+								"finalMask",
+								[5, "0"]
+							]
+						]
+					]
+				],
+				[
+					6,
+					[
+						7,
+						"std",
+						"textureStore"
+					],
+					[
+						[
+							7,
+							[
+								7,
+								"computeLayout",
+								"$"
+							],
+							"litTex"
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec2u"
+							],
+							["cx", "cy"]
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec4f"
+							],
+							["lit", [5, "0"]]
+						]
+					]
+				]
+			]],
+			"externalNames": [
+				"computeLayout",
+				"d",
+				"COMPUTE_W",
+				"COMPUTE_H",
+				"std",
+				"heightFn",
+				"edgeMode",
+				"edges",
+				"lightingEnabled"
+			]
+		},
+		externals: () => ({
+			computeLayout,
+			d,
+			COMPUTE_W,
+			COMPUTE_H,
+			std,
+			heightFn,
+			edgeMode,
+			edges: edges_exports,
+			lightingEnabled
+		})
+	}) && $.f)({})).$name("surface3dRaymarch");
+}
+const surface3dCompose = tgpu.fn([
+	d.vec4f,
+	d.vec3f,
+	d.f32
+], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((childColor, lit, mask) => {
+	"use gpu";
+	const finalRgb = std.clamp(childColor.xyz.mul(lit), d.vec3f(0, 0, 0), d.vec3f(1, 1, 1));
+	return d.vec4f(finalRgb, __tsover_mul(childColor.w, mask));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "childColor"
+			},
+			{
+				"type": "i",
+				"name": "lit"
+			},
+			{
+				"type": "i",
+				"name": "mask"
+			}
+		],
+		"body": [0, [[
+			13,
+			"finalRgb",
+			[
+				6,
+				[
+					7,
+					"std",
+					"clamp"
+				],
+				[
+					[
+						6,
+						[
+							7,
+							[
+								7,
+								"childColor",
+								"xyz"
+							],
+							"mul"
+						],
+						["lit"]
+					],
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec3f"
+						],
+						[
+							[5, "0"],
+							[5, "0"],
+							[5, "0"]
+						]
+					],
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec3f"
+						],
+						[
+							[5, "1"],
+							[5, "1"],
+							[5, "1"]
+						]
+					]
+				]
+			]
+		], [10, [
+			6,
+			[
+				7,
+				"d",
+				"vec4f"
+			],
+			["finalRgb", [
+				1,
+				[
+					7,
+					"childColor",
+					"w"
+				],
+				"*",
+				"mask"
+			]]
+		]]]],
+		"externalNames": ["std", "d"]
+	},
+	externals: () => ({
+		std,
+		d
+	})
+}) && $.f)({}));
+const componentDefinition = {
+	name: "Surface3D",
+	boundingBoxDeclaration: { aspectRatio: null },
+	category: "Distortions",
+	description: "Drapes child content over a 3D wave surface with perspective and lighting",
+	requiresRTT: true,
+	requiresChild: true,
+	usesPointer: true,
+	providesUVContextViaCompute: true,
+	props: {
+		amplitude: {
+			default: .3,
+			description: "Wave height",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Amplitude",
+				group: "Waves"
+			}
+		},
+		waveType: {
+			default: "fractal",
+			compileTime: true,
+			description: "Wave pattern type",
+			ui: {
+				type: "select",
+				options: [
+					{
+						label: "Fractal",
+						value: "fractal"
+					},
+					{
+						label: "Sine",
+						value: "sine"
+					},
+					{
+						label: "Ridge",
+						value: "ridge"
+					}
+				],
+				label: "Wave Type",
+				group: "Waves"
+			}
+		},
+		frequency: {
+			default: 1.5,
+			description: "Wave frequency",
+			ui: {
+				type: "range",
+				min: .1,
+				max: 5,
+				step: .1,
+				label: "Frequency",
+				group: "Waves"
+			}
+		},
+		octaves: {
+			default: 2,
+			compileTime: true,
+			description: "Detail octaves",
+			ui: {
+				type: "range",
+				min: 1,
+				max: 5,
+				step: 1,
+				label: "Octaves",
+				group: "Waves"
+			}
+		},
+		seed: {
+			default: 0,
+			description: "Random seed offset",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 100,
+				step: 1,
+				label: "Seed",
+				group: "Waves"
+			}
+		},
+		speed: {
+			default: .5,
+			description: "Animation speed",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 3,
+				step: .1,
+				label: "Speed",
+				group: "Waves"
+			}
+		},
+		tilt: {
+			default: 35,
+			description: "Camera tilt in degrees",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 85,
+				step: 1,
+				label: "Tilt",
+				group: "Camera"
+			}
+		},
+		roll: {
+			default: 0,
+			description: "Camera roll in degrees",
+			ui: {
+				type: "range",
+				min: -45,
+				max: 45,
+				step: 1,
+				label: "Roll",
+				group: "Camera"
+			}
+		},
+		height: {
+			default: 0,
+			description: "Camera height",
+			ui: {
+				type: "range",
+				min: -1,
+				max: 2,
+				step: .01,
+				label: "Height",
+				group: "Camera"
+			}
+		},
+		zoom: {
+			default: 1,
+			description: "Camera zoom",
+			ui: {
+				type: "range",
+				min: .3,
+				max: 3,
+				step: .01,
+				label: "Zoom",
+				group: "Camera"
+			}
+		},
+		nearCutoff: {
+			default: 0,
+			description: "Near fade distance",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Near Cutoff",
+				group: "Camera"
+			}
+		},
+		farCutoff: {
+			default: 1,
+			description: "Far fade distance",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Far Cutoff",
+				group: "Camera"
+			}
+		},
+		edgePinning: {
+			default: 0,
+			description: "Smoothly flatten the surface at its edges (orthogonal to edge mode)",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Edge Pinning",
+				group: "Waves"
+			}
+		},
+		edges: {
+			default: "mirror",
+			transform: transformEdges,
+			compileTime: true,
+			description: "How to handle content beyond the surface bounds",
+			ui: {
+				type: "select",
+				options: [
+					{
+						label: "Stretch",
+						value: "stretch"
+					},
+					{
+						label: "Transparent",
+						value: "transparent"
+					},
+					{
+						label: "Mirror",
+						value: "mirror"
+					},
+					{
+						label: "Wrap",
+						value: "wrap"
+					}
+				],
+				label: "Edges",
+				group: "Waves"
+			}
+		},
+		lighting: {
+			default: 30,
+			compileTimeWhen: (prev, next) => prev < .01 !== next < .01,
+			description: "Intensity of lighting and shading",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 100,
+				step: 1,
+				label: "Lighting",
+				group: "Lighting"
+			}
+		},
+		glossiness: {
+			default: 0,
+			description: "Surface glossiness",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 100,
+				step: 1,
+				label: "Glossiness",
+				group: "Lighting"
+			}
+		},
+		highlights: {
+			default: 15,
+			description: "Specular highlight intensity",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 100,
+				step: 1,
+				label: "Highlights",
+				group: "Lighting"
+			}
+		},
+		lightX: {
+			default: .4,
+			description: "Light direction X",
+			ui: {
+				type: "range",
+				min: -1,
+				max: 1,
+				step: .01,
+				label: "Light X",
+				group: "Lighting"
+			}
+		},
+		lightY: {
+			default: -.6,
+			description: "Light direction Y",
+			ui: {
+				type: "range",
+				min: -1,
+				max: 1,
+				step: .01,
+				label: "Light Y",
+				group: "Lighting"
+			}
+		},
+		lightZ: {
+			default: .7,
+			description: "Light direction Z",
+			ui: {
+				type: "range",
+				min: -1,
+				max: 1,
+				step: .01,
+				label: "Light Z",
+				group: "Lighting"
+			}
+		},
+		lightColor: {
+			default: "#ffffff",
+			transform: transformColor,
+			description: "Light color",
+			ui: {
+				type: "color",
+				label: "Light Color",
+				group: "Lighting"
+			}
+		},
+		cursorIntensity: {
+			default: 1,
+			compileTimeWhen: (prev, next) => prev < .01 !== next < .01,
+			description: "Strength of cursor ripples",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 2,
+				step: .01,
+				label: "Cursor Ripples",
+				group: "Interaction"
+			}
+		},
+		cursorSpeed: {
+			default: .5,
+			description: "Speed of cursor ripple propagation",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Ripple Speed",
+				group: "Interaction"
+			}
+		}
+	},
+	compute: (params) => {
+		const { gpu, getCpuValue, registerComputeTexture, onCleanup, onResize, dimensions } = params;
+		const root = gpu?.root;
+		if (!root) return null;
+		const waveType = getCpuValue("waveType") === "sine" ? 1 : getCpuValue("waveType") === "ridge" ? 2 : 0;
+		const octaveCount = Math.max(1, Math.floor(getCpuValue("octaves") ?? 2));
+		const edgeMode = getCpuValue("edges") ?? 2;
+		const lightingEnabled = (getCpuValue("lighting") ?? 30) >= .01;
+		const cursorEnabled = (getCpuValue("cursorIntensity") ?? 1) >= .01;
+		const uvMaskTex = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
+			size: [COMPUTE_W, COMPUTE_H],
+			format: STATE_FORMAT
+		}).$usage("storage", "sampled"), "uvMaskTex");
+		const litTex = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
+			size: [COMPUTE_W, COMPUTE_H],
+			format: STATE_FORMAT
+		}).$usage("storage", "sampled"), "litTex");
+		onCleanup(() => {
+			uvMaskTex.destroy();
+			litTex.destroy();
+		});
+		const uvMaskMap = registerComputeTexture(uvMaskTex);
+		const litMap = registerComputeTexture(litTex);
+		const bufferA = createStateBuffer(root, d.f32, WAVE_CELLS);
+		const bufferB = createStateBuffer(root, d.f32, WAVE_CELLS);
+		const readBuf = createStateBuffer(root, d.f32, WAVE_CELLS);
+		const paramsU = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(S3Params), "paramsU");
+		let curW = Math.max(1, Math.round(dimensions.width));
+		let curH = Math.max(1, Math.round(dimensions.height));
+		onResize(({ width, height }) => {
+			curW = Math.max(1, Math.round(width));
+			curH = Math.max(1, Math.round(height));
+		});
+		const computeKernel = makeComputeKernel(waveType, octaveCount, edgeMode, lightingEnabled, cursorEnabled);
+		const computeBg = root.createBindGroup(computeLayout, {
+			readBuf,
+			params: paramsU.buffer,
+			uvMaskTex,
+			litTex
+		});
+		const computePass = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+			"use gpu";
+			computeKernel(cx, cy);
+		}), {
+			v: 1,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "cx"
+				}, {
+					"type": "i",
+					"name": "cy"
+				}],
+				"body": [0, [[
+					6,
+					"computeKernel",
+					["cx", "cy"]
+				]]],
+				"externalNames": ["computeKernel"]
+			},
+			externals: () => ({ computeKernel })
+		}) && $.f)({}), {
+			size: [COMPUTE_W, COMPUTE_H],
+			bindGroup: computeBg
+		});
+		const propagate = cursorEnabled ? makePropagateKernel() : null;
+		const propBgAB = cursorEnabled ? root.createBindGroup(propagateLayout, {
+			readSrc: bufferA,
+			writeBuf: bufferB,
+			readBuf,
+			params: paramsU.buffer
+		}) : null;
+		const propBgBA = cursorEnabled ? root.createBindGroup(propagateLayout, {
+			readSrc: bufferB,
+			writeBuf: bufferA,
+			readBuf,
+			params: paramsU.buffer
+		}) : null;
+		const propagatePass = cursorEnabled && propagate ? createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+			"use gpu";
+			propagate(cx, cy);
+		}), {
+			v: 1,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "cx"
+				}, {
+					"type": "i",
+					"name": "cy"
+				}],
+				"body": [0, [[
+					6,
+					"propagate",
+					["cx", "cy"]
+				]]],
+				"externalNames": ["propagate"]
+			},
+			externals: () => ({ propagate })
+		}) && $.f)({}), { size: [WAVE_GRID, WAVE_GRID] }) : null;
+		let direction = 0;
+		let prevPx = .5;
+		let prevPy = .5;
+		let lastTime = Date.now();
+		let lastActiveTime = Date.now();
+		let animT = 0;
+		const writeParams = (fp, mouseSpeed) => {
+			const aspect = Math.max(1, curW) / Math.max(1, curH);
+			const tilt = (getCpuValue("tilt") ?? 35) * DEG_TO_RAD;
+			const roll = (getCpuValue("roll") ?? 0) * DEG_TO_RAD;
+			const camHeight = getCpuValue("height") ?? 0;
+			const zoom = getCpuValue("zoom") ?? 1;
+			const camDist = .85 / Math.max(1e-4, zoom);
+			const camY = -Math.sin(tilt) * camDist;
+			const orbitZ = Math.cos(tilt) * camDist;
+			const camPos = [
+				0,
+				camY,
+				orbitZ + camHeight
+			];
+			const fwd = norm3([
+				0,
+				-camY,
+				-orbitZ
+			]);
+			const right0 = [
+				1,
+				0,
+				0
+			];
+			const up0 = norm3(cross3(right0, fwd));
+			const cr = Math.cos(roll);
+			const sr = Math.sin(roll);
+			const camRight = [
+				right0[0] * cr + up0[0] * sr,
+				right0[1] * cr + up0[1] * sr,
+				right0[2] * cr + up0[2] * sr
+			];
+			const camUp = [
+				up0[0] * cr - right0[0] * sr,
+				up0[1] * cr - right0[1] * sr,
+				up0[2] * cr - right0[2] * sr
+			];
+			const focal = 1.5;
+			const px = fp.pointer?.x ?? .5;
+			const py = fp.pointer?.y ?? .5;
+			const cNdcX = (px - .5) * 2 * aspect;
+			const cNdcY = -(py - .5) * 2;
+			const rd = norm3([
+				fwd[0] * focal + camRight[0] * cNdcX + camUp[0] * cNdcY,
+				fwd[1] * focal + camRight[1] * cNdcX + camUp[1] * cNdcY,
+				fwd[2] * focal + camRight[2] * cNdcX + camUp[2] * cNdcY
+			]);
+			const cRayDownZ = Math.max(-rd[2], .001);
+			const cT0 = camPos[2] / cRayDownZ;
+			const cWX0 = camPos[0] + rd[0] * cT0;
+			const cWY0 = camPos[1] + rd[1] * cT0;
+			const cursorWorldUVx = cWX0 * .5 + .5;
+			const cursorWorldUVy = cWY0 * .5 + .5;
+			const lc = getCpuValue("lightColor");
+			paramsU.write({
+				amp: getCpuValue("amplitude") ?? .3,
+				freq: getCpuValue("frequency") ?? 1.5,
+				seed: getCpuValue("seed") ?? 0,
+				edgePin: getCpuValue("edgePinning") ?? 0,
+				cursorIntensity: getCpuValue("cursorIntensity") ?? 1,
+				t: animT,
+				aspect,
+				focal,
+				camPos: d.vec3f(camPos[0], camPos[1], camPos[2]),
+				camForward: d.vec3f(fwd[0], fwd[1], fwd[2]),
+				camRight: d.vec3f(camRight[0], camRight[1], camRight[2]),
+				camUp: d.vec3f(camUp[0], camUp[1], camUp[2]),
+				lighting: (getCpuValue("lighting") ?? 30) * .035,
+				glossiness: (getCpuValue("glossiness") ?? 0) * .01,
+				highlights: (getCpuValue("highlights") ?? 15) * .04,
+				lightX: getCpuValue("lightX") ?? .4,
+				lightY: getCpuValue("lightY") ?? -.6,
+				lightZ: getCpuValue("lightZ") ?? .7,
+				lightColor: d.vec3f(lc?.x ?? 1, lc?.y ?? 1, lc?.z ?? 1),
+				nearCutoff: getCpuValue("nearCutoff") ?? 0,
+				farCutoff: getCpuValue("farCutoff") ?? 1,
+				cursorWaveX: (cursorWorldUVx - .5) / WAVE_HALFEXTENT + .5,
+				cursorWaveY: (cursorWorldUVy - .5) / WAVE_HALFEXTENT + .5,
+				mouseSpeed,
+				dt: .016,
+				decay: 10,
+				radius: .025,
+				waveSpeed: getCpuValue("cursorSpeed") ?? .5
+			});
+		};
+		return {
+			outputs: {
+				uvMaskMap,
+				litMap
+			},
+			getComputeNodes: (frameParams) => {
+				const fp = frameParams;
+				const now = Date.now();
+				const dt = Math.min(fp.deltaTime ?? (now - lastTime) / 1e3, .016);
+				lastTime = now;
+				const px = fp.pointer?.x ?? prevPx;
+				const py = fp.pointer?.y ?? prevPy;
+				const rawVelX = dt > 0 ? (px - prevPx) / dt : 0;
+				const rawVelY = dt > 0 ? (py - prevPy) / dt : 0;
+				const mouseSpeed = Math.min(Math.sqrt(rawVelX * rawVelX + rawVelY * rawVelY), 2);
+				prevPx = px;
+				prevPy = py;
+				if (mouseSpeed > .01) lastActiveTime = now;
+				animT += dt * (getCpuValue("speed") ?? .5);
+				writeParams(fp, mouseSpeed);
+				if (!cursorEnabled || !propagatePass) return [computePass];
+				const dampFactor = 1 - 10 * .004;
+				const settleTime = dampFactor >= 1 ? Infinity : Math.min(3e4, Math.log(1e-6) / Math.log(Math.max(dampFactor, .001)) * 16.67);
+				if (now - lastActiveTime > settleTime && mouseSpeed < .01) return [computePass];
+				const prop = direction === 0 ? propagatePass.with(propBgAB) : propagatePass.with(propBgBA);
+				direction = 1 - direction;
+				return [prop, computePass];
+			}
+		};
+	},
+	fragment: (params) => {
+		const { childNode, ctx, computeOutputs, convertToTexture } = params;
+		if (!childNode) return ZERO;
+		const uvMaskTex = computeOutputs?.uvMaskMap;
+		const litTex = computeOutputs?.litMap;
+		if (!uvMaskTex || !litTex) return ZERO;
+		const uvMaskSample = uvMaskTex.sample(ctx.uv, "linearClamp");
+		const litSample = litTex.sample(ctx.uv, "linearClamp");
+		const lookedUpUV = vec4(uvMaskSample.member("r"), uvMaskSample.member("g"), 0, 0).member("xy");
+		const mask = uvMaskSample.member("b");
+		const lit = litSample.member("rgb");
+		return call(unpremultiplyAlpha, "unpremultiplyAlpha", [call(surface3dCompose, "surface3dCompose", [
+			params.uvPropagationActive ? childNode : convertToTexture(childNode).sample(lookedUpUV),
+			lit,
+			mask
+		])]);
+	}
+};
+function cross3(a, b) {
+	return [
+		a[1] * b[2] - a[2] * b[1],
+		a[2] * b[0] - a[0] * b[2],
+		a[0] * b[1] - a[1] * b[0]
+	];
+}
+function norm3(a) {
+	const l = Math.max(1e-6, Math.hypot(a[0], a[1], a[2]));
+	return [
+		a[0] / l,
+		a[1] / l,
+		a[2] / l
+	];
+}
+var Surface3D_default = componentDefinition;
+export { surface3dCompose as a, makePropagateKernel as i, componentDefinition as n, makeComputeKernel as r, Surface3D_default as t };