@hello-terrain/three 0.0.0-alpha.12 → 0.0.0-alpha.14

package/dist/index.cjs

@@ -361,6 +361,7 @@ function compileComputePipeline(stages, width, options) {
     WORKGROUP_X,
     WORKGROUP_Y
   ];
+  const midPipelineExecute = options?.midPipelineExecute;
   const uInstanceCount = tsl.uniform(0, "uint").setName("uInstanceCount");
   const stagedKernelCache = /* @__PURE__ */ new Map();
   function clampWorkgroupToLimits(requested, limits) {
@@ -421,281 +422,14 @@ function compileComputePipeline(stages, width, options) {
     }
     const dispatchX = Math.ceil(width / workgroupX);
     const dispatchY = Math.ceil(width / workgroupY);
-    for (const kernel of stagedKernels) {
-      renderer.compute(kernel, [dispatchX, dispatchY, instanceCount]);
-    }
-  }
-  return { execute };
-}
-
-function resolveType(format) {
-  return format === "rgba16float" ? three.HalfFloatType : three.FloatType;
-}
-function resolveFilter(mode) {
-  return mode === "linear" ? three.LinearFilter : three.NearestFilter;
-}
-function configureStorageTexture(texture2, format, filter) {
-  texture2.format = three.RGBAFormat;
-  texture2.type = resolveType(format);
-  texture2.magFilter = resolveFilter(filter);
-  texture2.minFilter = resolveFilter(filter);
-  texture2.wrapS = three.ClampToEdgeWrapping;
-  texture2.wrapT = three.ClampToEdgeWrapping;
-  texture2.generateMipmaps = false;
-  texture2.needsUpdate = true;
-}
-function ArrayTextureBackend(edgeVertexCount, tileCount, options) {
-  let currentEdgeVertexCount = edgeVertexCount;
-  let currentTileCount = tileCount;
-  const tex = new webgpu.StorageArrayTexture(
-    edgeVertexCount,
-    edgeVertexCount,
-    tileCount
-  );
-  tex.name = "terrainField";
-  configureStorageTexture(tex, options.format, options.filter);
-  return {
-    backendType: "array-texture",
-    get edgeVertexCount() {
-      return currentEdgeVertexCount;
-    },
-    get tileCount() {
-      return currentTileCount;
-    },
-    texture: tex,
-    uv(ix, iy, _tileIndex) {
-      return tsl.vec2(ix.toFloat(), iy.toFloat());
-    },
-    texel(ix, iy, tileIndex) {
-      return tsl.ivec3(ix, iy, tileIndex);
-    },
-    sample(u, v, tileIndex) {
-      return tsl.texture(tex, tsl.vec2(u, v)).depth(tsl.int(tileIndex));
-    },
-    resize(width, height, nextTileCount) {
-      currentEdgeVertexCount = width;
-      currentTileCount = nextTileCount;
-      tex.setSize(width, height, nextTileCount);
-      tex.needsUpdate = true;
-    }
-  };
-}
-function atlasCoord(tilesPerRow, edgeVertexCount, ix, iy, tileIndex) {
-  const tilesPerRowNode = tsl.int(tilesPerRow);
-  const edge = tsl.int(edgeVertexCount);
-  const tile = tsl.int(tileIndex);
-  const col = tile.mod(tilesPerRowNode);
-  const row = tile.div(tilesPerRowNode);
-  const atlasX = col.mul(edge).add(tsl.int(ix));
-  const atlasY = row.mul(edge).add(tsl.int(iy));
-  return { atlasX, atlasY };
-}
-function AtlasBackend(edgeVertexCount, tileCount, options) {
-  let currentEdgeVertexCount = edgeVertexCount;
-  let currentTileCount = tileCount;
-  let tilesPerRow = Math.max(1, Math.ceil(Math.sqrt(tileCount)));
-  const atlasSize = tilesPerRow * edgeVertexCount;
-  const tex = new webgpu.StorageTexture(atlasSize, atlasSize);
-  tex.name = "terrainFieldAtlas";
-  configureStorageTexture(tex, options.format, options.filter);
-  return {
-    backendType: "atlas",
-    get edgeVertexCount() {
-      return currentEdgeVertexCount;
-    },
-    get tileCount() {
-      return currentTileCount;
-    },
-    texture: tex,
-    uv(ix, iy, tileIndex) {
-      const { atlasX, atlasY } = atlasCoord(
-        tilesPerRow,
-        currentEdgeVertexCount,
-        ix,
-        iy,
-        tileIndex
-      );
-      const currentAtlasSize = tsl.float(tilesPerRow * currentEdgeVertexCount);
-      return tsl.vec2(
-        atlasX.toFloat().add(0.5).div(currentAtlasSize),
-        atlasY.toFloat().add(0.5).div(currentAtlasSize)
-      );
-    },
-    texel(ix, iy, tileIndex) {
-      const { atlasX, atlasY } = atlasCoord(
-        tilesPerRow,
-        currentEdgeVertexCount,
-        ix,
-        iy,
-        tileIndex
-      );
-      return tsl.ivec2(atlasX, atlasY);
-    },
-    sample(u, v, tileIndex) {
-      const tile = tsl.int(tileIndex);
-      const tilesPerRowNode = tsl.int(tilesPerRow);
-      const col = tile.mod(tilesPerRowNode);
-      const row = tile.div(tilesPerRowNode);
-      const invTilesPerRow = tsl.float(1 / tilesPerRow);
-      const atlasU = col.toFloat().add(u).mul(invTilesPerRow);
-      const atlasV = row.toFloat().add(v).mul(invTilesPerRow);
-      return tsl.texture(tex, tsl.vec2(atlasU, atlasV));
-    },
-    resize(width, height, nextTileCount) {
-      currentEdgeVertexCount = width;
-      currentTileCount = nextTileCount;
-      tilesPerRow = Math.max(1, Math.ceil(Math.sqrt(nextTileCount)));
-      const nextAtlasSize = tilesPerRow * width;
-      const image = tex.image;
-      image.width = nextAtlasSize;
-      image.height = nextAtlasSize;
-      tex.needsUpdate = true;
-    }
-  };
-}
-function texture3DBackend(edgeVertexCount, tileCount, options) {
-  const storage = ArrayTextureBackend(edgeVertexCount, tileCount, options);
-  return { ...storage, backendType: "texture-3d" };
-}
-function tryGetDeviceLimits(renderer) {
-  const backend = renderer;
-  return backend.backend?.device?.limits ?? {};
-}
-function createTerrainFieldStorage(edgeVertexCount, tileCount, renderer, options = {}) {
-  const filter = options.filter ?? "linear";
-  const format = options.format ?? "rgba16float";
-  const forcedBackend = options.backend;
-  if (forcedBackend === "atlas") {
-    return AtlasBackend(edgeVertexCount, tileCount, { filter, format });
-  }
-  if (forcedBackend === "texture-3d") {
-    return texture3DBackend(edgeVertexCount, tileCount, { filter, format });
-  }
-  if (forcedBackend === "array-texture") {
-    return ArrayTextureBackend(edgeVertexCount, tileCount, { filter, format });
-  }
-  const DEFAULT_MAX_TEXTURE_ARRAY_LAYERS = 256;
-  const maxLayers = renderer ? tryGetDeviceLimits(renderer).maxTextureArrayLayers ?? DEFAULT_MAX_TEXTURE_ARRAY_LAYERS : DEFAULT_MAX_TEXTURE_ARRAY_LAYERS;
-  if (tileCount > maxLayers) {
-    return AtlasBackend(edgeVertexCount, tileCount, { filter, format });
-  }
-  return ArrayTextureBackend(edgeVertexCount, tileCount, { filter, format });
-}
-function storeTerrainField(storage, ix, iy, tileIndex, value) {
-  if (storage.backendType === "array-texture" || storage.backendType === "texture-3d") {
-    return tsl.textureStore(
-      storage.texture,
-      tsl.uvec3(tsl.int(ix), tsl.int(iy), tsl.int(tileIndex)),
-      value
-    );
-  }
-  return tsl.textureStore(storage.texture, storage.texel(ix, iy, tileIndex), value);
-}
-function loadTerrainField(storage, ix, iy, tileIndex) {
-  if (storage.backendType === "array-texture" || storage.backendType === "texture-3d") {
-    return tsl.textureLoad(storage.texture, tsl.ivec2(tsl.int(ix), tsl.int(iy)), tsl.int(0)).depth(
-      tsl.int(tileIndex)
-    );
-  }
-  return tsl.textureLoad(storage.texture, storage.texel(ix, iy, tileIndex), tsl.int(0));
-}
-function loadTerrainFieldElevation(storage, ix, iy, tileIndex) {
-  return loadTerrainField(storage, ix, iy, tileIndex).r;
-}
-function loadTerrainFieldNormal(storage, ix, iy, tileIndex) {
-  const raw = loadTerrainField(storage, ix, iy, tileIndex);
-  return tsl.vec3(raw.g, raw.b, raw.a);
-}
-function sampleTerrainField(storage, u, v, tileIndex) {
-  return storage.sample(u, v, tileIndex);
-}
-function sampleTerrainFieldElevation(storage, u, v, tileIndex) {
-  return sampleTerrainField(storage, u, v, tileIndex).r;
-}
-function packTerrainFieldSample(height, normal) {
-  return tsl.vec4(height, normal.x, normal.y, normal.z);
-}
-
-const createElevation = (tile, uniforms, elevationFn) => {
-  return function perVertexElevation(nodeIndex, localCoordinates) {
-    const ix = tsl.int(localCoordinates.x);
-    const iy = tsl.int(localCoordinates.y);
-    const edgeVertexCount = uniforms.uInnerTileSegments.toVar().add(tsl.int(3));
-    const tileUV = localCoordinates.toFloat().div(edgeVertexCount.toFloat());
-    const rootUV = tile.rootUVCompute(nodeIndex, ix, iy);
-    const worldPosition = tile.tileVertexWorldPositionCompute(nodeIndex, ix, iy).setName("worldPositionWithSkirt");
-    const rootSize = uniforms.uRootSize.toVar();
-    return elevationFn({
-      worldPosition,
-      rootSize,
-      rootUV,
-      tileOriginVec2: tile.tileOriginVec2(nodeIndex),
-      tileSize: tile.tileSize(nodeIndex),
-      tileLevel: tile.tileLevel(nodeIndex),
-      nodeIndex: tsl.int(nodeIndex),
-      tileUV
-    });
-  };
-};
-
-const HALF_PI = Math.PI * 0.5;
-const FIELD_INNER_TEXEL_OFFSET = 1.5;
-const FIELD_EDGE_EXTRA_TEXELS = 3;
-function sphereTileArcLength(radius, levelDivisor) {
-  return radius * HALF_PI / levelDivisor;
-}
-function decodeLeafTile(leafStorage, nodeIndex) {
-  const nodeOffset = tsl.int(nodeIndex).mul(tsl.int(4));
-  return {
-    level: leafStorage.node.element(nodeOffset).toInt(),
-    x: leafStorage.node.element(nodeOffset.add(tsl.int(1))).toFloat(),
-    y: leafStorage.node.element(nodeOffset.add(tsl.int(2))).toFloat(),
-    face: leafStorage.node.element(nodeOffset.add(tsl.int(3))).toInt()
-  };
-}
-function faceUVFromTileLocal(tile, localU, localV, baseU = tsl.float(1), baseV = tsl.float(1)) {
-  const levelScale = tsl.pow(tsl.float(2), tile.level.toFloat());
-  const nU = baseU.mul(levelScale);
-  const nV = baseV.mul(levelScale);
-  return tsl.vec2(tile.x.add(localU).div(nU), tile.y.add(localV).div(nV));
-}
-function createTileCompute(leafStorage, uniforms, projection) {
-  const baseU = tsl.float(projection.baseResolution?.u ?? 1);
-  const baseV = tsl.float(projection.baseResolution?.v ?? 1);
-  const tileLevel = tsl.Fn(([nodeIndex]) => decodeLeafTile(leafStorage, nodeIndex).level);
-  const tileFace = tsl.Fn(([nodeIndex]) => decodeLeafTile(leafStorage, nodeIndex).face);
-  const tileOriginVec2 = tsl.Fn(([nodeIndex]) => {
-    const tile = decodeLeafTile(leafStorage, nodeIndex);
-    return tsl.vec2(tile.x, tile.y);
-  });
-  const tileFaceUV = tsl.Fn(([nodeIndex, ix, iy]) => {
-    const tile = decodeLeafTile(leafStorage, nodeIndex);
-    const fInnerSegments = uniforms.uInnerTileSegments.toVar().toFloat();
-    const localU = tsl.int(ix).toFloat().sub(tsl.float(1)).div(fInnerSegments);
-    const localV = tsl.int(iy).toFloat().sub(tsl.float(1)).div(fInnerSegments);
-    return faceUVFromTileLocal(tile, localU, localV, baseU, baseV);
-  });
-  const shared = {
-    tileLevel: (nodeIndex) => tileLevel(nodeIndex),
-    tileFace: (nodeIndex) => tileFace(nodeIndex),
-    tileOriginVec2: (nodeIndex) => tileOriginVec2(nodeIndex),
-    tileFaceUV: (nodeIndex, ix, iy) => tileFaceUV(nodeIndex, ix, iy)
-  };
-  const parts = projection.gpu.createTileComputeParts({ leafStorage, uniforms, shared });
-  return {
-    ...shared,
-    tileSize: parts.tileSize,
-    rootUVCompute: parts.rootUV,
-    tileVertexWorldPositionCompute: parts.tileVertexWorldPosition
-  };
-}
-function tileLocalToFieldUV(localCoord, innerSegments) {
-  const edge = tsl.float(innerSegments).add(tsl.float(FIELD_EDGE_EXTRA_TEXELS));
-  return tsl.float(localCoord).mul(tsl.float(innerSegments)).add(tsl.float(FIELD_INNER_TEXEL_OFFSET)).div(edge);
-}
-function tileLocalToFieldUVNumber(localCoord, innerSegments) {
-  const edge = innerSegments + FIELD_EDGE_EXTRA_TEXELS;
-  return (localCoord * innerSegments + FIELD_INNER_TEXEL_OFFSET) / edge;
+    for (let stageIndex = 0; stageIndex < stagedKernels.length; stageIndex += 1) {
+      renderer.compute(stagedKernels[stageIndex], [dispatchX, dispatchY, instanceCount]);
+      if (midPipelineExecute && stagedKernels.length > 1 && stageIndex === stagedKernels.length - 2) {
+        midPipelineExecute(renderer, instanceCount);
+      }
+    }
+  }
+  return { execute };
 }
 
 function createLeafStorage(maxNodes) {
@@ -937,20 +671,15 @@ function beginUpdate(state, topology, params) {
 
 function shouldSplit(bounds, level, maxLevel, params) {
   if (level >= maxLevel) return false;
-  const mode = params.mode ?? "distance";
   const cx = bounds.cx;
   const cy = bounds.cy;
   const cz = bounds.cz;
   const distSq = cx * cx + cy * cy + cz * cz;
   const safeDistSq = distSq > 1e-12 ? distSq : 1e-12;
-  if (mode === "screen") {
-    const proj = params.projectionFactor ?? 0;
-    const target = params.targetPixels ?? 0;
-    if (proj <= 0 || target <= 0) {
-      const f2 = params.distanceFactor ?? 2;
-      const threshold2 = bounds.r * f2;
-      return safeDistSq < threshold2 * threshold2;
-    }
+  if (params.mode === "screen") {
+    const proj = params.projectionFactor;
+    const target = params.targetPixels;
+    if (proj <= 0 || target <= 0) return false;
     const left = bounds.r * bounds.r * proj * proj;
     const right = safeDistSq * target * target;
     return left > right;
@@ -984,7 +713,7 @@ function refineLeaves(state, topology, params, outLeaves) {
     let elevationRange;
     if (params.tileElevationRange) {
       const range = state.scratchElevationRange;
-      if (params.tileElevationRange(space, level, x, y, range)) {
+      if (params.tileElevationRange(tile, range)) {
         elevationRange = range;
       }
     }
@@ -1087,19 +816,9 @@ function balance2to1(state, topology, params, leaves) {
 }
 
 function update(state, topology, params, outLeaves) {
-  const cam = params.cameraOrigin;
-  const elevation = params.elevationAtCameraXZ ?? 0;
-  const origX = cam.x;
-  const origY = cam.y;
-  const origZ = cam.z;
-  topology.projection.cpu.cameraSurfaceOffset(cam, elevation);
   beginUpdate(state, topology, params);
   const leaves = refineLeaves(state, topology, params, outLeaves);
-  const result = balance2to1(state, topology, params, leaves);
-  cam.x = origX;
-  cam.y = origY;
-  cam.z = origZ;
-  return result;
+  return balance2to1(state, topology, params, leaves);
 }
 
 const scratchTile = { space: 0, level: 0, x: 0, y: 0 };
@@ -1196,94 +915,370 @@ function buildSeams2to1(topology, leaves, outSeams, outIndex) {
   return outSeams;
 }
 
-function createFlatNormalFromElevationField(elevationFieldNode, edgeVertexCount) {
-  return tsl.Fn(
-    ([nodeIndex, tileSize, ix, iy, elevationScale]) => {
-      const iEdge = tsl.int(edgeVertexCount);
-      const verticesPerNode = iEdge.mul(iEdge);
-      const baseOffset = tsl.int(nodeIndex).mul(verticesPerNode);
-      const xLeft = tsl.int(ix).sub(tsl.int(1));
-      const xRight = tsl.int(ix).add(tsl.int(1));
-      const yUp = tsl.int(iy).sub(tsl.int(1));
-      const yDown = tsl.int(iy).add(tsl.int(1));
-      const hLeft = elevationFieldNode.element(baseOffset.add(tsl.int(iy).mul(iEdge).add(xLeft))).mul(elevationScale);
-      const hRight = elevationFieldNode.element(baseOffset.add(tsl.int(iy).mul(iEdge).add(xRight))).mul(elevationScale);
-      const hUp = elevationFieldNode.element(baseOffset.add(yUp.mul(iEdge).add(tsl.int(ix)))).mul(elevationScale);
-      const hDown = elevationFieldNode.element(baseOffset.add(yDown.mul(iEdge).add(tsl.int(ix)))).mul(elevationScale);
-      const innerSegments = tsl.float(iEdge).sub(tsl.float(3));
-      const stepWorld = tileSize.div(innerSegments);
-      const inv2Step = tsl.float(0.5).div(stepWorld);
-      const dhdx = tsl.float(hRight).sub(tsl.float(hLeft)).mul(inv2Step);
-      const dhdz = tsl.float(hDown).sub(tsl.float(hUp)).mul(inv2Step);
-      return tsl.vec3(dhdx.negate(), tsl.float(1), dhdz.negate()).normalize();
-    }
-  );
+function createFlatNormalFromElevationField(elevationFieldNode, edgeVertexCount) {
+  return tsl.Fn(
+    ([nodeIndex, tileSize, ix, iy, elevationScale]) => {
+      const iEdge = tsl.int(edgeVertexCount);
+      const verticesPerNode = iEdge.mul(iEdge);
+      const baseOffset = tsl.int(nodeIndex).mul(verticesPerNode);
+      const xLeft = tsl.int(ix).sub(tsl.int(1));
+      const xRight = tsl.int(ix).add(tsl.int(1));
+      const yUp = tsl.int(iy).sub(tsl.int(1));
+      const yDown = tsl.int(iy).add(tsl.int(1));
+      const hLeft = elevationFieldNode.element(baseOffset.add(tsl.int(iy).mul(iEdge).add(xLeft))).mul(elevationScale);
+      const hRight = elevationFieldNode.element(baseOffset.add(tsl.int(iy).mul(iEdge).add(xRight))).mul(elevationScale);
+      const hUp = elevationFieldNode.element(baseOffset.add(yUp.mul(iEdge).add(tsl.int(ix)))).mul(elevationScale);
+      const hDown = elevationFieldNode.element(baseOffset.add(yDown.mul(iEdge).add(tsl.int(ix)))).mul(elevationScale);
+      const innerSegments = tsl.float(iEdge).sub(tsl.float(3));
+      const stepWorld = tileSize.div(innerSegments);
+      const inv2Step = tsl.float(0.5).div(stepWorld);
+      const dhdx = tsl.float(hRight).sub(tsl.float(hLeft)).mul(inv2Step);
+      const dhdz = tsl.float(hDown).sub(tsl.float(hUp)).mul(inv2Step);
+      return tsl.vec3(dhdx.negate(), tsl.float(1), dhdz.negate()).normalize();
+    }
+  );
+}
+function createDisplacedSurfaceNormalFromElevationField(elevationFieldNode, edgeVertexCount, makeSurfaceFns) {
+  return tsl.Fn(([nodeIndex, ix, iy, elevationScale]) => {
+    const iEdge = tsl.int(edgeVertexCount);
+    const verticesPerNode = iEdge.mul(iEdge);
+    const baseOffset = tsl.int(nodeIndex).mul(verticesPerNode);
+    const xLeft = tsl.int(ix).sub(tsl.int(1));
+    const xRight = tsl.int(ix).add(tsl.int(1));
+    const yUp = tsl.int(iy).sub(tsl.int(1));
+    const yDown = tsl.int(iy).add(tsl.int(1));
+    const heightAt = (gx, gy) => elevationFieldNode.element(baseOffset.add(gy.mul(iEdge).add(gx))).mul(elevationScale);
+    const { positionAt, dirAt } = makeSurfaceFns(nodeIndex);
+    const pLeft = positionAt(xLeft, tsl.int(iy), heightAt(xLeft, tsl.int(iy)));
+    const pRight = positionAt(xRight, tsl.int(iy), heightAt(xRight, tsl.int(iy)));
+    const pUp = positionAt(tsl.int(ix), yUp, heightAt(tsl.int(ix), yUp));
+    const pDown = positionAt(tsl.int(ix), yDown, heightAt(tsl.int(ix), yDown));
+    const tangentU = pRight.sub(pLeft);
+    const tangentV = pDown.sub(pUp);
+    const normal = tsl.cross(tangentU, tangentV).normalize();
+    const dir = dirAt(tsl.int(ix), tsl.int(iy));
+    return normal.mul(normal.dot(dir).sign());
+  });
+}
+
+const isSkirtVertex = tsl.Fn(([segments]) => {
+  const segmentsNode = typeof segments === "number" ? tsl.int(segments) : segments;
+  const vIndex = tsl.int(tsl.vertexIndex);
+  const segmentEdges = tsl.int(segmentsNode.add(3));
+  const vx = vIndex.mod(segmentEdges);
+  const vy = vIndex.div(segmentEdges);
+  const last = segmentEdges.sub(tsl.int(1));
+  return vx.equal(tsl.int(0)).or(vx.equal(last)).or(vy.equal(tsl.int(0))).or(vy.equal(last));
+});
+const isSkirtUV = tsl.Fn(([segments]) => {
+  const segmentsNode = typeof segments === "number" ? tsl.int(segments) : segments;
+  const ux = tsl.uv().x;
+  const uy = tsl.uv().y;
+  const segmentCount = segmentsNode.add(2);
+  const segmentStep = tsl.float(1).div(segmentCount);
+  const innerX = ux.greaterThan(segmentStep).and(ux.lessThan(segmentStep.oneMinus()));
+  const innerY = uy.greaterThan(segmentStep).and(uy.lessThan(segmentStep.oneMinus()));
+  return innerX.and(innerY).not();
+});
+
+const TILE_BOUNDS_FLOATS_PER_TILE = 4;
+const TILE_BOUNDS_LOD_MIN_OFFSET = 0;
+const TILE_BOUNDS_LOD_MAX_OFFSET = 1;
+const TILE_BOUNDS_PACK_MIN_OFFSET = 2;
+const TILE_BOUNDS_PACK_MAX_OFFSET = 3;
+const TERRAIN_FIELD_PACK_EPSILON = 1e-4;
+function resolveType(format) {
+  return format === "rgba16float" ? three.HalfFloatType : three.FloatType;
+}
+function resolveFilter(mode) {
+  return mode === "linear" ? three.LinearFilter : three.NearestFilter;
+}
+function configureStorageTexture(texture2, format, filter) {
+  texture2.format = three.RGBAFormat;
+  texture2.type = resolveType(format);
+  texture2.magFilter = resolveFilter(filter);
+  texture2.minFilter = resolveFilter(filter);
+  texture2.wrapS = three.ClampToEdgeWrapping;
+  texture2.wrapT = three.ClampToEdgeWrapping;
+  texture2.generateMipmaps = false;
+  texture2.needsUpdate = true;
+}
+function ArrayTextureBackend(edgeVertexCount, tileCount, options) {
+  let currentEdgeVertexCount = edgeVertexCount;
+  let currentTileCount = tileCount;
+  const tex = new webgpu.StorageArrayTexture(
+    edgeVertexCount,
+    edgeVertexCount,
+    tileCount
+  );
+  tex.name = "terrainField";
+  configureStorageTexture(tex, options.format, options.filter);
+  return {
+    backendType: "array-texture",
+    get edgeVertexCount() {
+      return currentEdgeVertexCount;
+    },
+    get tileCount() {
+      return currentTileCount;
+    },
+    texture: tex,
+    uv(ix, iy, _tileIndex) {
+      return tsl.vec2(ix.toFloat(), iy.toFloat());
+    },
+    texel(ix, iy, tileIndex) {
+      return tsl.ivec3(ix, iy, tileIndex);
+    },
+    sample(u, v, tileIndex) {
+      return tsl.texture(tex, tsl.vec2(u, v)).depth(tsl.int(tileIndex));
+    },
+    resize(width, height, nextTileCount) {
+      currentEdgeVertexCount = width;
+      currentTileCount = nextTileCount;
+      tex.setSize(width, height, nextTileCount);
+      tex.needsUpdate = true;
+    }
+  };
+}
+function atlasCoord(tilesPerRow, edgeVertexCount, ix, iy, tileIndex) {
+  const tilesPerRowNode = tsl.int(tilesPerRow);
+  const edge = tsl.int(edgeVertexCount);
+  const tile = tsl.int(tileIndex);
+  const col = tile.mod(tilesPerRowNode);
+  const row = tile.div(tilesPerRowNode);
+  const atlasX = col.mul(edge).add(tsl.int(ix));
+  const atlasY = row.mul(edge).add(tsl.int(iy));
+  return { atlasX, atlasY };
+}
+function AtlasBackend(edgeVertexCount, tileCount, options) {
+  let currentEdgeVertexCount = edgeVertexCount;
+  let currentTileCount = tileCount;
+  let tilesPerRow = Math.max(1, Math.ceil(Math.sqrt(tileCount)));
+  const atlasSize = tilesPerRow * edgeVertexCount;
+  const tex = new webgpu.StorageTexture(atlasSize, atlasSize);
+  tex.name = "terrainFieldAtlas";
+  configureStorageTexture(tex, options.format, options.filter);
+  return {
+    backendType: "atlas",
+    get edgeVertexCount() {
+      return currentEdgeVertexCount;
+    },
+    get tileCount() {
+      return currentTileCount;
+    },
+    texture: tex,
+    uv(ix, iy, tileIndex) {
+      const { atlasX, atlasY } = atlasCoord(
+        tilesPerRow,
+        currentEdgeVertexCount,
+        ix,
+        iy,
+        tileIndex
+      );
+      const currentAtlasSize = tsl.float(tilesPerRow * currentEdgeVertexCount);
+      return tsl.vec2(
+        atlasX.toFloat().add(0.5).div(currentAtlasSize),
+        atlasY.toFloat().add(0.5).div(currentAtlasSize)
+      );
+    },
+    texel(ix, iy, tileIndex) {
+      const { atlasX, atlasY } = atlasCoord(
+        tilesPerRow,
+        currentEdgeVertexCount,
+        ix,
+        iy,
+        tileIndex
+      );
+      return tsl.ivec2(atlasX, atlasY);
+    },
+    sample(u, v, tileIndex) {
+      const tile = tsl.int(tileIndex);
+      const tilesPerRowNode = tsl.int(tilesPerRow);
+      const col = tile.mod(tilesPerRowNode);
+      const row = tile.div(tilesPerRowNode);
+      const invTilesPerRow = tsl.float(1 / tilesPerRow);
+      const atlasU = col.toFloat().add(u).mul(invTilesPerRow);
+      const atlasV = row.toFloat().add(v).mul(invTilesPerRow);
+      return tsl.texture(tex, tsl.vec2(atlasU, atlasV));
+    },
+    resize(width, height, nextTileCount) {
+      currentEdgeVertexCount = width;
+      currentTileCount = nextTileCount;
+      tilesPerRow = Math.max(1, Math.ceil(Math.sqrt(nextTileCount)));
+      const nextAtlasSize = tilesPerRow * width;
+      const image = tex.image;
+      image.width = nextAtlasSize;
+      image.height = nextAtlasSize;
+      tex.needsUpdate = true;
+    }
+  };
+}
+function texture3DBackend(edgeVertexCount, tileCount, options) {
+  const storage = ArrayTextureBackend(edgeVertexCount, tileCount, options);
+  return { ...storage, backendType: "texture-3d" };
+}
+function tryGetDeviceLimits(renderer) {
+  const backend = renderer;
+  return backend.backend?.device?.limits ?? {};
+}
+function createTerrainFieldStorage(edgeVertexCount, tileCount, renderer, options = {}) {
+  const filter = options.filter ?? "linear";
+  const format = options.format ?? "rgba16float";
+  const forcedBackend = options.backend;
+  if (forcedBackend === "atlas") {
+    return AtlasBackend(edgeVertexCount, tileCount, { filter, format });
+  }
+  if (forcedBackend === "texture-3d") {
+    return texture3DBackend(edgeVertexCount, tileCount, { filter, format });
+  }
+  if (forcedBackend === "array-texture") {
+    return ArrayTextureBackend(edgeVertexCount, tileCount, { filter, format });
+  }
+  const DEFAULT_MAX_TEXTURE_ARRAY_LAYERS = 256;
+  const maxLayers = renderer ? tryGetDeviceLimits(renderer).maxTextureArrayLayers ?? DEFAULT_MAX_TEXTURE_ARRAY_LAYERS : DEFAULT_MAX_TEXTURE_ARRAY_LAYERS;
+  if (tileCount > maxLayers) {
+    return AtlasBackend(edgeVertexCount, tileCount, { filter, format });
+  }
+  return ArrayTextureBackend(edgeVertexCount, tileCount, { filter, format });
+}
+function storeTerrainField(storage, ix, iy, tileIndex, value) {
+  if (storage.backendType === "array-texture" || storage.backendType === "texture-3d") {
+    return tsl.textureStore(
+      storage.texture,
+      tsl.uvec3(tsl.int(ix), tsl.int(iy), tsl.int(tileIndex)),
+      value
+    );
+  }
+  return tsl.textureStore(storage.texture, storage.texel(ix, iy, tileIndex), value);
+}
+function loadTerrainField(storage, ix, iy, tileIndex) {
+  if (storage.backendType === "array-texture" || storage.backendType === "texture-3d") {
+    return tsl.textureLoad(storage.texture, tsl.ivec2(tsl.int(ix), tsl.int(iy)), tsl.int(0)).depth(
+      tsl.int(tileIndex)
+    );
+  }
+  return tsl.textureLoad(storage.texture, storage.texel(ix, iy, tileIndex), tsl.int(0));
+}
+function loadTerrainFieldElevation(storage, ix, iy, tileIndex) {
+  return loadTerrainField(storage, ix, iy, tileIndex).r;
+}
+function loadTerrainFieldNormal(storage, ix, iy, tileIndex) {
+  const raw = loadTerrainField(storage, ix, iy, tileIndex);
+  return tsl.vec3(raw.g, raw.b, raw.a);
+}
+function sampleTerrainField(storage, u, v, tileIndex) {
+  return storage.sample(u, v, tileIndex);
+}
+function sampleTerrainFieldElevation(storage, u, v, tileIndex) {
+  return sampleTerrainField(storage, u, v, tileIndex).r;
+}
+function packTerrainFieldSample(height, normal) {
+  return tsl.vec4(height, normal.x, normal.y, normal.z);
+}
+function loadTilePackBounds(boundsNode, tileIndex) {
+  const base = tsl.int(tileIndex).mul(tsl.int(TILE_BOUNDS_FLOATS_PER_TILE));
+  return {
+    packMin: boundsNode.element(base.add(tsl.int(TILE_BOUNDS_PACK_MIN_OFFSET))),
+    packMax: boundsNode.element(base.add(tsl.int(TILE_BOUNDS_PACK_MAX_OFFSET)))
+  };
+}
+function packNormalizedTerrainFieldSample(height, normal, packMin, packMax) {
+  const span = tsl.max(packMax.sub(packMin), tsl.float(TERRAIN_FIELD_PACK_EPSILON));
+  const normalized = height.sub(packMin).div(span);
+  return tsl.vec4(normalized, normal.x, normal.y, normal.z);
+}
+function denormalizeTerrainFieldElevation(normalized, packMin, packMax) {
+  const span = tsl.max(packMax.sub(packMin), tsl.float(TERRAIN_FIELD_PACK_EPSILON));
+  return packMin.add(normalized.mul(span));
+}
+
+const HALF_PI = Math.PI * 0.5;
+const FIELD_INNER_TEXEL_OFFSET = 1.5;
+const FIELD_EDGE_EXTRA_TEXELS = 3;
+function sphereTileArcLength(radius, levelDivisor) {
+  return radius * HALF_PI / levelDivisor;
 }
-function createDisplacedSurfaceNormalFromElevationField(elevationFieldNode, edgeVertexCount, makeSurfaceFns) {
-  return tsl.Fn(([nodeIndex, ix, iy, elevationScale]) => {
-    const iEdge = tsl.int(edgeVertexCount);
-    const verticesPerNode = iEdge.mul(iEdge);
-    const baseOffset = tsl.int(nodeIndex).mul(verticesPerNode);
-    const xLeft = tsl.int(ix).sub(tsl.int(1));
-    const xRight = tsl.int(ix).add(tsl.int(1));
-    const yUp = tsl.int(iy).sub(tsl.int(1));
-    const yDown = tsl.int(iy).add(tsl.int(1));
-    const heightAt = (gx, gy) => elevationFieldNode.element(baseOffset.add(gy.mul(iEdge).add(gx))).mul(elevationScale);
-    const { positionAt, dirAt } = makeSurfaceFns(nodeIndex);
-    const pLeft = positionAt(xLeft, tsl.int(iy), heightAt(xLeft, tsl.int(iy)));
-    const pRight = positionAt(xRight, tsl.int(iy), heightAt(xRight, tsl.int(iy)));
-    const pUp = positionAt(tsl.int(ix), yUp, heightAt(tsl.int(ix), yUp));
-    const pDown = positionAt(tsl.int(ix), yDown, heightAt(tsl.int(ix), yDown));
-    const tangentU = pRight.sub(pLeft);
-    const tangentV = pDown.sub(pUp);
-    const normal = tsl.cross(tangentU, tangentV).normalize();
-    const dir = dirAt(tsl.int(ix), tsl.int(iy));
-    return normal.mul(normal.dot(dir).sign());
+function decodeLeafTile(leafStorage, nodeIndex) {
+  const nodeOffset = tsl.int(nodeIndex).mul(tsl.int(4));
+  return {
+    level: leafStorage.node.element(nodeOffset).toInt(),
+    x: leafStorage.node.element(nodeOffset.add(tsl.int(1))).toFloat(),
+    y: leafStorage.node.element(nodeOffset.add(tsl.int(2))).toFloat(),
+    face: leafStorage.node.element(nodeOffset.add(tsl.int(3))).toInt()
+  };
+}
+function faceUVFromTileLocal(tile, localU, localV, baseU = tsl.float(1), baseV = tsl.float(1)) {
+  const levelScale = tsl.pow(tsl.float(2), tile.level.toFloat());
+  const nU = baseU.mul(levelScale);
+  const nV = baseV.mul(levelScale);
+  return tsl.vec2(tile.x.add(localU).div(nU), tile.y.add(localV).div(nV));
+}
+function createTileCompute(leafStorage, uniforms, projection) {
+  const baseU = tsl.float(projection.baseResolution?.u ?? 1);
+  const baseV = tsl.float(projection.baseResolution?.v ?? 1);
+  const tileLevel = tsl.Fn(([nodeIndex]) => decodeLeafTile(leafStorage, nodeIndex).level);
+  const tileFace = tsl.Fn(([nodeIndex]) => decodeLeafTile(leafStorage, nodeIndex).face);
+  const tileOriginVec2 = tsl.Fn(([nodeIndex]) => {
+    const tile = decodeLeafTile(leafStorage, nodeIndex);
+    return tsl.vec2(tile.x, tile.y);
+  });
+  const tileFaceUV = tsl.Fn(([nodeIndex, ix, iy]) => {
+    const tile = decodeLeafTile(leafStorage, nodeIndex);
+    const fInnerSegments = uniforms.uInnerTileSegments.toVar().toFloat();
+    const localU = tsl.int(ix).toFloat().sub(tsl.float(1)).div(fInnerSegments);
+    const localV = tsl.int(iy).toFloat().sub(tsl.float(1)).div(fInnerSegments);
+    return faceUVFromTileLocal(tile, localU, localV, baseU, baseV);
   });
+  const shared = {
+    tileLevel: (nodeIndex) => tileLevel(nodeIndex),
+    tileFace: (nodeIndex) => tileFace(nodeIndex),
+    tileOriginVec2: (nodeIndex) => tileOriginVec2(nodeIndex),
+    tileFaceUV: (nodeIndex, ix, iy) => tileFaceUV(nodeIndex, ix, iy)
+  };
+  const parts = projection.gpu.createTileComputeParts({ leafStorage, uniforms, shared });
+  return {
+    ...shared,
+    tileSize: parts.tileSize,
+    rootUVCompute: parts.rootUV,
+    tileVertexWorldPositionCompute: parts.tileVertexWorldPosition
+  };
+}
+function tileLocalToFieldUV(localCoord, innerSegments) {
+  const edge = tsl.float(innerSegments).add(tsl.float(FIELD_EDGE_EXTRA_TEXELS));
+  return tsl.float(localCoord).mul(tsl.float(innerSegments)).add(tsl.float(FIELD_INNER_TEXEL_OFFSET)).div(edge);
+}
+function tileLocalToFieldUVNumber(localCoord, innerSegments) {
+  const edge = innerSegments + FIELD_EDGE_EXTRA_TEXELS;
+  return (localCoord * innerSegments + FIELD_INNER_TEXEL_OFFSET) / edge;
 }
 
-const isSkirtVertex = tsl.Fn(([segments]) => {
-  const segmentsNode = typeof segments === "number" ? tsl.int(segments) : segments;
-  const vIndex = tsl.int(tsl.vertexIndex);
-  const segmentEdges = tsl.int(segmentsNode.add(3));
-  const vx = vIndex.mod(segmentEdges);
-  const vy = vIndex.div(segmentEdges);
-  const last = segmentEdges.sub(tsl.int(1));
-  return vx.equal(tsl.int(0)).or(vx.equal(last)).or(vy.equal(tsl.int(0))).or(vy.equal(last));
-});
-const isSkirtUV = tsl.Fn(([segments]) => {
-  const segmentsNode = typeof segments === "number" ? tsl.int(segments) : segments;
-  const ux = tsl.uv().x;
-  const uy = tsl.uv().y;
-  const segmentCount = segmentsNode.add(2);
-  const segmentStep = tsl.float(1).div(segmentCount);
-  const innerX = ux.greaterThan(segmentStep).and(ux.lessThan(segmentStep.oneMinus()));
-  const innerY = uy.greaterThan(segmentStep).and(uy.lessThan(segmentStep.oneMinus()));
-  return innerX.and(innerY).not();
-});
-
-function createTileElevation(terrainUniforms, terrainFieldStorage) {
-  if (!terrainFieldStorage) return tsl.float(0);
+function createTileElevation(terrainUniforms, terrainFieldStorage, tileBoundsNode) {
+  if (!terrainFieldStorage || !tileBoundsNode) return tsl.float(0);
   const innerSegs = terrainUniforms.uInnerTileSegments;
   const u = tileLocalToFieldUV(tsl.positionLocal.x.add(tsl.float(0.5)), innerSegs);
   const v = tileLocalToFieldUV(tsl.positionLocal.z.add(tsl.float(0.5)), innerSegs);
-  return sampleTerrainFieldElevation(terrainFieldStorage, u, v, tsl.int(tsl.instanceIndex)).mul(
+  const normalized = sampleTerrainFieldElevation(
+    terrainFieldStorage,
+    u,
+    v,
+    tsl.int(tsl.instanceIndex)
+  );
+  const { packMin, packMax } = loadTilePackBounds(tileBoundsNode, tsl.int(tsl.instanceIndex));
+  return denormalizeTerrainFieldElevation(normalized, packMin, packMax).mul(
     terrainUniforms.uElevationScale
   );
 }
 function loadWorldNormal(terrainUniforms, terrainFieldStorage) {
-  const nodeIndex = tsl.int(tsl.instanceIndex);
-  const edgeVertexCount = tsl.int(terrainUniforms.uInnerTileSegments.add(3));
-  const localVertexIndex = tsl.int(tsl.vertexIndex);
-  const ix = localVertexIndex.mod(edgeVertexCount);
-  const iy = localVertexIndex.div(edgeVertexCount);
-  return loadTerrainFieldNormal(terrainFieldStorage, ix, iy, nodeIndex);
+  const innerSegs = terrainUniforms.uInnerTileSegments;
+  const u = tileLocalToFieldUV(tsl.positionLocal.x.add(tsl.float(0.5)), innerSegs);
+  const v = tileLocalToFieldUV(tsl.positionLocal.z.add(tsl.float(0.5)), innerSegs);
+  const raw = sampleTerrainField(terrainFieldStorage, u, v, tsl.int(tsl.instanceIndex));
+  return tsl.vec3(raw.g, raw.b, raw.a).normalize();
 }
 function assignWorldNormal(terrainUniforms, terrainFieldStorage) {
   if (!terrainFieldStorage) return;
   tsl.normalLocal.assign(tsl.Fn(() => loadWorldNormal(terrainUniforms, terrainFieldStorage))());
 }
-function createFlatRenderVertexPosition(leafStorage, terrainUniforms, terrainFieldStorage) {
+function createFlatRenderVertexPosition(leafStorage, terrainUniforms, terrainFieldStorage, tileBoundsNode) {
   return tsl.Fn(() => {
     const tile = decodeLeafTile(leafStorage, tsl.int(tsl.instanceIndex));
     const rootSize = terrainUniforms.uRootSize.toVar();
@@ -1297,7 +1292,11 @@ function createFlatRenderVertexPosition(leafStorage, terrainUniforms, terrainFie
     const clampedZ = tsl.positionLocal.z.max(half.negate()).min(half);
     const worldX = centerX.add(clampedX.mul(size));
     const worldZ = centerZ.add(clampedZ.mul(size));
-    const yElevation = createTileElevation(terrainUniforms, terrainFieldStorage);
+    const yElevation = createTileElevation(
+      terrainUniforms,
+      terrainFieldStorage,
+      tileBoundsNode
+    );
     const skirtVertex = isSkirtVertex(terrainUniforms.uInnerTileSegments);
     const baseY = rootOrigin.y.add(yElevation);
     const skirtY = baseY.sub(terrainUniforms.uSkirtScale.toVar());
@@ -1306,7 +1305,7 @@ function createFlatRenderVertexPosition(leafStorage, terrainUniforms, terrainFie
     return tsl.vec3(worldX, worldY, worldZ);
   })();
 }
-function createCurvedRenderVertexPosition(leafStorage, terrainUniforms, terrainFieldStorage, surfacePoint, baseU = 1, baseV = 1) {
+function createCurvedRenderVertexPosition(leafStorage, terrainUniforms, terrainFieldStorage, surfacePoint, tileBoundsNode, baseU = 1, baseV = 1) {
   const fBaseU = tsl.float(baseU);
   const fBaseV = tsl.float(baseV);
   return tsl.Fn(() => {
@@ -1315,7 +1314,11 @@ function createCurvedRenderVertexPosition(leafStorage, terrainUniforms, terrainF
     const localU = tsl.positionLocal.x.max(half.negate()).min(half).add(half);
     const localV = tsl.positionLocal.z.max(half.negate()).min(half).add(half);
     const faceUV = faceUVFromTileLocal(tile, localU, localV, fBaseU, fBaseV);
-    const yElevation = createTileElevation(terrainUniforms, terrainFieldStorage);
+    const yElevation = createTileElevation(
+      terrainUniforms,
+      terrainFieldStorage,
+      tileBoundsNode
+    );
     const skirtVertex = isSkirtVertex(terrainUniforms.uInnerTileSegments);
     const displacement = tsl.select(
       skirtVertex,
@@ -1500,26 +1503,6 @@ function cpuRaycast(query, ray, config, options) {
     distance: ray.origin.distanceTo(point)
   };
 }
-function cpuRaycastBoundsOnly(ray, config, options) {
-  const bounds = getTerrainBounds(config);
-  const planeY = (config.minY + config.maxY) * 0.5;
-  const dirY = ray.direction.y;
-  if (Math.abs(dirY) < 1e-8) return null;
-  const t = (planeY - ray.origin.y) / dirY;
-  if (t < 0) return null;
-  const maxDistance = options?.maxDistance ?? Number.POSITIVE_INFINITY;
-  if (t > maxDistance) return null;
-  const point = new three.Vector3();
-  ray.at(t, point);
-  if (point.x < bounds.minX || point.x > bounds.maxX || point.z < bounds.minZ || point.z > bounds.maxZ) {
-    return null;
-  }
-  return {
-    position: point,
-    normal: new three.Vector3(0, 1, 0),
-    distance: ray.origin.distanceTo(point)
-  };
-}
 function intersectRaySphere(ray, cx, cy, cz, radius) {
   const ox = ray.origin.x - cx;
   const oy = ray.origin.y - cy;
@@ -1585,22 +1568,6 @@ function cubeSphereRaycast(query, ray, params, options) {
     distance: ray.origin.distanceTo(sample.position)
   };
 }
-function cubeSphereRaycastBoundsOnly(ray, params, options) {
-  const shell = intersectRaySphere(ray, params.centerX, params.centerY, params.centerZ, params.radius);
-  if (!shell) return null;
-  const maxDistance = options?.maxDistance ?? Number.POSITIVE_INFINITY;
-  const t = shell.t0 >= 0 ? shell.t0 : shell.t1;
-  if (t < 0 || t > maxDistance) return null;
-  const point = new three.Vector3();
-  ray.at(t, point);
-  const normal = new three.Vector3(
-    point.x - params.centerX,
-    point.y - params.centerY,
-    point.z - params.centerZ
-  ).normalize();
-  if (params.invert) normal.negate();
-  return { position: point, normal, distance: ray.origin.distanceTo(point) };
-}
 function torusSignedDistance(query, params, px, py, pz, scratchPoint, scratchParams) {
   positionToTorusParams(
     px,
@@ -1655,28 +1622,6 @@ function torusRaycast(query, ray, params, options) {
     distance: ray.origin.distanceTo(sample.position)
   };
 }
-function torusRaycastBoundsOnly(ray, params, options) {
-  const shell = intersectRaySphere(
-    ray,
-    params.centerX,
-    params.centerY,
-    params.centerZ,
-    params.outerRadius
-  );
-  if (!shell) return null;
-  const maxDistance = options?.maxDistance ?? Number.POSITIVE_INFINITY;
-  const t = shell.t0 >= 0 ? shell.t0 : shell.t1;
-  if (t < 0 || t > maxDistance) return null;
-  const point = new three.Vector3();
-  ray.at(t, point);
-  const normal = new three.Vector3(
-    point.x - params.centerX,
-    point.y - params.centerY,
-    point.z - params.centerZ
-  ).normalize();
-  if (params.invert) normal.negate();
-  return { position: point, normal, distance: ray.origin.distanceTo(point) };
-}
 
 function createTerrainQuery(cache) {
   return {
@@ -1790,7 +1735,12 @@ function createFlatProjection() {
     faceOutward: false,
     gpu: {
       renderVertexPosition(ctx) {
-        return createFlatRenderVertexPosition(ctx.leafStorage, ctx.uniforms, ctx.terrainFieldStorage);
+        return createFlatRenderVertexPosition(
+          ctx.leafStorage,
+          ctx.uniforms,
+          ctx.terrainFieldStorage,
+          ctx.tileBoundsNode
+        );
       },
       createTileComputeParts: createFlatTileComputeParts,
       createFieldNormal(ctx) {
@@ -1802,9 +1752,6 @@ function createFlatProjection() {
       }
     },
     cpu: {
-      cameraSurfaceOffset(cam, elevation) {
-        cam.y -= elevation;
-      },
       createSurfaceOps() {
         return null;
       },
@@ -1813,26 +1760,44 @@ function createFlatProjection() {
       },
       raycast(ctx) {
         const { ray, options, terrainQuery, config } = ctx;
-        if (terrainQuery) {
-          const precise = cpuRaycast(terrainQuery, ray, config, options);
-          if (precise) return precise;
-        }
-        const coarse = cpuRaycastBoundsOnly(ray, config, options);
-        if (coarse && terrainQuery) {
-          const sample = terrainQuery.sampleTerrain(coarse.position.x, coarse.position.z);
-          if (sample.valid) {
-            coarse.position.y = sample.elevation;
-            coarse.normal.copy(sample.normal);
-          }
-        }
-        return coarse;
+        if (!terrainQuery) return null;
+        return cpuRaycast(terrainQuery, ray, config, options);
       }
     }
   };
 }
 
+function boundingSphereFromPoints(px, py, pz, count, cameraOrigin, out) {
+  let sumX = 0;
+  let sumY = 0;
+  let sumZ = 0;
+  for (let i = 0; i < count; i++) {
+    sumX += px[i];
+    sumY += py[i];
+    sumZ += pz[i];
+  }
+  const cX = sumX / count;
+  const cY = sumY / count;
+  const cZ = sumZ / count;
+  let maxDistSq = 0;
+  for (let i = 0; i < count; i++) {
+    const dx = px[i] - cX;
+    const dy = py[i] - cY;
+    const dz = pz[i] - cZ;
+    const dSq = dx * dx + dy * dy + dz * dz;
+    if (dSq > maxDistSq) maxDistSq = dSq;
+  }
+  out.cx = cX - cameraOrigin.x;
+  out.cy = cY - cameraOrigin.y;
+  out.cz = cZ - cameraOrigin.z;
+  out.r = Math.sqrt(maxDistSq);
+}
+
 function createFlatTopology(cfg) {
   const halfRoot = 0.5 * cfg.rootSize;
+  const px = new Float64Array(8);
+  const py = new Float64Array(8);
+  const pz = new Float64Array(8);
   const topology = {
     spaceCount: 1,
     maxRootCount: 1,
@@ -1872,15 +1837,26 @@ function createFlatTopology(cfg) {
       const size = cfg.rootSize * scale;
       const minX = cfg.origin.x + (tile.x * size - halfRoot);
       const minZ = cfg.origin.z + (tile.y * size - halfRoot);
-      const centerX = minX + 0.5 * size;
-      const centerZ = minZ + 0.5 * size;
-      const centerY = cfg.origin.y + (elevationRange ? (elevationRange.min + elevationRange.max) * 0.5 : 0);
-      out.cx = centerX - cameraOrigin.x;
-      out.cy = centerY - cameraOrigin.y;
-      out.cz = centerZ - cameraOrigin.z;
-      const halfDiag = 0.7071067811865476 * size;
-      const vertExtent = elevationRange ? Math.max(Math.abs(elevationRange.min), Math.abs(elevationRange.max)) : 0;
-      out.r = halfDiag + vertExtent;
+      const maxX = minX + size;
+      const maxZ = minZ + size;
+      const yLo = cfg.origin.y + (elevationRange ? elevationRange.min : 0);
+      const yHi = elevationRange ? cfg.origin.y + elevationRange.max : 0;
+      let pointCount = 0;
+      for (let i = 0; i < 4; i++) {
+        const cornerX = (i & 1) === 0 ? minX : maxX;
+        const cornerZ = i < 2 ? minZ : maxZ;
+        px[pointCount] = cornerX;
+        py[pointCount] = yLo;
+        pz[pointCount] = cornerZ;
+        pointCount += 1;
+        if (elevationRange) {
+          px[pointCount] = cornerX;
+          py[pointCount] = yHi;
+          pz[pointCount] = cornerZ;
+          pointCount += 1;
+        }
+      }
+      boundingSphereFromPoints(px, py, pz, pointCount, cameraOrigin, out);
     },
     rootTiles(_cameraOrigin, out) {
       const root = out[0];
@@ -1898,6 +1874,9 @@ function createInfiniteFlatTopology(cfg) {
   const halfRoot = 0.5 * cfg.rootSize;
   const rootGridRadius = Math.max(0, Math.floor(cfg.rootGridRadius ?? 1));
   const rootWidth = rootGridRadius * 2 + 1;
+  const px = new Float64Array(8);
+  const py = new Float64Array(8);
+  const pz = new Float64Array(8);
   return {
     spaceCount: 1,
     maxRootCount: rootWidth * rootWidth,
@@ -1931,15 +1910,26 @@ function createInfiniteFlatTopology(cfg) {
       const size = cfg.rootSize * scale;
       const minX = cfg.origin.x + (tile.x * size - halfRoot);
       const minZ = cfg.origin.z + (tile.y * size - halfRoot);
-      const centerX = minX + 0.5 * size;
-      const centerZ = minZ + 0.5 * size;
-      const centerY = cfg.origin.y + (elevationRange ? (elevationRange.min + elevationRange.max) * 0.5 : 0);
-      out.cx = centerX - cameraOrigin.x;
-      out.cy = centerY - cameraOrigin.y;
-      out.cz = centerZ - cameraOrigin.z;
-      const halfDiag = 0.7071067811865476 * size;
-      const vertExtent = elevationRange ? Math.max(Math.abs(elevationRange.min), Math.abs(elevationRange.max)) : 0;
-      out.r = halfDiag + vertExtent;
+      const maxX = minX + size;
+      const maxZ = minZ + size;
+      const yLo = cfg.origin.y + (elevationRange ? elevationRange.min : 0);
+      const yHi = elevationRange ? cfg.origin.y + elevationRange.max : 0;
+      let pointCount = 0;
+      for (let i = 0; i < 4; i++) {
+        const cornerX = (i & 1) === 0 ? minX : maxX;
+        const cornerZ = i < 2 ? minZ : maxZ;
+        px[pointCount] = cornerX;
+        py[pointCount] = yLo;
+        pz[pointCount] = cornerZ;
+        pointCount += 1;
+        if (elevationRange) {
+          px[pointCount] = cornerX;
+          py[pointCount] = yHi;
+          pz[pointCount] = cornerZ;
+          pointCount += 1;
+        }
+      }
+      boundingSphereFromPoints(px, py, pz, pointCount, cameraOrigin, out);
     },
     rootTiles(cameraOrigin, out) {
       const camRootX = Math.floor((cameraOrigin.x - cfg.origin.x + halfRoot) / cfg.rootSize);
@@ -2313,9 +2303,11 @@ function packedSampleFromTileResult(params, tileResult) {
     fieldV,
     safeTileIndex
   ).toVar();
+  const { packMin, packMax } = loadTilePackBounds(params.tileBoundsNode, safeTileIndex);
+  const elevation = denormalizeTerrainFieldElevation(sampled.r, packMin, packMax);
   const normal = tsl.vec3(sampled.g, sampled.b, sampled.a);
   const valid = found.select(tsl.float(1), tsl.float(0)).toVar();
-  return tsl.vec4(sampled.r, normal.x, normal.y, normal.z).mul(valid);
+  return tsl.vec4(elevation, normal.x, normal.y, normal.z).mul(valid);
 }
 function createTerrainSampleNode(params) {
   const tileLookup = createTileIndexFromWorldPosition(
@@ -2475,7 +2467,6 @@ function createCubeSphereProjection(config) {
       const nx = dx / len;
       const ny = dy / len;
       const nz = dz / len;
-      const dirSign = invert ? -1 : 1;
       dirScratch[0] = nx;
       dirScratch[1] = ny;
       dirScratch[2] = nz;
@@ -2484,9 +2475,9 @@ function createCubeSphereProjection(config) {
       out.space = face;
       out.u = uvScratch[0];
       out.v = uvScratch[1];
-      out.dirX = nx * dirSign;
-      out.dirY = ny * dirSign;
-      out.dirZ = nz * dirSign;
+      out.dirX = nx;
+      out.dirY = ny;
+      out.dirZ = nz;
       return true;
     },
     surfacePosition(key, elevation, outVec) {
@@ -2519,7 +2510,8 @@ function createCubeSphereProjection(config) {
       let nx = tuy * tvz - tuz * tvy;
       let ny = tuz * tvx - tux * tvz;
       let nz = tux * tvy - tuy * tvx;
-      if (nx * key.dirX + ny * key.dirY + nz * key.dirZ < 0) {
+      const outwardSign = invert ? -1 : 1;
+      if ((nx * key.dirX + ny * key.dirY + nz * key.dirZ) * outwardSign < 0) {
         nx = -nx;
         ny = -ny;
         nz = -nz;
@@ -2543,7 +2535,8 @@ function createCubeSphereProjection(config) {
             const dir = cubeFaceDirection(basis, faceUV.x, faceUV.y);
             const r = invert ? ctx.uniforms.uRadius.toVar().sub(displacement) : ctx.uniforms.uRadius.toVar().add(displacement);
             return ctx.uniforms.uRootOrigin.toVar().add(dir.mul(r));
-          }
+          },
+          ctx.tileBoundsNode
         );
       },
       createTileComputeParts: createSphereTileComputeParts,
@@ -2573,19 +2566,6 @@ function createCubeSphereProjection(config) {
       augmentSampler: augmentCubeSphereSampler
     },
     cpu: {
-      cameraSurfaceOffset(cam, elevation) {
-        const dx = cam.x - center.x;
-        const dy = cam.y - center.y;
-        const dz = cam.z - center.z;
-        const len = Math.hypot(dx, dy, dz);
-        if (len > 1e-12) {
-          const sign = invert ? 1 : -1;
-          const inv = sign * elevation / len;
-          cam.x += dx * inv;
-          cam.y += dy * inv;
-          cam.z += dz * inv;
-        }
-      },
       createSurfaceOps() {
         return surfaceOps;
       },
@@ -2596,6 +2576,7 @@ function createCubeSphereProjection(config) {
         return { query, surfaceQuery, sphereQuery };
       },
       raycast(ctx) {
+        if (!ctx.sphereQuery) return null;
         const range = ctx.terrainQuery?.getGlobalElevationRange();
         const dispMax = range ? Math.max(0, range.max - center.y) : radius * 0.1;
         const outerPadding = invert ? 0 : dispMax + RAYCAST_PADDING$1;
@@ -2607,11 +2588,7 @@ function createCubeSphereProjection(config) {
           maxRadius: radius + outerPadding,
           invert
         };
-        if (ctx.sphereQuery) {
-          const precise = cubeSphereRaycast(ctx.sphereQuery, ctx.ray, params, ctx.options);
-          if (precise) return precise;
-        }
-        return cubeSphereRaycastBoundsOnly(ctx.ray, params, ctx.options);
+        return cubeSphereRaycast(ctx.sphereQuery, ctx.ray, params, ctx.options);
       }
     }
   };
@@ -2702,8 +2679,6 @@ function createCubeSphereTopology(cfg) {
     spaceCount: 6,
     maxRootCount: 6,
     projection: createCubeSphereProjection({ radius, center, invert: cfg.invert }),
-    radius,
-    center,
     neighborSameLevel(tile, dir, out) {
       const level = tile.level;
       const n = 1 << level;
@@ -2740,48 +2715,29 @@ function createCubeSphereTopology(cfg) {
       const u1 = (tile.x + 1) / n;
       const v0 = tile.y / n;
       const v1 = (tile.y + 1) / n;
-      const cornersU = [u0, u1, u0, u1];
-      const cornersV = [v0, v0, v1, v1];
-      const disps = elevationRange ? [elevationRange.min, elevationRange.max] : [0];
+      const shellLo = radius + (elevationRange ? elevationRange.min : 0);
+      const shellHi = elevationRange ? radius + elevationRange.max : 0;
       let pointCount = 0;
-      let sumX = 0;
-      let sumY = 0;
-      let sumZ = 0;
       for (let i = 0; i < 4; i++) {
-        faceUVToCube(tile.space, cornersU[i], cornersV[i], cube);
+        const u = (i & 1) === 0 ? u0 : u1;
+        const v = i < 2 ? v0 : v1;
+        faceUVToCube(tile.space, u, v, cube);
         const len = Math.hypot(cube[0], cube[1], cube[2]);
         const dirX = cube[0] / len;
         const dirY = cube[1] / len;
         const dirZ = cube[2] / len;
-        for (let di = 0; di < disps.length; di++) {
-          const shellRadius = radius + disps[di];
-          const sx = center.x + dirX * shellRadius;
-          const sy = center.y + dirY * shellRadius;
-          const sz = center.z + dirZ * shellRadius;
-          px[pointCount] = sx;
-          py[pointCount] = sy;
-          pz[pointCount] = sz;
-          sumX += sx;
-          sumY += sy;
-          sumZ += sz;
+        px[pointCount] = center.x + dirX * shellLo;
+        py[pointCount] = center.y + dirY * shellLo;
+        pz[pointCount] = center.z + dirZ * shellLo;
+        pointCount += 1;
+        if (elevationRange) {
+          px[pointCount] = center.x + dirX * shellHi;
+          py[pointCount] = center.y + dirY * shellHi;
+          pz[pointCount] = center.z + dirZ * shellHi;
           pointCount += 1;
         }
       }
-      const cX = sumX / pointCount;
-      const cY = sumY / pointCount;
-      const cZ = sumZ / pointCount;
-      let maxDistSq = 0;
-      for (let i = 0; i < pointCount; i++) {
-        const dx = px[i] - cX;
-        const dy = py[i] - cY;
-        const dz = pz[i] - cZ;
-        const dSq = dx * dx + dy * dy + dz * dz;
-        if (dSq > maxDistSq) maxDistSq = dSq;
-      }
-      out.cx = cX - cameraOrigin.x;
-      out.cy = cY - cameraOrigin.y;
-      out.cz = cZ - cameraOrigin.z;
-      out.r = Math.sqrt(maxDistSq);
+      boundingSphereFromPoints(px, py, pz, pointCount, cameraOrigin, out);
     },
     rootTiles(_cameraOrigin, out) {
       for (let s = 0; s < 6; s++) {
@@ -2928,6 +2884,7 @@ function createTorusProjection(config) {
           ctx.uniforms,
           ctx.terrainFieldStorage,
           (_tile, faceUV, displacement) => torusPosition(geometry, faceUV.x, faceUV.y, displacement),
+          ctx.tileBoundsNode,
           baseU,
           baseV
         );
@@ -2952,13 +2909,6 @@ function createTorusProjection(config) {
       }
     },
     cpu: {
-      cameraSurfaceOffset(cam, elevation) {
-        positionToTorusParams(cam.x, cam.y, cam.z, majorRadius, center, params);
-        torusOutwardNormal$1(params.u, params.v, normalScratch, invert);
-        cam.x -= normalScratch[0] * elevation;
-        cam.y -= normalScratch[1] * elevation;
-        cam.z -= normalScratch[2] * elevation;
-      },
       createSurfaceOps() {
         return surfaceOps;
       },
@@ -2968,6 +2918,7 @@ function createTorusProjection(config) {
         return { query, surfaceQuery, sphereQuery: null };
       },
       raycast(ctx) {
+        if (!ctx.surfaceQuery) return null;
         const range = ctx.terrainQuery?.getGlobalElevationRange();
         const dispMax = range ? Math.max(0, range.max - ctx.config.originY) : minorRadius * 0.5;
         const outerPadding = invert ? 0 : dispMax + RAYCAST_PADDING;
@@ -2980,11 +2931,7 @@ function createTorusProjection(config) {
           outerRadius: majorRadius + minorRadius + outerPadding,
           invert
         };
-        if (ctx.surfaceQuery) {
-          const precise = torusRaycast(ctx.surfaceQuery, ctx.ray, raycastParams, ctx.options);
-          if (precise) return precise;
-        }
-        return torusRaycastBoundsOnly(ctx.ray, raycastParams, ctx.options);
+        return torusRaycast(ctx.surfaceQuery, ctx.ray, raycastParams, ctx.options);
       }
     }
   };
@@ -3017,8 +2964,6 @@ function createTorusTopology(cfg) {
       baseU,
       baseV
     }),
-    radius: majorRadius + minorRadius,
-    center,
     neighborSameLevel(tile, dir, out) {
       const { nU, nV } = levelResolution(tile.level);
       let nx = tile.x;
@@ -3049,42 +2994,28 @@ function createTorusTopology(cfg) {
       const v0 = tile.y / nV;
       const stepU = 1 / nU;
       const stepV = 1 / nV;
-      const disps = elevationRange ? [elevationRange.min, elevationRange.max] : [0];
+      const dispLo = elevationRange ? elevationRange.min : 0;
+      const dispHi = elevationRange ? elevationRange.max : 0;
       let pointCount = 0;
-      let sumX = 0;
-      let sumY = 0;
-      let sumZ = 0;
       for (let sj = 0; sj <= 2; sj++) {
         for (let si = 0; si <= 2; si++) {
           const u = u0 + si * stepU / 2;
           const v = v0 + sj * stepV / 2;
-          for (let di = 0; di < disps.length; di++) {
-            torusUVToPoint(u, v, majorRadius, minorRadius, disps[di], center, corner, invert);
+          torusUVToPoint(u, v, majorRadius, minorRadius, dispLo, center, corner, invert);
+          px[pointCount] = corner[0];
+          py[pointCount] = corner[1];
+          pz[pointCount] = corner[2];
+          pointCount += 1;
+          if (elevationRange) {
+            torusUVToPoint(u, v, majorRadius, minorRadius, dispHi, center, corner, invert);
             px[pointCount] = corner[0];
             py[pointCount] = corner[1];
             pz[pointCount] = corner[2];
-            sumX += corner[0];
-            sumY += corner[1];
-            sumZ += corner[2];
             pointCount += 1;
           }
         }
       }
-      const cX = sumX / pointCount;
-      const cY = sumY / pointCount;
-      const cZ = sumZ / pointCount;
-      let maxDistSq = 0;
-      for (let i = 0; i < pointCount; i++) {
-        const dx = px[i] - cX;
-        const dy = py[i] - cY;
-        const dz = pz[i] - cZ;
-        const dSq = dx * dx + dy * dy + dz * dz;
-        if (dSq > maxDistSq) maxDistSq = dSq;
-      }
-      out.cx = cX - cameraOrigin.x;
-      out.cy = cY - cameraOrigin.y;
-      out.cz = cZ - cameraOrigin.z;
-      out.r = Math.sqrt(maxDistSq);
+      boundingSphereFromPoints(px, py, pz, pointCount, cameraOrigin, out);
     },
     rootTiles(_cameraOrigin, out) {
       let count = 0;
@@ -3180,8 +3111,8 @@ function buildTileElevationPyramid(pyramid, index, tileBounds, leafCount) {
     const level = index.keysLevel[slot];
     const x = index.keysX[slot];
     const y = index.keysY[slot];
-    const rawMin = tileBounds[leafIndex * 2];
-    const rawMax = tileBounds[leafIndex * 2 + 1];
+    const rawMin = tileBounds[leafIndex * TILE_BOUNDS_FLOATS_PER_TILE + TILE_BOUNDS_LOD_MIN_OFFSET];
+    const rawMax = tileBounds[leafIndex * TILE_BOUNDS_FLOATS_PER_TILE + TILE_BOUNDS_LOD_MAX_OFFSET];
     for (let ancestorLevel = level; ancestorLevel >= 0; ancestorLevel--) {
       const shift = level - ancestorLevel;
       mergeRange(
@@ -3335,8 +3266,8 @@ function createTerrainSnapshotState(maxNodes, maxLevel, totalElements) {
     backElevation: new Float32Array(totalElements),
     frontIndex: createSpatialIndex(maxNodes),
     backIndex: createSpatialIndex(maxNodes),
-    frontTileBounds: new Float32Array(maxNodes * 2),
-    backTileBounds: new Float32Array(maxNodes * 2),
+    frontTileBounds: new Float32Array(maxNodes * TILE_BOUNDS_FLOATS_PER_TILE),
+    backTileBounds: new Float32Array(maxNodes * TILE_BOUNDS_FLOATS_PER_TILE),
     frontLeafCount: 0,
     globalRange: null,
     hasSnapshot: false,
@@ -3377,7 +3308,7 @@ function triggerSnapshotReadback(state, renderer, attribute, spatialIndex, bound
     let boundsValid = activeLeafCount === 0;
     if (boundsFilled) {
       for (let i = 0; i < activeLeafCount; i += 1) {
-        if ((state.backTileBounds[i * 2 + 1] ?? 0) !== 0) {
+        if ((state.backTileBounds[i * TILE_BOUNDS_FLOATS_PER_TILE + TILE_BOUNDS_LOD_MAX_OFFSET] ?? 0) !== 0) {
           boundsValid = true;
           break;
         }
@@ -3399,8 +3330,8 @@ function triggerSnapshotReadback(state, renderer, attribute, spatialIndex, bound
       let gMin = Infinity;
       let gMax = -Infinity;
       for (let i = 0; i < activeLeafCount; i++) {
-        const rawMin = state.frontTileBounds[i * 2];
-        const rawMax = state.frontTileBounds[i * 2 + 1];
+        const rawMin = state.frontTileBounds[i * TILE_BOUNDS_FLOATS_PER_TILE + TILE_BOUNDS_LOD_MIN_OFFSET];
+        const rawMax = state.frontTileBounds[i * TILE_BOUNDS_FLOATS_PER_TILE + TILE_BOUNDS_LOD_MAX_OFFSET];
         const a = originY + rawMin * elevationScale;
         const b = originY + rawMax * elevationScale;
         gMin = Math.min(gMin, a, b);
@@ -3436,7 +3367,7 @@ function triggerSnapshotReadback(state, renderer, attribute, spatialIndex, bound
           boundsAttribute,
           state.boundsReadback,
           state.backTileBounds,
-          activeLeafCount * 2,
+          activeLeafCount * TILE_BOUNDS_FLOATS_PER_TILE,
           "terrainBoundsReadback"
         );
       }
@@ -3455,7 +3386,9 @@ function triggerSnapshotReadback(state, renderer, attribute, spatialIndex, bound
     if (boundsResult) {
       const rawBounds = new Float32Array(boundsResult);
       state.backTileBounds.fill(0);
-      state.backTileBounds.set(rawBounds.subarray(0, activeLeafCount * 2));
+      state.backTileBounds.set(
+        rawBounds.subarray(0, activeLeafCount * TILE_BOUNDS_FLOATS_PER_TILE)
+      );
       boundsFilled = true;
     }
     applySnapshot(boundsFilled);
@@ -3569,8 +3502,8 @@ function createCpuTerrainCache(maxNodes, initialConfig, surfaceOps) {
   };
   const tileBoundsFromLookup = (lookup, elevationBase) => {
     if (!lookup.found || lookup.leafIndex >= state.frontLeafCount) return null;
-    const rawMin = state.frontTileBounds[lookup.leafIndex * 2];
-    const rawMax = state.frontTileBounds[lookup.leafIndex * 2 + 1];
+    const rawMin = state.frontTileBounds[lookup.leafIndex * TILE_BOUNDS_FLOATS_PER_TILE + TILE_BOUNDS_LOD_MIN_OFFSET];
+    const rawMax = state.frontTileBounds[lookup.leafIndex * TILE_BOUNDS_FLOATS_PER_TILE + TILE_BOUNDS_LOD_MAX_OFFSET];
     const a = elevationBase + rawMin * config.elevationScale;
     const b = elevationBase + rawMax * config.elevationScale;
     return {
@@ -3648,6 +3581,9 @@ function createCpuTerrainCache(maxNodes, initialConfig, surfaceOps) {
     get hasSurface() {
       return surfaceOps !== null;
     },
+    setSurfaceOps(nextSurfaceOps) {
+      surfaceOps = nextSurfaceOps;
+    },
     updateConfig(nextConfig) {
       config = nextConfig;
       shape.edgeVertexCount = config.innerTileSegments + 3;
@@ -3795,72 +3731,132 @@ function createCpuTerrainCache(maxNodes, initialConfig, surfaceOps) {
       return lookupTileElevationRange(state.elevationPyramid, space, level, x, y, out);
     }
   };
-  return api;
+  return api;
+}
+
+const createElevation = (tile, uniforms, elevationFn) => {
+  return function perVertexElevation(nodeIndex, localCoordinates) {
+    const ix = tsl.int(localCoordinates.x);
+    const iy = tsl.int(localCoordinates.y);
+    const edgeVertexCount = uniforms.uInnerTileSegments.toVar().add(tsl.int(3));
+    const tileUV = localCoordinates.toFloat().div(edgeVertexCount.toFloat());
+    const rootUV = tile.rootUVCompute(nodeIndex, ix, iy);
+    const worldPosition = tile.tileVertexWorldPositionCompute(nodeIndex, ix, iy).setName("worldPositionWithSkirt");
+    const rootSize = uniforms.uRootSize.toVar();
+    return elevationFn({
+      worldPosition,
+      rootSize,
+      rootUV,
+      tileOriginVec2: tile.tileOriginVec2(nodeIndex),
+      tileSize: tile.tileSize(nodeIndex),
+      tileLevel: tile.tileLevel(nodeIndex),
+      nodeIndex: tsl.int(nodeIndex),
+      tileUV
+    });
+  };
+};
+
+function createTerrainUniforms(params) {
+  const sanitizedId = params.instanceId?.replace(/-/g, "_");
+  const suffix = sanitizedId ? `_${sanitizedId}` : "";
+  const uRootOrigin = tsl.uniform(
+    new webgpu.Vector3(params.rootOrigin.x, params.rootOrigin.y, params.rootOrigin.z)
+  ).setName(`uRootOrigin${suffix}`);
+  const uRootSize = tsl.uniform(tsl.float(params.rootSize)).setName(`uRootSize${suffix}`);
+  const uInnerTileSegments = tsl.uniform(tsl.int(params.innerTileSegments)).setName(
+    `uInnerTileSegments${suffix}`
+  );
+  const uSkirtScale = tsl.uniform(tsl.float(params.skirtScale)).setName(`uSkirtScale${suffix}`);
+  const uElevationScale = tsl.uniform(tsl.float(params.elevationScale)).setName(`uElevationScale${suffix}`);
+  const uRadius = tsl.uniform(tsl.float(params.radius)).setName(`uRadius${suffix}`);
+  return {
+    uRootOrigin,
+    uRootSize,
+    uInnerTileSegments,
+    uSkirtScale,
+    uElevationScale,
+    uRadius
+  };
 }
 
-const WGSIZE = 64;
-function buildReductionKernel(elevationFieldNode, boundsNode, verticesPerNode) {
-  const elemsPerThread = Math.ceil(verticesPerNode / WGSIZE);
-  return tsl.Fn(() => {
-    const sharedMin = tsl.workgroupArray("float", WGSIZE);
-    const sharedMax = tsl.workgroupArray("float", WGSIZE);
-    const tid = tsl.int(tsl.localId.x);
-    const tileIdx = tsl.int(tsl.workgroupId.z);
-    const baseOffset = tileIdx.mul(tsl.int(verticesPerNode));
-    const start = tid.mul(tsl.int(elemsPerThread));
-    const end = tsl.min(start.add(tsl.int(elemsPerThread)), tsl.int(verticesPerNode));
-    const localMin = tsl.float(1e10).toVar("localMin");
-    const localMax = tsl.float(-1e10).toVar("localMax");
-    tsl.Loop({ start, end, type: "int", condition: "<" }, ({ i }) => {
-      const h = elevationFieldNode.element(baseOffset.add(i));
-      localMin.assign(tsl.min(localMin, h));
-      localMax.assign(tsl.max(localMax, h));
-    });
-    sharedMin.element(tid).assign(localMin);
-    sharedMax.element(tid).assign(localMax);
-    tsl.workgroupBarrier();
-    tsl.If(tid.equal(tsl.int(0)), () => {
-      const finalMin = tsl.float(1e10).toVar("finalMin");
-      const finalMax = tsl.float(-1e10).toVar("finalMax");
-      tsl.Loop(WGSIZE, ({ i }) => {
-        finalMin.assign(tsl.min(finalMin, sharedMin.element(i)));
-        finalMax.assign(tsl.max(finalMax, sharedMax.element(i)));
-      });
-      const outIdx = tileIdx.mul(tsl.int(2));
-      boundsNode.element(outIdx).assign(finalMin);
-      boundsNode.element(outIdx.add(tsl.int(1))).assign(finalMax);
-    });
-  })().computeKernel([WGSIZE, 1, 1]);
-}
-const tileBoundsContextTask = work.task((get, work) => {
-  const elevationFieldContext = get(createElevationFieldContextTask);
-  const maxNodesValue = get(maxNodes);
+const instanceIdTask = work.task(() => crypto.randomUUID()).displayName("instanceIdTask").cache("once");
+
+const scratchVector3 = new three.Vector3();
+const createUniformsTask = work.task((get, work) => {
+  const uniformParams = {
+    rootOrigin: get(origin),
+    rootSize: get(rootSize),
+    innerTileSegments: get(innerTileSegments),
+    skirtScale: get(skirtScale),
+    elevationScale: get(elevationScale),
+    radius: get(radius),
+    instanceId: get(instanceIdTask)
+  };
+  return work(() => createTerrainUniforms(uniformParams));
+}).displayName("createUniformsTask").cache("once");
+const updateUniformsTask = work.task((get, work) => {
+  const terrainUniformsContext = get(createUniformsTask);
+  const rootSizeVal = get(rootSize);
+  const rootOrigin = get(origin);
+  const innerTileSegmentsVal = get(innerTileSegments);
+  const skirtScaleVal = get(skirtScale);
+  const elevationScaleVal = get(elevationScale);
+  const radiusVal = get(radius);
+  return work(() => {
+    terrainUniformsContext.uRootSize.value = rootSizeVal;
+    terrainUniformsContext.uRootOrigin.value = scratchVector3.set(
+      rootOrigin.x,
+      rootOrigin.y,
+      rootOrigin.z
+    );
+    terrainUniformsContext.uInnerTileSegments.value = innerTileSegmentsVal;
+    terrainUniformsContext.uSkirtScale.value = skirtScaleVal;
+    terrainUniformsContext.uElevationScale.value = elevationScaleVal;
+    terrainUniformsContext.uRadius.value = radiusVal;
+    return terrainUniformsContext;
+  });
+}).displayName("updateUniformsTask");
+
+const createElevationFieldContextTask = work.task((get, work) => {
   const edgeVertexCount = get(innerTileSegments) + 3;
+  const verticesPerNode = edgeVertexCount * edgeVertexCount;
+  const totalElements = get(maxNodes) * verticesPerNode;
   return work(() => {
-    const data = new Float32Array(maxNodesValue * 2);
+    const data = new Float32Array(totalElements);
     const attribute = new webgpu.StorageBufferAttribute(data, 1);
-    attribute.name = "tileBounds";
-    const node = tsl.storage(attribute, "float", maxNodesValue * 2).setName(
-      "tileBounds"
-    );
-    const verticesPerNode = edgeVertexCount * edgeVertexCount;
-    const kernel = buildReductionKernel(elevationFieldContext.node, node, verticesPerNode);
-    return { data, attribute, node, kernel };
+    attribute.name = "elevationField";
+    const node = tsl.storage(attribute, "float", totalElements).setName("elevationField");
+    return {
+      data,
+      attribute,
+      node
+    };
   });
-}).displayName("tileBoundsContextTask");
-const tileBoundsReductionTask = work.task(
-  (get, work, { resources }) => {
-    get(executeComputeTask);
-    const boundsContext = get(tileBoundsContextTask);
-    const leafState = get(leafGpuBufferTask);
-    return work(() => {
-      if (resources?.renderer && leafState.count > 0) {
-        resources.renderer.compute(boundsContext.kernel, [1, 1, leafState.count]);
+}).displayName("createElevationFieldContextTask");
+const tileNodesTask = work.task((get, work) => {
+  const leafStorage = get(leafStorageTask);
+  const uniforms = get(updateUniformsTask);
+  const topology = get(topologyTask);
+  return work(() => {
+    return createTileCompute(leafStorage, uniforms, topology.projection);
+  });
+}).displayName("tileNodesTask");
+const elevationFieldStageTask = work.task((get, work) => {
+  const tile = get(tileNodesTask);
+  const uniforms = get(updateUniformsTask);
+  const elevationFieldContext = get(createElevationFieldContextTask);
+  const userElevationFn = get(elevationFn);
+  return work(() => {
+    const heightFn = createElevationFunction(userElevationFn);
+    const heightWriteFn = createElevation(tile, uniforms, heightFn);
+    return [
+      (nodeIndex, globalVertexIndex, _uv, localCoordinates) => {
+        const height = heightWriteFn(nodeIndex, localCoordinates);
+        elevationFieldContext.node.element(globalVertexIndex).assign(height);
       }
-      return boundsContext;
-    });
-  }
-).displayName("tileBoundsReductionTask").lane("gpu");
+    ];
+  });
+}).displayName("elevationFieldStageTask");
 
 const terrainQueryTask = work.task((get, work) => {
   const maxNodesValue = get(maxNodes);
@@ -3874,6 +3870,7 @@ const terrainQueryTask = work.task((get, work) => {
   const projection = topologyValue.projection;
   return work((prev) => {
     const shapeKey = `${maxNodesValue}:${innerTileSegmentsValue}:${projection.kind}`;
+    const resolvedRadius = projection.radius ?? radiusValue;
     const configValues = {
       rootSize: rootSizeValue,
       originX: originValue.x,
@@ -3882,7 +3879,7 @@ const terrainQueryTask = work.task((get, work) => {
       innerTileSegments: innerTileSegmentsValue,
       elevationScale: elevationScaleValue,
       maxLevel: maxLevelValue,
-      radius: topologyValue.radius ?? radiusValue,
+      radius: resolvedRadius,
       baseU: projection.baseResolution?.u ?? 1,
       baseV: projection.baseResolution?.v ?? 1
     };
@@ -3897,9 +3894,15 @@ const terrainQueryTask = work.task((get, work) => {
       query = runtime.query;
       surfaceQuery = runtime.surfaceQuery;
       sphereQuery = runtime.sphereQuery;
+    } else if (prev?.projection !== projection) {
+      cache.setSurfaceOps(projection.cpu.createSurfaceOps());
+      const runtime = projection.cpu.createRuntimeQueries(cache);
+      query = runtime.query;
+      surfaceQuery = runtime.surfaceQuery;
+      sphereQuery = runtime.sphereQuery;
     }
     cache.updateConfig(configValues);
-    return { cache, query, surfaceQuery, sphereQuery, shapeKey };
+    return { cache, query, surfaceQuery, sphereQuery, shapeKey, projection };
   });
 }).displayName("terrainQueryTask");
 const terrainReadbackTask = work.task(
@@ -3946,27 +3949,19 @@ const quadtreeConfigTask = work.task((get, work) => {
 const quadtreeUpdateTask = work.task((get, work) => {
   const quadtreeConfig = get(quadtreeConfigTask);
   const quadtreeUpdateConfig = get(quadtreeUpdate);
-  const { query: terrainQuery, surfaceQuery, cache } = get(terrainQueryTask);
+  const { cache } = get(terrainQueryTask);
   const elevationScaleValue = get(elevationScale);
   let outLeaves = void 0;
-  const cameraPosition = new three.Vector3();
   const elevationRangeScratch = { min: 0, max: 0 };
-  return work(() => {
-    const cam = quadtreeUpdateConfig.cameraOrigin;
-    if (surfaceQuery) {
-      cameraPosition.set(cam.x, cam.y, cam.z);
-      quadtreeUpdateConfig.elevationAtCameraXZ = surfaceQuery.getElevationByPosition(cameraPosition) ?? 0;
-    } else {
-      quadtreeUpdateConfig.elevationAtCameraXZ = terrainQuery.getElevation(cam.x, cam.z) ?? 0;
+  quadtreeUpdateConfig.tileElevationRange = (tile, out) => {
+    if (!cache.getTileElevationRange(tile.space, tile.level, tile.x, tile.y, elevationRangeScratch)) {
+      return false;
     }
-    quadtreeUpdateConfig.tileElevationRange = (space, level, x, y, out) => {
-      if (!cache.getTileElevationRange(space, level, x, y, elevationRangeScratch)) {
-        return false;
-      }
-      out.min = elevationRangeScratch.min * elevationScaleValue;
-      out.max = elevationRangeScratch.max * elevationScaleValue;
-      return true;
-    };
+    out.min = elevationRangeScratch.min * elevationScaleValue;
+    out.max = elevationRangeScratch.max * elevationScaleValue;
+    return true;
+  };
+  return work(() => {
     outLeaves = update(
       quadtreeConfig.state,
       quadtreeConfig.topology,
@@ -4004,107 +3999,88 @@ const leafGpuBufferTask = work.task((get, work) => {
   });
 }).displayName("leafGpuBufferTask");
 
-function createTerrainUniforms(params) {
-  const sanitizedId = params.instanceId?.replace(/-/g, "_");
-  const suffix = sanitizedId ? `_${sanitizedId}` : "";
-  const uRootOrigin = tsl.uniform(
-    new webgpu.Vector3(params.rootOrigin.x, params.rootOrigin.y, params.rootOrigin.z)
-  ).setName(`uRootOrigin${suffix}`);
-  const uRootSize = tsl.uniform(tsl.float(params.rootSize)).setName(`uRootSize${suffix}`);
-  const uInnerTileSegments = tsl.uniform(tsl.int(params.innerTileSegments)).setName(
-    `uInnerTileSegments${suffix}`
-  );
-  const uSkirtScale = tsl.uniform(tsl.float(params.skirtScale)).setName(`uSkirtScale${suffix}`);
-  const uElevationScale = tsl.uniform(tsl.float(params.elevationScale)).setName(`uElevationScale${suffix}`);
-  const uRadius = tsl.uniform(tsl.float(params.radius)).setName(`uRadius${suffix}`);
-  return {
-    uRootOrigin,
-    uRootSize,
-    uInnerTileSegments,
-    uSkirtScale,
-    uElevationScale,
-    uRadius
-  };
+const WGSIZE = 64;
+function buildReductionKernel(elevationFieldNode, boundsNode, verticesPerNode, edgeVertexCount) {
+  const elemsPerThread = Math.ceil(verticesPerNode / WGSIZE);
+  return tsl.Fn(() => {
+    const sharedLodMin = tsl.workgroupArray("float", WGSIZE);
+    const sharedLodMax = tsl.workgroupArray("float", WGSIZE);
+    const sharedPackMin = tsl.workgroupArray("float", WGSIZE);
+    const sharedPackMax = tsl.workgroupArray("float", WGSIZE);
+    const tid = tsl.int(tsl.localId.x);
+    const tileIdx = tsl.int(tsl.workgroupId.z);
+    const baseOffset = tileIdx.mul(tsl.int(verticesPerNode));
+    const start = tid.mul(tsl.int(elemsPerThread));
+    const end = tsl.min(start.add(tsl.int(elemsPerThread)), tsl.int(verticesPerNode));
+    const localLodMin = tsl.float(1e10).toVar("localLodMin");
+    const localLodMax = tsl.float(-1e10).toVar("localLodMax");
+    const localPackMin = tsl.float(1e10).toVar("localPackMin");
+    const localPackMax = tsl.float(-1e10).toVar("localPackMax");
+    const edge = tsl.int(edgeVertexCount);
+    const lastEdge = tsl.int(edgeVertexCount - 1);
+    tsl.Loop({ start, end, type: "int", condition: "<" }, ({ i }) => {
+      const ix = tsl.int(i).mod(edge);
+      const iy = tsl.int(i).div(edge);
+      const isSkirt = ix.equal(tsl.int(0)).or(ix.equal(lastEdge)).or(iy.equal(tsl.int(0))).or(iy.equal(lastEdge));
+      const h = elevationFieldNode.element(baseOffset.add(i));
+      localPackMin.assign(tsl.min(localPackMin, h));
+      localPackMax.assign(tsl.max(localPackMax, h));
+      tsl.If(isSkirt.not(), () => {
+        localLodMin.assign(tsl.min(localLodMin, h));
+        localLodMax.assign(tsl.max(localLodMax, h));
+      });
+    });
+    sharedLodMin.element(tid).assign(localLodMin);
+    sharedLodMax.element(tid).assign(localLodMax);
+    sharedPackMin.element(tid).assign(localPackMin);
+    sharedPackMax.element(tid).assign(localPackMax);
+    tsl.workgroupBarrier();
+    tsl.If(tid.equal(tsl.int(0)), () => {
+      const finalLodMin = tsl.float(1e10).toVar("finalLodMin");
+      const finalLodMax = tsl.float(-1e10).toVar("finalLodMax");
+      const finalPackMin = tsl.float(1e10).toVar("finalPackMin");
+      const finalPackMax = tsl.float(-1e10).toVar("finalPackMax");
+      tsl.Loop(WGSIZE, ({ i }) => {
+        finalLodMin.assign(tsl.min(finalLodMin, sharedLodMin.element(i)));
+        finalLodMax.assign(tsl.max(finalLodMax, sharedLodMax.element(i)));
+        finalPackMin.assign(tsl.min(finalPackMin, sharedPackMin.element(i)));
+        finalPackMax.assign(tsl.max(finalPackMax, sharedPackMax.element(i)));
+      });
+      const outIdx = tileIdx.mul(tsl.int(TILE_BOUNDS_FLOATS_PER_TILE));
+      boundsNode.element(outIdx.add(tsl.int(TILE_BOUNDS_LOD_MIN_OFFSET))).assign(finalLodMin);
+      boundsNode.element(outIdx.add(tsl.int(TILE_BOUNDS_LOD_MAX_OFFSET))).assign(finalLodMax);
+      boundsNode.element(outIdx.add(tsl.int(TILE_BOUNDS_PACK_MIN_OFFSET))).assign(finalPackMin);
+      boundsNode.element(outIdx.add(tsl.int(TILE_BOUNDS_PACK_MAX_OFFSET))).assign(finalPackMax);
+    });
+  })().computeKernel([WGSIZE, 1, 1]);
 }
-
-const instanceIdTask = work.task(() => crypto.randomUUID()).displayName("instanceIdTask").cache("once");
-
-const scratchVector3 = new three.Vector3();
-const createUniformsTask = work.task((get, work) => {
-  const uniformParams = {
-    rootOrigin: get(origin),
-    rootSize: get(rootSize),
-    innerTileSegments: get(innerTileSegments),
-    skirtScale: get(skirtScale),
-    elevationScale: get(elevationScale),
-    radius: get(radius),
-    instanceId: get(instanceIdTask)
-  };
-  return work(() => createTerrainUniforms(uniformParams));
-}).displayName("createUniformsTask").cache("once");
-const updateUniformsTask = work.task((get, work) => {
-  const terrainUniformsContext = get(createUniformsTask);
-  const rootSizeVal = get(rootSize);
-  const rootOrigin = get(origin);
-  const innerTileSegmentsVal = get(innerTileSegments);
-  const skirtScaleVal = get(skirtScale);
-  const elevationScaleVal = get(elevationScale);
-  const radiusVal = get(radius);
-  return work(() => {
-    terrainUniformsContext.uRootSize.value = rootSizeVal;
-    terrainUniformsContext.uRootOrigin.value = scratchVector3.set(
-      rootOrigin.x,
-      rootOrigin.y,
-      rootOrigin.z
-    );
-    terrainUniformsContext.uInnerTileSegments.value = innerTileSegmentsVal;
-    terrainUniformsContext.uSkirtScale.value = skirtScaleVal;
-    terrainUniformsContext.uElevationScale.value = elevationScaleVal;
-    terrainUniformsContext.uRadius.value = radiusVal;
-    return terrainUniformsContext;
-  });
-}).displayName("updateUniformsTask");
-
-const createElevationFieldContextTask = work.task((get, work) => {
+function runTileBoundsReduction(renderer, boundsContext, leafCount) {
+  if (leafCount > 0) {
+    renderer.compute(boundsContext.kernel, [1, 1, leafCount]);
+  }
+}
+const tileBoundsContextTask = work.task((get, work) => {
+  const elevationFieldContext = get(createElevationFieldContextTask);
+  const maxNodesValue = get(maxNodes);
   const edgeVertexCount = get(innerTileSegments) + 3;
-  const verticesPerNode = edgeVertexCount * edgeVertexCount;
-  const totalElements = get(maxNodes) * verticesPerNode;
   return work(() => {
-    const data = new Float32Array(totalElements);
+    const floatCount = maxNodesValue * TILE_BOUNDS_FLOATS_PER_TILE;
+    const data = new Float32Array(floatCount);
     const attribute = new webgpu.StorageBufferAttribute(data, 1);
-    attribute.name = "elevationField";
-    const node = tsl.storage(attribute, "float", totalElements).setName("elevationField");
-    return {
-      data,
-      attribute,
-      node
-    };
-  });
-}).displayName("createElevationFieldContextTask");
-const tileNodesTask = work.task((get, work) => {
-  const leafStorage = get(leafStorageTask);
-  const uniforms = get(updateUniformsTask);
-  const topology = get(topologyTask);
-  return work(() => {
-    return createTileCompute(leafStorage, uniforms, topology.projection);
-  });
-}).displayName("tileNodesTask");
-const elevationFieldStageTask = work.task((get, work) => {
-  const tile = get(tileNodesTask);
-  const uniforms = get(updateUniformsTask);
-  const elevationFieldContext = get(createElevationFieldContextTask);
-  const userElevationFn = get(elevationFn);
-  return work(() => {
-    const heightFn = createElevationFunction(userElevationFn);
-    const heightWriteFn = createElevation(tile, uniforms, heightFn);
-    return [
-      (nodeIndex, globalVertexIndex, _uv, localCoordinates) => {
-        const height = heightWriteFn(nodeIndex, localCoordinates);
-        elevationFieldContext.node.element(globalVertexIndex).assign(height);
-      }
-    ];
+    attribute.name = "tileBounds";
+    const node = tsl.storage(attribute, "float", floatCount).setName(
+      "tileBounds"
+    );
+    const verticesPerNode = edgeVertexCount * edgeVertexCount;
+    const kernel = buildReductionKernel(
+      elevationFieldContext.node,
+      node,
+      verticesPerNode,
+      edgeVertexCount
+    );
+    return { data, attribute, node, kernel };
   });
-}).displayName("elevationFieldStageTask");
+}).displayName("tileBoundsContextTask");
 
 const createTerrainFieldTextureTask = work.task(
   (get, work, { resources }) => {
@@ -4129,6 +4105,7 @@ const terrainFieldStageTask = work.task((get, work) => {
   const tile = get(tileNodesTask);
   const uniforms = get(updateUniformsTask);
   const topology = get(topologyTask);
+  const boundsContext = get(tileBoundsContextTask);
   return work(() => {
     const computeNormal = topology.projection.gpu.createFieldNormal({
       elevationFieldNode: elevationFieldContext.node,
@@ -4143,12 +4120,13 @@ const terrainFieldStageTask = work.task((get, work) => {
         const iy = tsl.int(localCoordinates.y);
         const height = elevationFieldContext.node.element(globalVertexIndex);
         const normal = computeNormal(nodeIndex, ix, iy);
+        const { packMin, packMax } = loadTilePackBounds(boundsContext.node, nodeIndex);
         storeTerrainField(
           terrainFieldStorage,
           ix,
           iy,
           nodeIndex,
-          packTerrainFieldSample(height, normal)
+          packNormalizedTerrainFieldSample(height, normal, packMin, packMax)
         );
       }
     ];
@@ -4160,23 +4138,28 @@ function createComputePipelineTasks(leafStageTask) {
   const compile = work.task((get, work) => {
     const pipeline = get(leafStageTask);
     const edgeVertexCount = get(innerTileSegments) + 3;
+    const boundsContext = get(tileBoundsContextTask);
     return work(
       () => compileComputePipeline(pipeline, edgeVertexCount, {
-        })
+        midPipelineExecute: (renderer, instanceCount) => {
+          runTileBoundsReduction(renderer, boundsContext, instanceCount);
+        }
+      })
     );
   }).displayName("compileComputeTask");
-  const execute = work.task(
-    (get, work, { resources }) => {
-      const { execute: run } = get(compile);
-      const leafState = get(leafGpuBufferTask);
-      return work(
-        () => resources?.renderer ? run(resources.renderer, leafState.count) : () => {
-        }
-      );
-    }
-  ).displayName("executeComputeTask").lane("gpu");
+  const execute = work.task((get, work, { resources }) => {
+    const { execute: run } = get(compile);
+    const leafState = get(leafGpuBufferTask);
+    return work(() => resources?.renderer ? run(resources.renderer, leafState.count) : () => {
+    });
+  }).displayName("executeComputeTask").lane("gpu");
   return { compile, execute };
 }
+const tileBoundsReductionTask = work.task((get, work) => {
+  get(executeComputeTask);
+  const boundsContext = get(tileBoundsContextTask);
+  return work(() => boundsContext);
+}).displayName("tileBoundsReductionTask").lane("gpu");
 
 const gpuSpatialIndexStorageTask = work.task((get, work) => {
   const maxNodesValue = get(maxNodes);
@@ -4194,6 +4177,7 @@ const gpuSpatialIndexUploadTask = work.task((get, work) => {
 
 const createTerrainSamplerTask = work.task((get, work) => {
   const terrainFieldStorage = get(createTerrainFieldTextureTask);
+  const tileBoundsContext = get(tileBoundsContextTask);
   const spatialIndex = get(gpuSpatialIndexStorageTask);
   const uniforms = get(updateUniformsTask);
   const elevationCallback = get(elevationFn);
@@ -4202,6 +4186,7 @@ const createTerrainSamplerTask = work.task((get, work) => {
   return work(
     () => createTerrainSampler({
       terrainFieldStorage,
+      tileBoundsNode: tileBoundsContext.node,
       spatialIndex,
       uniforms,
       elevationCallback,
@@ -4215,12 +4200,14 @@ const positionNodeTask = work.task((get, work) => {
   const leafStorage = get(leafStorageTask);
   const terrainUniforms = get(updateUniformsTask);
   const terrainFieldStorage = get(createTerrainFieldTextureTask);
+  const tileBoundsContext = get(tileBoundsContextTask);
   const topology = get(topologyTask);
   return work(
     () => topology.projection.gpu.renderVertexPosition({
       leafStorage,
       uniforms: terrainUniforms,
-      terrainFieldStorage
+      terrainFieldStorage,
+      tileBoundsNode: tileBoundsContext.node
     })
   );
 }).displayName("positionNodeTask");
@@ -4341,6 +4328,17 @@ function terrainGraph() {
   return g;
 }
 
+const decodeUint16RG = tsl.Fn(
+  ([sample]) => sample.r.mul(tsl.float(256)).add(sample.g).div(tsl.float(257))
+);
+const sampleHeightmapMeters = tsl.Fn(
+  ([heightmapTexture, uv, minM, _maxM, rangeM]) => {
+    const sample = tsl.texture(heightmapTexture, uv);
+    const normalized = decodeUint16RG(sample);
+    return minM.add(normalized.mul(rangeM));
+  }
+);
+
 const textureSpaceToVectorSpace = tsl.Fn(([value]) => {
   return tsl.remap(value, tsl.float(0), tsl.float(1), tsl.float(-1), tsl.float(1));
 });
@@ -4398,6 +4396,12 @@ exports.AtlasBackend = AtlasBackend;
 exports.CUBE_FACES = CUBE_FACES;
 exports.CUBE_FACE_COUNT = CUBE_FACE_COUNT;
 exports.Dir = Dir;
+exports.TERRAIN_FIELD_PACK_EPSILON = TERRAIN_FIELD_PACK_EPSILON;
+exports.TILE_BOUNDS_FLOATS_PER_TILE = TILE_BOUNDS_FLOATS_PER_TILE;
+exports.TILE_BOUNDS_LOD_MAX_OFFSET = TILE_BOUNDS_LOD_MAX_OFFSET;
+exports.TILE_BOUNDS_LOD_MIN_OFFSET = TILE_BOUNDS_LOD_MIN_OFFSET;
+exports.TILE_BOUNDS_PACK_MAX_OFFSET = TILE_BOUNDS_PACK_MAX_OFFSET;
+exports.TILE_BOUNDS_PACK_MIN_OFFSET = TILE_BOUNDS_PACK_MIN_OFFSET;
 exports.TerrainGeometry = TerrainGeometry;
 exports.TerrainMesh = TerrainMesh;
 exports.U32_EMPTY = U32_EMPTY;
@@ -4434,6 +4438,8 @@ exports.cubeFaceDirection = cubeFaceDirection;
 exports.cubeFaceFromDirection = cubeFaceFromDirection;
 exports.cubeFacePoint = cubeFacePoint;
 exports.cubeFaceUVFromDirection = cubeFaceUVFromDirection;
+exports.decodeUint16RG = decodeUint16RG;
+exports.denormalizeTerrainFieldElevation = denormalizeTerrainFieldElevation;
 exports.deriveNormalZ = deriveNormalZ;
 exports.directionToFace = directionToFace;
 exports.directionToFaceUV = directionToFaceUV;
@@ -4456,9 +4462,11 @@ exports.leafStorageTask = leafStorageTask;
 exports.loadTerrainField = loadTerrainField;
 exports.loadTerrainFieldElevation = loadTerrainFieldElevation;
 exports.loadTerrainFieldNormal = loadTerrainFieldNormal;
+exports.loadTilePackBounds = loadTilePackBounds;
 exports.maxLevel = maxLevel;
 exports.maxNodes = maxNodes;
 exports.origin = origin;
+exports.packNormalizedTerrainFieldSample = packNormalizedTerrainFieldSample;
 exports.packTerrainFieldSample = packTerrainFieldSample;
 exports.positionNodeTask = positionNodeTask;
 exports.positionToTorusParams = positionToTorusParams;
@@ -4469,6 +4477,8 @@ exports.radius = radius;
 exports.resetLeafSet = resetLeafSet;
 exports.resetSeamTable = resetSeamTable;
 exports.rootSize = rootSize;
+exports.runTileBoundsReduction = runTileBoundsReduction;
+exports.sampleHeightmapMeters = sampleHeightmapMeters;
 exports.sampleTerrainField = sampleTerrainField;
 exports.sampleTerrainFieldElevation = sampleTerrainFieldElevation;
 exports.skirtScale = skirtScale;
@@ -4483,6 +4493,8 @@ exports.terrainRaycastTask = terrainRaycastTask;
 exports.terrainReadbackTask = terrainReadbackTask;
 exports.terrainTasks = terrainTasks;
 exports.textureSpaceToVectorSpace = textureSpaceToVectorSpace;
+exports.tileBoundsContextTask = tileBoundsContextTask;
+exports.tileBoundsReductionTask = tileBoundsReductionTask;
 exports.tileNodesTask = tileNodesTask;
 exports.topology = topology;
 exports.topologyTask = topologyTask;