shaders 3.0.448 → 3.0.450

package/dist/core/{Surface3D-TsGPzdGm.js → Surface3D-CW2ApEgt.js}

@@ -1,71 +1,86 @@
-import { Bt as ZERO, Ft as edgeWrapUV, Ht as call, It as edges_exports, J as std, Jt as vec4, Nt as edgeMirrorUV, Tn as d, X as createGuardedCompute, Z as createStateBuffer, cn as unpremultiplyAlpha, n as tgpu, pt as noise_exports, ut as mxNoiseFloat2 } from "./coords-BkIjixe_.js";
-import { a as transformColor, s as transformEdges } from "./transformations-t0d2-uSX.js";
+import { At as mix, Ct as exp, Gt as arrayOf, Mt as pow, N as unpremultiplyAlpha, Ot as max, Qt as struct, Rt as sin, St as dot, Tt as floor, Ut as data_exports, bt as cos, d as ZERO, et as src_default, ht as abs, i as edgeMirrorUV, in as vec3f, jt as normalize, kt as min, ln as u32, mt as select, nt as std_exports, o as edgeWrapUV, on as vec4f, ot as textureStore, p as call, qt as textureStorage2d, rn as vec2u, s as edges_exports, sn as f32, tn as vec2f, wt as exp2, y as vec4, yt as clamp, zt as smoothstep } from "./edges-BZUKQxSE.js";
+import { p as noise_exports, u as mxNoiseFloat2 } from "./noise-Cq0KUOSC.js";
+import { n as createGuardedCompute, r as createStateBuffer } from "./compute-BoeIXi0l.js";
+import { t as isMobileGpuViewport } from "./device-BODv_4aH.js";
+import { a as transformColor, s as transformEdges } from "./transformations-CsPUHppB.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 COMPUTE_MAX = isMobileGpuViewport() ? 960 : 1600;
+var COMPUTE_FALLBACK_W = 1600;
+var COMPUTE_FALLBACK_H = 900;
+var MARCH_STEPS = isMobileGpuViewport() ? 12 : 16;
+var MARCH_REFINE = 6;
+var MARCH_FAR = 15;
+var HEIGHT_SLAB_PAD = .02;
+var CURSOR_WAVE_BOUND = 6;
+var WAVE_DECAY = 10;
+var WAVE_DECAY_PER_STEP = .004;
+var WAVE_DAMP = 1 - WAVE_DECAY * WAVE_DECAY_PER_STEP;
+var WAVE_SETTLE_MS = WAVE_DAMP >= 1 ? Infinity : Math.min(3e4, Math.log(1e-6) / Math.log(Math.max(WAVE_DAMP, .001)) * 16.67);
 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
+var S3Params = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+	amp: f32,
+	freq: f32,
+	seed: f32,
+	edgePin: f32,
+	cursorIntensity: f32,
+	t: f32,
+	aspect: f32,
+	focal: f32,
+	camPos: vec3f,
+	camForward: vec3f,
+	camRight: vec3f,
+	camUp: vec3f,
+	lighting: f32,
+	glossiness: f32,
+	highlights: f32,
+	lightX: f32,
+	lightY: f32,
+	lightZ: f32,
+	lightColor: vec3f,
+	nearCutoff: f32,
+	farCutoff: f32,
+	cursorWaveX: f32,
+	cursorWaveY: f32,
+	mouseSpeed: f32,
+	dt: f32,
+	decay: f32,
+	radius: f32,
+	waveSpeed: f32,
+	heightEnvelope: f32,
+	cursorActive: f32
 }), "S3Params");
-var propagateLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+var propagateLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
 	readSrc: {
-		storage: d.arrayOf(d.f32, WAVE_CELLS),
+		storage: arrayOf(f32, WAVE_CELLS),
 		access: "readonly"
 	},
 	writeBuf: {
-		storage: d.arrayOf(d.f32, WAVE_CELLS),
+		storage: arrayOf(f32, WAVE_CELLS),
 		access: "mutable"
 	},
 	readBuf: {
-		storage: d.arrayOf(d.f32, WAVE_CELLS),
+		storage: arrayOf(f32, WAVE_CELLS),
 		access: "mutable"
 	},
 	params: { uniform: S3Params }
 }), "propagateLayout");
-var computeLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+var computeLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
 	readBuf: {
-		storage: d.arrayOf(d.f32, WAVE_CELLS),
+		storage: arrayOf(f32, WAVE_CELLS),
 		access: "readonly"
 	},
 	params: { uniform: S3Params },
