@hello-terrain/three 0.0.0-alpha.13 → 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,283 +422,16 @@ 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]);
+    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 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;
-}
-
 function createLeafStorage(maxNodes) {
   const data = new Int32Array(maxNodes * 4);
   const attribute = new webgpu.StorageBufferAttribute(data, 4);
@@ -1178,97 +912,373 @@ function buildSeams2to1(topology, leaves, outSeams, outIndex) {
       if (j !== U32_EMPTY) neighbors[outOffset + 1] = j;
     }
   }
-  return outSeams;
+  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 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));
 }
 
-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();
-    }
-  );
+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();
@@ -1282,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());
@@ -1291,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(() => {
@@ -1300,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,
@@ -1717,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) {
@@ -2280,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(
@@ -2510,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,
@@ -2858,6 +2884,7 @@ function createTorusProjection(config) {
           ctx.uniforms,
           ctx.terrainFieldStorage,
           (_tile, faceUV, displacement) => torusPosition(geometry, faceUV.x, faceUV.y, displacement),
+          ctx.tileBoundsNode,
           baseU,
           baseV
         );
@@ -3084,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(
@@ -3239,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,
@@ -3281,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;
         }
@@ -3303,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);
@@ -3340,7 +3367,7 @@ function triggerSnapshotReadback(state, renderer, attribute, spatialIndex, bound
           boundsAttribute,
           state.boundsReadback,
           state.backTileBounds,
-          activeLeafCount * 2,
+          activeLeafCount * TILE_BOUNDS_FLOATS_PER_TILE,
           "terrainBoundsReadback"
         );
       }
@@ -3359,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);
@@ -3473,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 {
@@ -3702,84 +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 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 WGSIZE = 64;
-function buildReductionKernel(elevationFieldNode, boundsNode, verticesPerNode, edgeVertexCount) {
-  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");
-    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));
-      tsl.If(isSkirt.not(), () => {
-        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 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,
-      edgeVertexCount
-    );
-    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);
@@ -3922,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 }) => {
@@ -4047,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,
@@ -4061,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)
         );
       }
     ];
@@ -4078,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);
@@ -4112,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);
@@ -4120,6 +4186,7 @@ const createTerrainSamplerTask = work.task((get, work) => {
   return work(
     () => createTerrainSampler({
       terrainFieldStorage,
+      tileBoundsNode: tileBoundsContext.node,
       spatialIndex,
       uniforms,
       elevationCallback,
@@ -4133,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");
@@ -4259,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));
 });
@@ -4316,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;
@@ -4352,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;
@@ -4374,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;
@@ -4387,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;
@@ -4401,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;