-	uvMaskTex: { storageTexture: d.textureStorage2d(STATE_FORMAT, "write-only") },
-	litTex: { storageTexture: d.textureStorage2d(STATE_FORMAT, "write-only") }
+	uvMaskTex: { storageTexture: textureStorage2d(STATE_FORMAT, "write-only") },
+	litTex: { storageTexture: 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) => {
+	return src_default.fn([vec2f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv) => {
 		"use gpu";
 		const p = computeLayout.$.params;
 		const u = uv.x;
@@ -73,77 +88,80 @@ function buildHeightFn(waveType, octaveCount, cursorEnabled) {
 		const amp = p.amp;
 		const freq = p.freq;
 		const seedU = p.seed;
-		let waveVal = d.f32(0);
+		let waveVal = f32(0);
 		if (waveType === 1) {
-			let accSin = d.f32(0);
+			let accSin = 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 iF = f32(i);
+				const scale = exp2(iF);
+				const weight = exp2(__tsover_mul(iF, -1));
+				const cu$1 = cos(__tsover_mul(iF, 1.111));
+				const su = 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));
+				accSin = __tsover_add(accSin, __tsover_mul(sin(phase), weight));
 			}
 			waveVal = __tsover_mul(accSin, invTotalWeight);
 		} else if (waveType === 2) {
-			let accR = d.f32(0);
+			let accR = 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)));
+				const iF = f32(i);
+				const scale = exp2(iF);
+				const weight = exp2(__tsover_mul(iF, -1));
+				const driftX = cos(__tsover_mul(iF, 2.39996));
+				const driftY = sin(__tsover_mul(iF, 2.39996));
+				const coord = 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);
+			waveVal = __tsover_sub(__tsover_mul(__tsover_sub(1, 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 wx = mxNoiseFloat2(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(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);
+			let accW = 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)));
+				const iF = f32(i);
+				const scale = exp2(iF);
+				const weight = exp2(__tsover_mul(iF, -1));
+				const driftX = cos(__tsover_mul(iF, 2.39996));
+				const driftY = sin(__tsover_mul(iF, 2.39996));
+				const coord = 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 pinFalloff = smoothstep(.6, 1, max(abs(cu), abs(cv)));
+		const pinMask = mix(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)));
+			let ripple = f32(0);
+			if (p.cursorActive > .5) {
+				const H = 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 = f32(WAVE_MAX);
+				const gx = __tsover_mul(clamp(waveU, 0, 1), Nm1);
+				const gy = __tsover_mul(clamp(waveV, 0, 1), Nm1);
+				const ix = u32(clamp(gx, 0, Nm1));
+				const iy = u32(clamp(gy, 0, Nm1));
+				const ix1 = min(__tsover_add(ix, u32(1)), u32(WAVE_MAX));
+				const iy1 = min(__tsover_add(iy, u32(1)), u32(WAVE_MAX));
+				const fx = __tsover_sub(gx, floor(gx));
+				const fy = __tsover_sub(gy, floor(gy));
+				const W = 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 = mix(mix(v00, v10, fx), mix(v01, v11, fx), fy);
+				ripple = __tsover_mul(waveSample, __tsover_mul(p.cursorIntensity, .05));
+			}
+			return __tsover_add(baseHeight, ripple);
 		} else return baseHeight;
 	}), {
 		v: 1,
@@ -1287,8 +1305,8 @@ function buildHeightFn(waveType, octaveCount, cursorEnabled) {
 					"cursorEnabled",
 					[0, [
 						[
-							13,
-							"H",
+							12,
+							"ripple",
 							[
 								6,
 								[
@@ -1296,178 +1314,143 @@ function buildHeightFn(waveType, octaveCount, cursorEnabled) {
 									"d",
 									"f32"
 								],
-								["WAVE_HALFEXTENT"]
+								[[5, "0"]]
 							]
 						],
 						[
-							13,
-							"waveU",
+							11,
 							[
 								1,
 								[
-									1,
+									7,
+									"p",
+									"cursorActive"
+								],
+								">",
+								[5, "0.5"]
+							],
+							[0, [
+								[
+									13,
+									"H",
 									[
-										1,
+										6,
 										[
 											7,
-											"uv",
-											"x"
+											"d",
+											"f32"
 										],
-										"-",
-										[5, "0.5"]
-									],
-									"/",
-									"H"
+										["WAVE_HALFEXTENT"]
+									]
 								],
-								"+",
-								[5, "0.5"]
-							]
-						],
-						[
-							13,
-							"waveV",
-							[
-								1,
 								[
-									1,
+									13,
+									"waveU",
 									[
 										1,
 										[
-											7,
-											"uv",
-											"y"
+											1,
+											[
+												1,
+												[
+													7,
+													"uv",
+													"x"
+												],
+												"-",
+												[5, "0.5"]
+											],
+											"/",
+											"H"
 										],
-										"-",
+										"+",
 										[5, "0.5"]
-									],
-									"/",
-									"H"
-								],
-								"+",
-								[5, "0.5"]
-							]
-						],
-						[
-							13,
-							"Nm1",
-							[
-								6,
-								[
-									7,
-									"d",
-									"f32"
+									]
 								],
-								["WAVE_MAX"]
-							]
-						],
-						[
-							13,
-							"gx",
-							[
-								1,
 								[
-									6,
-									[
-										7,
-										"std",
-										"clamp"
-									],
+									13,
+									"waveV",
 									[
-										"waveU",
-										[5, "0"],
-										[5, "1"]
+										1,
+										[
+											1,
+											[
+												1,
+												[
+													7,
+													"uv",
+													"y"
+												],
+												"-",
+												[5, "0.5"]
+											],
+											"/",
+											"H"
+										],
+										"+",
+										[5, "0.5"]
 									]
 								],
-								"*",
-								"Nm1"
-							]
-						],
-						[
-							13,
-							"gy",
-							[
-								1,
 								[
-									6,
-									[
-										7,
-										"std",
-										"clamp"
-									],
+									13,
+									"Nm1",
 									[
-										"waveV",
-										[5, "0"],
-										[5, "1"]
+										6,
+										[
+											7,
+											"d",
+											"f32"
+										],
+										["WAVE_MAX"]
 									]
 								],
-								"*",
-								"Nm1"
-							]
-						],
-						[
-							13,
-							"ix",
-							[
-								6,
 								[
-									7,
-									"d",
-									"u32"
-								],
-								[[
-									6,
-									[
-										7,
-										"std",
-										"clamp"
-									],
+									13,
+									"gx",
 									[
-										"gx",
-										[5, "0"],
+										1,
+										[
+											6,
+											[
+												7,
+												"std",
+												"clamp"
+											],
+											[
+												"waveU",
+												[5, "0"],
+												[5, "1"]
+											]
+										],
+										"*",
 										"Nm1"
 									]
-								]]
-							]
-						],
-						[
-							13,
-							"iy",
-							[
-								6,
-								[
-									7,
-									"d",
-									"u32"
 								],
-								[[
-									6,
-									[
-										7,
-										"std",
-										"clamp"
-									],
+								[
+									13,
+									"gy",
 									[
-										"gy",
-										[5, "0"],
+										1,
+										[
+											6,
+											[
+												7,
+												"std",
+												"clamp"
+											],
+											[
+												"waveV",
+												[5, "0"],
+												[5, "1"]
+											]
+										],
+										"*",
 										"Nm1"
 									]
-								]]
-							]
-						],
-						[
-							13,
-							"ix1",
-							[
-								6,
-								[
-									7,
-									"std",
-									"min"
 								],
-								[[
-									1,
+								[
+									13,
 									"ix",
-									"+",
 									[
 										6,
 										[
@@ -1475,33 +1458,24 @@ function buildHeightFn(waveType, octaveCount, cursorEnabled) {
 											"d",
 											"u32"
 										],
-										[[5, "1"]]
+										[[
+											6,
+											[
+												7,
+												"std",
+												"clamp"
+											],
+											[
+												"gx",
+												[5, "0"],
+												"Nm1"
+											]
+										]]
 									]
-								], [
-									6,
-									[
-										7,
-										"d",
-										"u32"
-									],
-									["WAVE_MAX"]
-								]]
-							]
-						],
-						[
-							13,
-							"iy1",
-							[
-								6,
-								[
-									7,
-									"std",
-									"min"
 								],
-								[[
-									1,
+								[
+									13,
 									"iy",
-									"+",
 									[
 										6,
 										[
@@ -1509,200 +1483,249 @@ function buildHeightFn(waveType, octaveCount, cursorEnabled) {
 											"d",
 											"u32"
 										],
-										[[5, "1"]]
+										[[
+											6,
+											[
+												7,
+												"std",
+												"clamp"
+											],
+											[
+												"gy",
+												[5, "0"],
+												"Nm1"
+											]
+										]]
 									]
-								], [
-									6,
-									[
-										7,
-										"d",
-										"u32"
-									],
-									["WAVE_MAX"]
-								]]
-							]
-						],
-						[
-							13,
-							"fx",
-							[
-								1,
-								"gx",
-								"-",
+								],
 								[
-									6,
+									13,
+									"ix1",
 									[
-										7,
-										"std",
-										"floor"
-									],
-									["gx"]
-								]
-							]
-						],
-						[
-							13,
-							"fy",
-							[
-								1,
-								"gy",
-								"-",
-								[
-									6,
-									[
-										7,
-										"std",
-										"floor"
-									],
-									["gy"]
-								]
-							]
-						],
-						[
-							13,
-							"W",
-							[
-								6,
-								[
-									7,
-									"d",
-									"u32"
+										6,
+										[
+											7,
+											"std",
+											"min"
+										],
+										[[
+											1,
+											"ix",
+											"+",
+											[
+												6,
+												[
+													7,
+													"d",
+													"u32"
+												],
+												[[5, "1"]]
+											]
+										], [
+											6,
+											[
+												7,
+												"d",
+												"u32"
+											],
+											["WAVE_MAX"]
+										]]
+									]
 								],
-								["WAVE_GRID"]
-							]
-						],
-						[
-							13,
-							"v00",
-							[
-								8,
 								[
-									7,
+									13,
+									"iy1",
 									[
-										7,
-										"computeLayout",
-										"$"
-									],
-									"readBuf"
+										6,
+										[
+											7,
+											"std",
+											"min"
+										],
+										[[
+											1,
+											"iy",
+											"+",
+											[
+												6,
+												[
+													7,
+													"d",
+													"u32"
+												],
+												[[5, "1"]]
+											]
+										], [
+											6,
+											[
+												7,
+												"d",
+												"u32"
+											],
+											["WAVE_MAX"]
+										]]
+									]
 								],
 								[
-									1,
+									13,
+									"fx",
 									[
 										1,
-										"iy",
-										"*",
-										"W"
-									],
-									"+",
-									"ix"
-								]
-							]
-						],
-						[
-							13,
-							"v10",
-							[
-								8,
-								[
-									7,
-									[
-										7,
-										"computeLayout",
-										"$"
-									],
-									"readBuf"
+										"gx",
+										"-",
+										[
+											6,
+											[
+												7,
+												"std",
+												"floor"
+											],
+											["gx"]
+										]
+									]
 								],
 								[
-									1,
+									13,
+									"fy",
 									[
 										1,
-										"iy",
-										"*",
-										"W"
-									],
-									"+",
-									"ix1"
-								]
-							]
-						],
-						[
-							13,
-							"v01",
-							[
-								8,
+										"gy",
+										"-",
+										[
+											6,
+											[
+												7,
+												"std",
+												"floor"
+											],
+											["gy"]
+										]
+									]
+								],
 								[
-									7,
+									13,
+									"W",
 									[
-										7,
-										"computeLayout",
-										"$"
-									],
-									"readBuf"
+										6,
+										[
+											7,
+											"d",
+											"u32"
+										],
+										["WAVE_GRID"]
+									]
 								],
 								[
-									1,
+									13,
+									"v00",
 									[
-										1,
-										"iy1",
-										"*",
-										"W"
-									],
-									"+",
-									"ix"
-								]
-							]
-						],
-						[
-							13,
-							"v11",
-							[
-								8,
+										8,
+										[
+											7,
+											[
+												7,
+												"computeLayout",
+												"$"
+											],
+											"readBuf"
+										],
+										[
+											1,
+											[
+												1,
+												"iy",
+												"*",
+												"W"
+											],
+											"+",
+											"ix"
+										]
+									]
+								],
 								[
-									7,
+									13,
+									"v10",
 									[
-										7,
-										"computeLayout",
-										"$"
-									],
-									"readBuf"
+										8,
+										[
+											7,
+											[
+												7,
+												"computeLayout",
+												"$"
+											],
+											"readBuf"
+										],
+										[
+											1,
+											[
+												1,
+												"iy",
+												"*",
+												"W"
+											],
+											"+",
+											"ix1"
+										]
+									]
 								],
 								[
-									1,
+									13,
+									"v01",
 									[
-										1,
-										"iy1",
-										"*",
-										"W"
-									],
-									"+",
-									"ix1"
-								]
-							]
-						],
-						[
-							13,
-							"waveSample",
-							[
-								6,
-								[
-									7,
-									"std",
-									"mix"
+										8,
+										[
+											7,
+											[
+												7,
+												"computeLayout",
+												"$"
+											],
+											"readBuf"
+										],
+										[
+											1,
+											[
+												1,
+												"iy1",
+												"*",
+												"W"
+											],
+											"+",
+											"ix"
+										]
+									]
 								],
 								[
+									13,
+									"v11",
 									[
-										6,
+										8,
 										[
 											7,
-											"std",
-											"mix"
+											[
+												7,
+												"computeLayout",
+												"$"
+											],
+											"readBuf"
 										],
 										[
-											"v00",
-											"v10",
-											"fx"
+											1,
+											[
+												1,
+												"iy1",
+												"*",
+												"W"
+											],
+											"+",
+											"ix1"
 										]
-									],
+									]
+								],
+								[
+									13,
+									"waveSample",
 									[
 										6,
 										[
@@ -1711,34 +1734,63 @@ function buildHeightFn(waveType, octaveCount, cursorEnabled) {
 											"mix"
 										],
 										[
-											"v01",
-											"v11",
-											"fx"
+											[
+												6,
+												[
+													7,
+													"std",
+													"mix"
+												],
+												[
+													"v00",
+													"v10",
+													"fx"
+												]
+											],
+											[
+												6,
+												[
+													7,
+													"std",
+													"mix"
+												],
+												[
+													"v01",
+													"v11",
+													"fx"
+												]
+											],
+											"fy"
 										]
-									],
-									"fy"
-								]
-							]
-						],
+									]
+								],
+								[
+									2,
+									"ripple",
+									"=",
+									[
+										1,
+										"waveSample",
+										"*",
+										[
+											1,
+											[
+												7,
+												"p",
+												"cursorIntensity"
+											],
+											"*",
+											[5, "0.05"]
+										]
+									]
+								]
+							]]
+						],
 						[10, [
 							1,
 							"baseHeight",
 							"+",
-							[
-								1,
-								"waveSample",
-								"*",
-								[
-									1,
-									[
-										7,
-										"p",
-										"cursorIntensity"
-									],
-									"*",
-									[5, "0.05"]
-								]
-							]
+							"ripple"
 						]]
 					]],
 					[0, [[10, "baseHeight"]]]
@@ -1761,10 +1813,10 @@ function buildHeightFn(waveType, octaveCount, cursorEnabled) {
 		},
 		externals: () => ({
 			computeLayout,
-			d,
+			d: data_exports,
 			waveType,
 			octaveCount,
-			std,
+			std: std_exports,
 			TWO_PI,
 			invTotalWeight,
 			noise: noise_exports,
@@ -1776,33 +1828,35 @@ function buildHeightFn(waveType, octaveCount, cursorEnabled) {
 	}) && $.f)({})).$name("surface3dHeight");
 }
 function makePropagateKernel() {
-	return tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+	return src_default.fn([u32, 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)) {
+		if (cx > u32(0) && cx < u32(WAVE_MAX) && cy > u32(0) && cy < u32(WAVE_MAX)) {
 			const p = propagateLayout.$.params;
-			const gs = d.u32(WAVE_GRID);
+			const gs = 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 left = propagateLayout.$.readSrc[__tsover_sub(idx, u32(1))];
+			const right = propagateLayout.$.readSrc[__tsover_add(idx, 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 dampFactor = __tsover_sub(1, __tsover_mul(p.decay, WAVE_DECAY_PER_STEP));
 			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 cellU = __tsover_div(__tsover_add(f32(cx), .5), f32(WAVE_GRID));
+			const cellV = __tsover_div(__tsover_add(f32(cy), .5), 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));
+				const influence = exp(__tsover_mul(__tsover_div(distSq, max(__tsover_mul(p.radius, p.radius), f32(1e-4))), -1));
 				next = __tsover_sub(next, __tsover_mul(__tsover_mul(__tsover_mul(influence, p.mouseSpeed), p.dt), 3));
 			}
+			const bound = f32(CURSOR_WAVE_BOUND);
+			next = clamp(next, __tsover_mul(bound, -1), bound);
 			propagateLayout.$.writeBuf[idx] = next;
 			propagateLayout.$.readBuf[idx] = next;
 		}
@@ -2102,7 +2156,7 @@ function makePropagateKernel() {
 									"decay"
 								],
 								"*",
-								[5, "0.004"]
+								"WAVE_DECAY_PER_STEP"
 							]
 						]
 					],
@@ -2415,6 +2469,46 @@ function makePropagateKernel() {
 							]
 						]]]
 					],
+					[
+						13,
+						"bound",
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							["CURSOR_WAVE_BOUND"]
+						]
+					],
+					[
+						2,
+						"next",
+						"=",
+						[
+							6,
+							[
+								7,
+								"std",
+								"clamp"
+							],
+							[
+								"next",
+								[
+									1,
+									"bound",
+									"*",
+									[
+										4,
+										"-",
+										[5, "1"]
+									]
+								],
+								"bound"
+							]
+						]
+					],
 					[
 						2,
 						[
@@ -2458,101 +2552,114 @@ function makePropagateKernel() {
 				"WAVE_MAX",
 				"propagateLayout",
 				"WAVE_GRID",
-				"std"
+				"WAVE_DECAY_PER_STEP",
+				"std",
+				"CURSOR_WAVE_BOUND"
 			]
 		},
 		externals: () => ({
-			d,
+			d: data_exports,
 			WAVE_MAX,
 			propagateLayout,
 			WAVE_GRID,
-			std
+			WAVE_DECAY_PER_STEP,
+			std: std_exports,
+			CURSOR_WAVE_BOUND
 		})
 	}) && $.f)({})).$name("surface3dPropagate");
 }
-function makeComputeKernel(waveType, octaveCount, edgeMode, lightingEnabled, cursorEnabled) {
+function makeComputeKernel(waveType, octaveCount, edgeMode, lightingEnabled, cursorEnabled, computeW = COMPUTE_FALLBACK_W, computeH = COMPUTE_FALLBACK_H) {
 	const heightFn = buildHeightFn(waveType, octaveCount, cursorEnabled);
-	return tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+	return src_default.fn([u32, 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 screenU = __tsover_div(__tsover_add(f32(cx), .5), f32(computeW));
+		const screenV = __tsover_div(__tsover_add(f32(cy), .5), f32(computeH));
 		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;
+		const rayDir = normalize(p.camForward.mul(p.focal).add(p.camRight.mul(ndcX)).add(p.camUp.mul(ndcY)));
+		const envelope = p.heightEnvelope;
+		const dzSign = select(f32(-1), f32(1), rayDir.z >= 0);
+		const dzSafe = __tsover_mul(dzSign, max(abs(rayDir.z), f32(1e-6)));
+		const tTop = __tsover_div(__tsover_sub(envelope, p.camPos.z), dzSafe);
+		const tBot = __tsover_div(__tsover_sub(__tsover_mul(envelope, -1), p.camPos.z), dzSafe);
+		const tEnter = max(min(tTop, tBot), f32(0));
+		const tExit = min(max(tTop, tBot), f32(MARCH_FAR));
+		const farPos = p.camPos.add(rayDir.mul(f32(MARCH_FAR)));
+		let hit = f32(0);
+		let finalT = f32(MARCH_FAR);
+		let hitU = __tsover_add(__tsover_mul(farPos.x, .5), .5);
+		let hitV = __tsover_add(__tsover_mul(farPos.y, .5), .5);
+		let lit = vec3f(1, 1, 1);
+		if (tExit > tEnter) {
+			const stepSize = __tsover_div(__tsover_sub(tExit, tEnter), f32(MARCH_STEPS));
+			let tMarch = tEnter;
+			const pStart = p.camPos.add(rayDir.mul(tEnter));
+			let prevDiff = __tsover_sub(pStart.z, heightFn(vec2f(__tsover_add(__tsover_mul(pStart.x, .5), .5), __tsover_add(__tsover_mul(pStart.y, .5), .5))));
+			for (let s = 0; s < MARCH_STEPS; s++) {
+				tMarch = __tsover_add(tMarch, stepSize);
+				const pos = p.camPos.add(rayDir.mul(tMarch));
+				const h = heightFn(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;
+			}
+			if (hit > .5) {
+				let tLow = __tsover_sub(tMarch, stepSize);
+				let tHigh = tMarch;
+				for (let r = 0; r < MARCH_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(vec2f(__tsover_add(__tsover_mul(pMid.x, .5), .5), __tsover_add(__tsover_mul(pMid.y, .5), .5)))) > 0) tLow = tMid;
+					else tHigh = tMid;
+				}
+				finalT = __tsover_mul(__tsover_add(tLow, tHigh), .5);
+				const hitPos = p.camPos.add(rayDir.mul(finalT));
+				hitU = __tsover_add(__tsover_mul(hitPos.x, .5), .5);
+				hitV = __tsover_add(__tsover_mul(hitPos.y, .5), .5);
+				if (lightingEnabled) {
+					const normalEps = .01;
+					const hC = heightFn(vec2f(hitU, hitV));
+					const hR = heightFn(vec2f(__tsover_add(hitU, normalEps), hitV));
+					const hUp = heightFn(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 = normalize(vec3f(__tsover_mul(dhdu, -.5), __tsover_mul(dhdv, -.5), 1));
+					const lightDir = normalize(vec3f(p.lightX, p.lightY, p.lightZ));
+					const viewDir = rayDir.mul(-1);
+					const diffuse = clamp(dot(nrm, lightDir), 0, 1);
+					const halfVec = normalize(lightDir.add(viewDir));
+					const specPow = __tsover_add(__tsover_mul(p.glossiness, 128), 4);
+					const specular = __tsover_mul(pow(clamp(dot(nrm, halfVec), 0, 1), specPow), p.highlights);
+					const ambient = 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 = clamp(mix(vec3f(1, 1, 1), totalLight, p.lighting), vec3f(0, 0, 0), vec3f(3, 3, 3));
+				}
 			}
-			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);
+		const rawSampleUV = vec2f(hitU, __tsover_sub(1, hitV));
+		let finalUV = vec2f(rawSampleUV.x, rawSampleUV.y);
+		let outOfBoundsMask = 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);
+			outOfBoundsMask = select(f32(0), f32(1), inside);
+		} else finalUV = clamp(rawSampleUV, vec2f(0, 0), vec2f(1, 1));
+		const CUTOFF_RANGE = f32(MARCH_FAR);
 		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 nearMask = smoothstep(__tsover_sub(nearT, edgeAA), __tsover_add(nearT, edgeAA), finalT);
+		const farMask = 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));
+		textureStore(computeLayout.$.uvMaskTex, vec2u(cx, cy), vec4f(finalUV.x, finalUV.y, finalMask, 0));
+		textureStore(computeLayout.$.litTex, vec2u(cx, cy), vec4f(lit, 0));
 	}), {
 		v: 1,
 		name: void 0,
@@ -2605,7 +2712,7 @@ function makeComputeKernel(waveType, octaveCount, edgeMode, lightingEnabled, cur
 								"d",
 								"f32"
 							],
-							["COMPUTE_W"]
+							["computeW"]
 						]
 					]
 				],
@@ -2636,7 +2743,7 @@ function makeComputeKernel(waveType, octaveCount, edgeMode, lightingEnabled, cur
 								"d",
 								"f32"
 							],
-							["COMPUTE_H"]
+							["computeH"]
 						]
 					]
 				],
@@ -2759,113 +2866,241 @@ function makeComputeKernel(waveType, octaveCount, edgeMode, lightingEnabled, cur
 				],
 				[
 					13,
-					"STEPS",
-					[5, "32"]
-				],
-				[
-					13,
-					"REFINE",
-					[5, "6"]
+					"envelope",
+					[
+						7,
+						"p",
+						"heightEnvelope"
+					]
 				],
 				[
 					13,
-					"rayDownComp",
+					"dzSign",
 					[
 						6,
 						[
 							7,
 							"std",
-							"max"
+							"select"
 						],
-						[[
-							1,
+						[
 							[
-								7,
-								"rayDir",
-								"z"
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[
+									4,
+									"-",
+									[5, "1"]
+								]]
 							],
-							"*",
 							[
-								4,
-								"-",
-								[5, "1"]
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[5, "1"]]
+							],
+							[
+								1,
+								[
+									7,
+									"rayDir",
+									"z"
+								],
+								">=",
+								[5, "0"]
 							]
-						], [
+						]
+					]
+				],
+				[
+					13,
+					"dzSafe",
+					[
+						1,
+						"dzSign",
+						"*",
+						[
 							6,
 							[
 								7,
-								"d",
-								"f32"
+								"std",
+								"max"
 							],
-							[[5, "0.05"]]
-						]]
+							[[
+								6,
+								[
+									7,
+									"std",
+									"abs"
+								],
+								[[
+									7,
+									"rayDir",
+									"z"
+								]]
+							], [
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[5, "0.000001"]]
+							]]
+						]
 					]
 				],
 				[
 					13,
-					"tToBase",
+					"tTop",
 					[
 						1,
 						[
-							7,
+							1,
+							"envelope",
+							"-",
 							[
 								7,
-								"p",
-								"camPos"
+								[
+									7,
+									"p",
+									"camPos"
+								],
+								"z"
+							]
+						],
+						"/",
+						"dzSafe"
+					]
+				],
+				[
+					13,
+					"tBot",
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								"envelope",
+								"*",
+								[
+									4,
+									"-",
+									[5, "1"]
+								]
 							],
-							"z"
+							"-",
+							[
+								7,
+								[
+									7,
+									"p",
+									"camPos"
+								],
+								"z"
+							]
 						],
 						"/",
-						"rayDownComp"
+						"dzSafe"
 					]
 				],
 				[
 					13,
-					"marchTotal",
+					"tEnter",
 					[
 						6,
 						[
 							7,
 							"std",
-							"min"
+							"max"
 						],
 						[[
-							1,
-							"tToBase",
-							"+",
-							[5, "1.5"]
-						], [5, "15"]]
+							6,
+							[
+								7,
+								"std",
+								"min"
+							],
+							["tTop", "tBot"]
+						], [
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "0"]]
+						]]
 					]
 				],
 				[
 					13,
-					"stepSize",
+					"tExit",
 					[
-						1,
-						"marchTotal",
-						"/",
+						6,
 						[
+							7,
+							"std",
+							"min"
+						],
+						[[
+							6,
+							[
+								7,
+								"std",
+								"max"
+							],
+							["tTop", "tBot"]
+						], [
 							6,
 							[
 								7,
 								"d",
 								"f32"
 							],
-							["STEPS"]
-						]
+							["MARCH_FAR"]
+						]]
 					]
 				],
 				[
-					12,
-					"tMarch",
+					13,
+					"farPos",
 					[
 						6,
 						[
 							7,
-							"d",
-							"f32"
+							[
+								7,
+								"p",
+								"camPos"
+							],
+							"add"
 						],
-						[[5, "0"]]
+						[[
+							6,
+							[
+								7,
+								"rayDir",
+								"mul"
+							],
+							[[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								["MARCH_FAR"]
+							]]
+						]]
 					]
 				],
 				[
@@ -2882,19 +3117,28 @@ function makeComputeKernel(waveType, octaveCount, edgeMode, lightingEnabled, cur
 					]
 				],
 				[
-					13,
-					"u0",
+					12,
+					"finalT",
 					[
-						1,
+						6,
 						[
-							1,
-							[
+							7,
+							"d",
+							"f32"
+						],
+						["MARCH_FAR"]
+					]
+				],
+				[
+					12,
+					"hitU",
+					[
+						1,
+						[
+							1,
+							[
 								7,
-								[
-									7,
-									"p",
-									"camPos"
-								],
+								"farPos",
 								"x"
 							],
 							"*",
@@ -2905,19 +3149,15 @@ function makeComputeKernel(waveType, octaveCount, edgeMode, lightingEnabled, cur
 					]
 				],
 				[
-					13,
-					"v0",
+					12,
+					"hitV",
 					[
 						1,
 						[
 							1,
 							[
 								7,
-								[
-									7,
-									"p",
-									"camPos"
-								],
+								"farPos",
 								"y"
 							],
 							"*",
@@ -2929,233 +3169,61 @@ function makeComputeKernel(waveType, octaveCount, edgeMode, lightingEnabled, cur
 				],
 				[
 					12,
-					"prevDiff",
+					"lit",
 					[
-						1,
+						6,
 						[
 							7,
-							[
-								7,
-								"p",
-								"camPos"
-							],
-							"z"
+							"d",
+							"vec3f"
 						],
-						"-",
 						[
-							6,
-							"heightFn",
-							[[
-								6,
-								[
-									7,
-									"d",
-									"vec2f"
-								],
-								["u0", "v0"]
-							]]
+							[5, "1"],
+							[5, "1"],
+							[5, "1"]
 						]
 					]
 				],
 				[
-					14,
-					[
-						12,
-						"s",
-						[5, "0"]
-					],
+					11,
 					[
 						1,
-						"s",
-						"<",
-						"STEPS"
-					],
-					[
-						102,
-						"++",
-						"s"
+						"tExit",
+						">",
+						"tEnter"
 					],
 					[0, [
-						[
-							2,
-							"tMarch",
-							"=",
-							[
-								1,
-								"tMarch",
-								"+",
-								"stepSize"
-							]
-						],
 						[
 							13,
-							"pos",
+							"stepSize",
 							[
-								6,
+								1,
 								[
-									7,
-									[
-										7,
-										"p",
-										"camPos"
-									],
-									"add"
+									1,
+									"tExit",
+									"-",
+									"tEnter"
 								],
-								[[
-									6,
-									[
-										7,
-										"rayDir",
-										"mul"
-									],
-									["tMarch"]
-								]]
-							]
-						],
-						[
-							13,
-							"h",
-							[
-								6,
-								"heightFn",
-								[[
+								"/",
+								[
 									6,
 									[
 										7,
 										"d",
-										"vec2f"
+										"f32"
 									],
-									[[
-										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"]
+									["MARCH_STEPS"]
 								]
-							],
-							[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"]
-							]
+							12,
+							"tMarch",
+							"tEnter"
 						],
 						[
 							13,
-							"pMid",
+							"pStart",
 							[
 								6,
 								[
@@ -3174,18 +3242,18 @@ function makeComputeKernel(waveType, octaveCount, edgeMode, lightingEnabled, cur
 										"rayDir",
 										"mul"
 									],
-									["tMid"]
+									["tEnter"]
 								]]
 							]
 						],
 						[
-							13,
-							"dMid",
+							12,
+							"prevDiff",
 							[
 								1,
 								[
 									7,
-									"pMid",
+									"pStart",
 									"z"
 								],
 								"-",
@@ -3205,7 +3273,7 @@ function makeComputeKernel(waveType, octaveCount, edgeMode, lightingEnabled, cur
 												1,
 												[
 													7,
-													"pMid",
+													"pStart",
 													"x"
 												],
 												"*",
@@ -3219,7 +3287,7 @@ function makeComputeKernel(waveType, octaveCount, edgeMode, lightingEnabled, cur
 												1,
 												[
 													7,
-													"pMid",
+													"pStart",
 													"y"
 												],
 												"*",
@@ -3233,805 +3301,1079 @@ function makeComputeKernel(waveType, octaveCount, edgeMode, lightingEnabled, cur
 							]
 						],
 						[
-							11,
+							14,
 							[
-								1,
-								"dMid",
-								">",
+								12,
+								"s",
 								[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"
+								1,
+								"s",
+								"<",
+								"MARCH_STEPS"
 							],
-							"add"
-						],
-						[[
-							6,
 							[
-								7,
-								"rayDir",
-								"mul"
+								102,
+								"++",
+								"s"
 							],
-							["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",
+							[0, [
 								[
-									3,
-									[
-										3,
-										[
-											3,
-											[
-												1,
-												[
-													7,
-													"rawSampleUV",
-													"x"
-												],
-												">=",
-												[5, "0"]
-											],
-											"&&",
-											[
-												1,
-												[
-													7,
-													"rawSampleUV",
-													"x"
-												],
-												"<=",
-												[5, "1"]
-											]
-										],
-										"&&",
-										[
-											1,
-											[
-												7,
-												"rawSampleUV",
-												"y"
-											],
-											">=",
-											[5, "0"]
-										]
-									],
-									"&&",
+									2,
+									"tMarch",
+									"=",
 									[
 										1,
-										[
-											7,
-											"rawSampleUV",
-											"y"
-										],
-										"<=",
-										[5, "1"]
+										"tMarch",
+										"+",
+										"stepSize"
 									]
-								]
-							], [
-								2,
-								"outOfBoundsMask",
-								"=",
+								],
 								[
-									6,
-									[
-										7,
-										"std",
-										"select"
-									],
+									13,
+									"pos",
 									[
+										6,
 										[
-											6,
+											7,
 											[
 												7,
-												"d",
-												"f32"
+												"p",
+												"camPos"
 											],
-											[[5, "0"]]
+											"add"
 										],
-										[
+										[[
 											6,
 											[
 												7,
-												"d",
-												"f32"
+												"rayDir",
+												"mul"
 											],
-											[[5, "1"]]
-										],
-										"inside"
+											["tMarch"]
+										]]
 									]
-								]
-							]]],
-							[0, [[
-								2,
-								"finalUV",
-								"=",
+								],
 								[
-									6,
-									[
-										7,
-										"std",
-										"clamp"
-									],
+									13,
+									"h",
 									[
-										"rawSampleUV",
-										[
-											6,
-											[
-												7,
-												"d",
-												"vec2f"
-											],
-											[[5, "0"], [5, "0"]]
-										],
-										[
+										6,
+										"heightFn",
+										[[
 											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,
+											[[
+												1,
+												[
+													1,
+													[
+														7,
+														"pos",
+														"x"
+													],
+													"*",
+													[5, "0.5"]
+												],
+												"+",
+												[5, "0.5"]
+											], [
+												1,
+												[
+													1,
+													[
+														7,
+														"pos",
+														"y"
+													],
+													"*",
+													[5, "0.5"]
+												],
+												"+",
+												[5, "0.5"]
+											]]
+										]]
+									]
+								],
+								[
+									13,
+									"diff",
 									[
-										7,
-										"d",
-										"vec2f"
+										1,
+										[
+											7,
+											"pos",
+											"z"
+										],
+										"-",
+										"h"
+									]
+								],
+								[
+									11,
+									[
+										3,
+										[
+											1,
+											"diff",
+											"<",
+											[5, "0"]
+										],
+										"&&",
+										[
+											1,
+											"prevDiff",
+											">",
+											[5, "0"]
+										]
 									],
-									["hitU", "hitV"]
-								]]
-							]
+									[0, [[
+										2,
+										"hit",
+										"=",
+										[5, "1"]
+									], [17]]]
+								],
+								[
+									2,
+									"prevDiff",
+									"=",
+									"diff"
+								]
+							]]
 						],
 						[
-							13,
-							"hR",
+							11,
 							[
-								6,
-								"heightFn",
-								[[
-									6,
+								1,
+								"hit",
+								">",
+								[5, "0.5"]
+							],
+							[0, [
+								[
+									12,
+									"tLow",
 									[
-										7,
-										"d",
-										"vec2f"
-									],
-									[[
 										1,
-										"hitU",
-										"+",
-										"normalEps"
-									], "hitV"]
-								]]
-							]
-						],
-						[
-							13,
-							"hUp",
-							[
-								6,
-								"heightFn",
-								[[
-									6,
+										"tMarch",
+										"-",
+										"stepSize"
+									]
+								],
+								[
+									12,
+									"tHigh",
+									"tMarch"
+								],
+								[
+									14,
 									[
-										7,
-										"d",
-										"vec2f"
+										12,
+										"r",
+										[5, "0"]
 									],
-									["hitU", [
+									[
 										1,
-										"hitV",
-										"+",
-										"normalEps"
+										"r",
+										"<",
+										"MARCH_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,
-							"dhdu",
-							[
-								1,
-								[
-									1,
-									"hR",
-									"-",
-									"hC"
 								],
-								"/",
-								"normalEps"
-							]
-						],
-						[
-							13,
-							"dhdv",
-							[
-								1,
 								[
-									1,
-									"hUp",
-									"-",
-									"hC"
+									2,
+									"finalT",
+									"=",
+									[
+										1,
+										[
+											1,
+											"tLow",
+											"+",
+											"tHigh"
+										],
+										"*",
+										[5, "0.5"]
+									]
 								],
-								"/",
-								"normalEps"
-							]
-						],
-						[
-							13,
-							"nrm",
-							[
-								6,
 								[
-									7,
-									"std",
-									"normalize"
+									13,
+									"hitPos",
+									[
+										6,
+										[
+											7,
+											[
+												7,
+												"p",
+												"camPos"
+											],
+											"add"
+										],
+										[[
+											6,
+											[
+												7,
+												"rayDir",
+												"mul"
+											],
+											["finalT"]
+										]]
+									]
 								],
-								[[
-									6,
+								[
+									2,
+									"hitU",
+									"=",
 									[
-										7,
-										"d",
-										"vec3f"
-									],
+										1,
+										[
+											1,
+											[
+												7,
+												"hitPos",
+												"x"
+											],
+											"*",
+											[5, "0.5"]
+										],
+										"+",
+										[5, "0.5"]
+									]
+								],
+								[
+									2,
+									"hitV",
+									"=",
 									[
+										1,
+										[
+											1,
+											[
+												7,
+												"hitPos",
+												"y"
+											],
+											"*",
+											[5, "0.5"]
+										],
+										"+",
+										[5, "0.5"]
+									]
+								],
+								[
+									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"]
+												]]
+											]
+										],
 										[
-											1,
-											"dhdu",
-											"*",
+											13,
+											"specPow",
 											[
-												4,
-												"-",
-												[5, "0.5"]
+												1,
+												[
+													1,
+													[
+														7,
+														"p",
+														"glossiness"
+													],
+													"*",
+													[5, "128"]
+												],
+												"+",
+												[5, "4"]
 											]
 										],
 										[
-											1,
-											"dhdv",
-											"*",
+											13,
+											"specular",
 											[
-												4,
-												"-",
-												[5, "0.5"]
+												1,
+												[
+													6,
+													[
+														7,
+														"std",
+														"pow"
+													],
+													[[
+														6,
+														[
+															7,
+															"std",
+															"clamp"
+														],
+														[
+															[
+																6,
+																[
+																	7,
+																	"std",
+																	"dot"
+																],
+																["nrm", "halfVec"]
+															],
+															[5, "0"],
+															[5, "1"]
+														]
+													], "specPow"]
+												],
+												"*",
+												[
+													7,
+													"p",
+													"highlights"
+												]
 											]
 										],
-										[5, "1"]
-									]
-								]]
-							]
-						],
-						[
-							13,
-							"lightDir",
-							[
-								6,
-								[
-									7,
-									"std",
-									"normalize"
-								],
-								[[
-									6,
-									[
-										7,
-										"d",
-										"vec3f"
-									],
-									[
 										[
-											7,
-											"p",
-											"lightX"
+											13,
+											"ambient",
+											[
+												6,
+												[
+													7,
+													"d",
+													"vec3f"
+												],
+												[
+													[5, "0.4"],
+													[5, "0.4"],
+													[5, "0.4"]
+												]
+											]
 										],
 										[
-											7,
-											"p",
-											"lightY"
+											13,
+											"tintedDiffuse",
+											[
+												6,
+												[
+													7,
+													[
+														7,
+														"p",
+														"lightColor"
+													],
+													"mul"
+												],
+												[[
+													1,
+													"diffuse",
+													"*",
+													[5, "0.6"]
+												]]
+											]
 										],
 										[
-											7,
-											"p",
-											"lightZ"
-										]
-									]
-								]]
-							]
-						],
-						[
-							13,
-							"viewDir",
-							[
-								6,
-								[
-									7,
-									"rayDir",
-									"mul"
-								],
-								[[
-									4,
-									"-",
-									[5, "1"]
-								]]
-							]
-						],
-						[
-							13,
-							"diffuse",
-							[
-								6,
-								[
-									7,
-									"std",
-									"clamp"
-								],
-								[
-									[
-										6,
-										[
-											7,
-											"std",
-											"dot"
+											13,
+											"tintedSpec",
+											[
+												6,
+												[
+													7,
+													[
+														7,
+														"p",
+														"lightColor"
+													],
+													"mul"
+												],
+												["specular"]
+											]
 										],
-										["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"
+											13,
+											"totalLight",
+											[
+												6,
+												[
+													7,
+													[
+														6,
+														[
+															7,
+															"ambient",
+															"add"
+														],
+														["tintedDiffuse"]
+													],
+													"add"
+												],
+												["tintedSpec"]
+											]
 										],
 										[
+											2,
+											"lit",
+											"=",
 											[
 												6,
 												[
 													7,
 													"std",
-													"dot"
+													"clamp"
 												],
-												["nrm", "halfVec"]
-											],
-											[5, "0"],
-											[5, "1"]
+												[
+													[
+														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"]
+														]
+													]
+												]
+											]
 										]
-									], "specPow"]
-								],
-								"*",
-								[
-									7,
-									"p",
-									"highlights"
+									]]
 								]
-							]
-						],
+							]]
+						]
+					]]
+				],
+				[
+					13,
+					"rawSampleUV",
+					[
+						6,
 						[
-							13,
-							"ambient",
-							[
-								6,
-								[
-									7,
-									"d",
-									"vec3f"
-								],
-								[
-									[5, "0.4"],
-									[5, "0.4"],
-									[5, "0.4"]
-								]
-							]
+							7,
+							"d",
+							"vec2f"
 						],
+						["hitU", [
+							1,
+							[5, "1"],
+							"-",
+							"hitV"
+						]]
+					]
+				],
+				[
+					12,
+					"finalUV",
+					[
+						6,
 						[
-							13,
-							"tintedDiffuse",
-							[
-								6,
-								[
-									7,
-									[
-										7,
-										"p",
-										"lightColor"
-									],
-									"mul"
-								],
-								[[
-									1,
-									"diffuse",
-									"*",
-									[5, "0.6"]
-								]]
-							]
+							7,
+							"d",
+							"vec2f"
 						],
+						[[
+							7,
+							"rawSampleUV",
+							"x"
+						], [
+							7,
+							"rawSampleUV",
+							"y"
+						]]
+					]
+				],
+				[
+					12,
+					"outOfBoundsMask",
+					[
+						6,
 						[
-							13,
-							"tintedSpec",
-							[
-								6,
-								[
-									7,
-									[
-										7,
-										"p",
-										"lightColor"
-									],
-									"mul"
-								],
-								["specular"]
-							]
+							7,
+							"d",
+							"f32"
 						],
+						[[5, "1"]]
+					]
+				],
+				[
+					11,
+					[
+						1,
+						"edgeMode",
+						"===",
+						[5, "2"]
+					],
+					[0, [[
+						2,
+						"finalUV",
+						"=",
 						[
-							13,
-							"totalLight",
+							6,
 							[
-								6,
-								[
-									7,
-									[
-										6,
-										[
-											7,
-											"ambient",
-											"add"
-										],
-										["tintedDiffuse"]
-									],
-									"add"
-								],
-								["tintedSpec"]
-							]
-						],
+								7,
+								"edges",
+								"edgeMirrorUV"
+							],
+							["rawSampleUV"]
+						]
+					]]],
+					[
+						11,
 						[
+							1,
+							"edgeMode",
+							"===",
+							[5, "3"]
+						],
+						[0, [[
 							2,
-							"lit",
+							"finalUV",
 							"=",
 							[
 								6,
 								[
 									7,
-									"std",
-									"clamp"
+									"edges",
+									"edgeWrapUV"
 								],
+								["rawSampleUV"]
+							]
+						]]],
+						[
+							11,
+							[
+								1,
+								"edgeMode",
+								"===",
+								[5, "1"]
+							],
+							[0, [[
+								13,
+								"inside",
 								[
+									3,
 									[
-										6,
-										[
-											7,
-											"std",
-											"mix"
-										],
+										3,
 										[
+											3,
 											[
-												6,
+												1,
 												[
 													7,
-													"d",
-													"vec3f"
+													"rawSampleUV",
+													"x"
 												],
-												[
-													[5, "1"],
-													[5, "1"],
-													[5, "1"]
-												]
+												">=",
+												[5, "0"]
 											],
-											"totalLight",
+											"&&",
 											[
-												7,
-												"p",
-												"lighting"
+												1,
+												[
+													7,
+													"rawSampleUV",
+													"x"
+												],
+												"<=",
+												[5, "1"]
 											]
+										],
+										"&&",
+										[
+											1,
+											[
+												7,
+												"rawSampleUV",
+												"y"
+											],
+											">=",
+											[5, "0"]
 										]
 									],
+									"&&",
 									[
-										6,
+										1,
 										[
 											7,
-											"d",
-											"vec3f"
+											"rawSampleUV",
+											"y"
+										],
+										"<=",
+										[5, "1"]
+									]
+								]
+							], [
+								2,
+								"outOfBoundsMask",
+								"=",
+								[
+									6,
+									[
+										7,
+										"std",
+										"select"
+									],
+									[
+										[
+											6,
+											[
+												7,
+												"d",
+												"f32"
+											],
+											[[5, "0"]]
 										],
 										[
-											[5, "0"],
-											[5, "0"],
-											[5, "0"]
-										]
+											6,
+											[
+												7,
+												"d",
+												"f32"
+											],
+											[[5, "1"]]
+										],
+										"inside"
+									]
+								]
+							]]],
+							[0, [[
+								2,
+								"finalUV",
+								"=",
+								[
+									6,
+									[
+										7,
+										"std",
+										"clamp"
 									],
 									[
-										6,
+										"rawSampleUV",
 										[
-											7,
-											"d",
-											"vec3f"
+											6,
+											[
+												7,
+												"d",
+												"vec2f"
+											],
+											[[5, "0"], [5, "0"]]
 										],
 										[
-											[5, "3"],
-											[5, "3"],
-											[5, "3"]
+											6,
+											[
+												7,
+												"d",
+												"vec2f"
+											],
+											[[5, "1"], [5, "1"]]
 										]
 									]
 								]
-							]
+							]]]
 						]
-					]]
+					]
 				],
 				[
 					13,
@@ -4043,7 +4385,7 @@ function makeComputeKernel(waveType, octaveCount, edgeMode, lightingEnabled, cur
 							"d",
 							"f32"
 						],
-						[[5, "15"]]
+						["MARCH_FAR"]
 					]
 				],
 				[
@@ -4244,36 +4586,41 @@ function makeComputeKernel(waveType, octaveCount, edgeMode, lightingEnabled, cur
 			"externalNames": [
 				"computeLayout",
 				"d",
-				"COMPUTE_W",
-				"COMPUTE_H",
+				"computeW",
+				"computeH",
 				"std",
+				"MARCH_FAR",
+				"MARCH_STEPS",
 				"heightFn",
+				"MARCH_REFINE",
+				"lightingEnabled",
 				"edgeMode",
-				"edges",
-				"lightingEnabled"
+				"edges"
 			]
 		},
 		externals: () => ({
 			computeLayout,
-			d,
-			COMPUTE_W,
-			COMPUTE_H,
-			std,
+			d: data_exports,
+			computeW,
+			computeH,
+			std: std_exports,
+			MARCH_FAR,
+			MARCH_STEPS,
 			heightFn,
+			MARCH_REFINE,
+			lightingEnabled,
 			edgeMode,
-			edges: edges_exports,
-			lightingEnabled
+			edges: edges_exports
 		})
 	}) && $.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) => {
+const surface3dCompose = src_default.fn([
+	vec4f,
+	vec3f,
+	f32
+], 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));
+	return vec4f(clamp(childColor.xyz.mul(lit), vec3f(0, 0, 0), vec3f(1, 1, 1)), __tsover_mul(childColor.w, mask));
 }), {
 	v: 1,
 	name: void 0,
@@ -4365,8 +4712,8 @@ const surface3dCompose = tgpu.fn([
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {
@@ -4429,7 +4776,7 @@ const componentDefinition = {
 		},
 		octaves: {
 			default: 2,
-			compileTime: true,
+			compileTimeWhen: (prev, next) => Math.max(1, Math.floor(prev)) !== Math.max(1, Math.floor(next)),
 			description: "Detail octaves",
 			ui: {
 				type: "range",
@@ -4695,12 +5042,21 @@ const componentDefinition = {
 		const edgeMode = getCpuValue("edges") ?? 2;
 		const lightingEnabled = (getCpuValue("lighting") ?? 30) >= .01;
 		const cursorEnabled = (getCpuValue("cursorIntensity") ?? 1) >= .01;
+		const canvasW = Math.round(dimensions.width);
+		const canvasH = Math.round(dimensions.height);
+		let computeW = Math.min(COMPUTE_MAX, COMPUTE_FALLBACK_W);
+		let computeH = Math.min(Math.round(COMPUTE_MAX * COMPUTE_FALLBACK_H / COMPUTE_FALLBACK_W), COMPUTE_FALLBACK_H);
+		if (canvasW >= 16 && canvasH >= 16) {
+			const fit = Math.min(1, COMPUTE_MAX / Math.max(canvasW, canvasH));
+			computeW = Math.max(16, Math.round(canvasW * fit));
+			computeH = Math.max(16, Math.round(canvasH * fit));
+		}
 		const uvMaskTex = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
-			size: [COMPUTE_W, COMPUTE_H],
+			size: [computeW, computeH],
 			format: STATE_FORMAT
 		}).$usage("storage", "sampled"), "uvMaskTex");
 		const litTex = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
-			size: [COMPUTE_W, COMPUTE_H],
+			size: [computeW, computeH],
 			format: STATE_FORMAT
 		}).$usage("storage", "sampled"), "litTex");
 		onCleanup(() => {
@@ -4709,9 +5065,9 @@ const componentDefinition = {
 		});
 		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 bufferA = createStateBuffer(root, f32, WAVE_CELLS);
+		const bufferB = createStateBuffer(root, f32, WAVE_CELLS);
+		const readBuf = createStateBuffer(root, 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));
@@ -4719,7 +5075,7 @@ const componentDefinition = {
 			curW = Math.max(1, Math.round(width));
 			curH = Math.max(1, Math.round(height));
 		});
-		const computeKernel = makeComputeKernel(waveType, octaveCount, edgeMode, lightingEnabled, cursorEnabled);
+		const computeKernel = makeComputeKernel(waveType, octaveCount, edgeMode, lightingEnabled, cursorEnabled, computeW, computeH);
 		const computeBg = root.createBindGroup(computeLayout, {
 			readBuf,
 			params: paramsU.buffer,
@@ -4749,7 +5105,7 @@ const componentDefinition = {
 			},
 			externals: () => ({ computeKernel })
 		}) && $.f)({}), {
-			size: [COMPUTE_W, COMPUTE_H],
+			size: [computeW, computeH],
 			bindGroup: computeBg
 		});
 		const propagate = cursorEnabled ? makePropagateKernel() : null;
@@ -4794,7 +5150,8 @@ const componentDefinition = {
 		let lastTime = Date.now();
 		let lastActiveTime = Date.now();
 		let animT = 0;
-		const writeParams = (fp, mouseSpeed) => {
+		let lastSig = null;
+		const writeParams = (fp, mouseSpeed, cursorActive) => {
 			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;
@@ -4848,36 +5205,85 @@ const componentDefinition = {
 			const cursorWorldUVx = cWX0 * .5 + .5;
 			const cursorWorldUVy = cWY0 * .5 + .5;
 			const lc = getCpuValue("lightColor");
+			const amp = getCpuValue("amplitude") ?? .3;
+			const cursorIntensity = getCpuValue("cursorIntensity") ?? 1;
+			const freq = getCpuValue("frequency") ?? 1.5;
+			const seed = getCpuValue("seed") ?? 0;
+			const edgePin = getCpuValue("edgePinning") ?? 0;
+			const lighting = (getCpuValue("lighting") ?? 30) * .035;
+			const glossiness = (getCpuValue("glossiness") ?? 0) * .01;
+			const highlights = (getCpuValue("highlights") ?? 15) * .04;
+			const lightX = getCpuValue("lightX") ?? .4;
+			const lightY = getCpuValue("lightY") ?? -.6;
+			const lightZ = getCpuValue("lightZ") ?? .7;
+			const nearCutoff = getCpuValue("nearCutoff") ?? 0;
+			const farCutoff = getCpuValue("farCutoff") ?? 1;
+			const waveSpeed = getCpuValue("cursorSpeed") ?? .5;
+			const cursorWaveX = (cursorWorldUVx - .5) / WAVE_HALFEXTENT + .5;
+			const cursorWaveY = (cursorWorldUVy - .5) / WAVE_HALFEXTENT + .5;
+			const heightEnvelope = amp + HEIGHT_SLAB_PAD + (cursorActive > 0 ? cursorIntensity * .05 * CURSOR_WAVE_BOUND : 0);
 			paramsU.write({
-				amp: getCpuValue("amplitude") ?? .3,
-				freq: getCpuValue("frequency") ?? 1.5,
-				seed: getCpuValue("seed") ?? 0,
-				edgePin: getCpuValue("edgePinning") ?? 0,
-				cursorIntensity: getCpuValue("cursorIntensity") ?? 1,
+				amp,
+				freq,
+				seed,
+				edgePin,
+				cursorIntensity,
 				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,
+				camPos: vec3f(camPos[0], camPos[1], camPos[2]),
+				camForward: vec3f(fwd[0], fwd[1], fwd[2]),
+				camRight: vec3f(camRight[0], camRight[1], camRight[2]),
+				camUp: vec3f(camUp[0], camUp[1], camUp[2]),
+				lighting,
+				glossiness,
+				highlights,
+				lightX,
+				lightY,
+				lightZ,
+				lightColor: vec3f(lc?.x ?? 1, lc?.y ?? 1, lc?.z ?? 1),
+				nearCutoff,
+				farCutoff,
+				cursorWaveX,
+				cursorWaveY,
 				mouseSpeed,
 				dt: .016,
-				decay: 10,
+				decay: WAVE_DECAY,
 				radius: .025,
-				waveSpeed: getCpuValue("cursorSpeed") ?? .5
+				waveSpeed,
+				heightEnvelope,
+				cursorActive
 			});
+			return [
+				amp,
+				freq,
+				seed,
+				edgePin,
+				cursorIntensity,
+				animT,
+				aspect,
+				tilt,
+				roll,
+				camHeight,
+				zoom,
+				lighting,
+				glossiness,
+				highlights,
+				lightX,
+				lightY,
+				lightZ,
+				lc?.x ?? 1,
+				lc?.y ?? 1,
+				lc?.z ?? 1,
+				nearCutoff,
+				farCutoff,
+				cursorWaveX,
+				cursorWaveY,
+				mouseSpeed,
+				waveSpeed,
+				heightEnvelope,
+				cursorActive
+			].join(",");
 		};
 		return {
 			outputs: {
@@ -4898,11 +5304,11 @@ const componentDefinition = {
 				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 waveSettled = !cursorEnabled || !propagatePass || now - lastActiveTime > WAVE_SETTLE_MS && mouseSpeed < .01;
+				const sig = writeParams(fp, mouseSpeed, waveSettled ? 0 : 1);
+				if (waveSettled && sig === lastSig) return [];
+				lastSig = sig;
+				if (waveSettled || !propagatePass) return [computePass];
 				const prop = direction === 0 ? propagatePass.with(propBgAB) : propagatePass.with(propBgBA);
 				direction = 1 - direction;
 				return [prop, computePass];