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

package/dist/index.mjs

@@ -1,7 +1,7 @@
 import { BufferGeometry, BufferAttribute, RGBAFormat, ClampToEdgeWrapping, HalfFloatType, FloatType, LinearFilter, NearestFilter, Vector3 } from 'three';
-import { MeshStandardNodeMaterial, InstancedMesh, InstancedBufferAttribute, StorageTexture, StorageArrayTexture, StorageBufferAttribute, Vector3 as Vector3$1 } from 'three/webgpu';
+import { MeshStandardNodeMaterial, InstancedMesh, InstancedBufferAttribute, StorageBufferAttribute, StorageTexture, StorageArrayTexture, Vector3 as Vector3$1 } from 'three/webgpu';
 import { param, task, graph } from '@hello-terrain/work';
-import { float, uniform, Fn, globalId, int, vec2, uint, If, vec3, textureLoad, ivec2, textureStore, uvec3, vec4, texture, ivec3, pow, storage, cross, vertexIndex, uv, instanceIndex, positionLocal, select, normalLocal, Loop, Break, sin, cos, bool, workgroupArray, localId, workgroupId, min, max, workgroupBarrier, remap, dot as dot$1, varyingProperty, mx_noise_float, mix } from 'three/tsl';
+import { float, uniform, Fn, globalId, int, vec2, uint, If, storage, vec3, cross, vertexIndex, uv, max, textureStore, uvec3, vec4, texture, ivec2, ivec3, textureLoad, pow, instanceIndex, positionLocal, select, normalLocal, Loop, Break, sin, cos, bool, workgroupArray, localId, workgroupId, min, workgroupBarrier, remap, dot as dot$1, varyingProperty, mx_noise_float, mix } from 'three/tsl';
 import { Fn as Fn$1 } from 'three/src/nodes/TSL.js';
 
 class TerrainGeometry extends BufferGeometry {
@@ -359,6 +359,7 @@ function compileComputePipeline(stages, width, options) {
     WORKGROUP_X,
     WORKGROUP_Y
   ];
+  const midPipelineExecute = options?.midPipelineExecute;
   const uInstanceCount = uniform(0, "uint").setName("uInstanceCount");
   const stagedKernelCache = /* @__PURE__ */ new Map();
   function clampWorkgroupToLimits(requested, limits) {
@@ -419,283 +420,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" ? HalfFloatType : FloatType;
-}
-function resolveFilter(mode) {
-  return mode === "linear" ? LinearFilter : NearestFilter;
-}
-function configureStorageTexture(texture2, format, filter) {
-  texture2.format = RGBAFormat;
-  texture2.type = resolveType(format);
-  texture2.magFilter = resolveFilter(filter);
-  texture2.minFilter = resolveFilter(filter);
-  texture2.wrapS = ClampToEdgeWrapping;
-  texture2.wrapT = ClampToEdgeWrapping;
-  texture2.generateMipmaps = false;
-  texture2.needsUpdate = true;
-}
-function ArrayTextureBackend(edgeVertexCount, tileCount, options) {
-  let currentEdgeVertexCount = edgeVertexCount;
-  let currentTileCount = tileCount;
-  const tex = new 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 vec2(ix.toFloat(), iy.toFloat());
-    },
-    texel(ix, iy, tileIndex) {
-      return ivec3(ix, iy, tileIndex);
-    },
-    sample(u, v, tileIndex) {
-      return texture(tex, vec2(u, v)).depth(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 = int(tilesPerRow);
-  const edge = int(edgeVertexCount);
-  const tile = int(tileIndex);
-  const col = tile.mod(tilesPerRowNode);
-  const row = tile.div(tilesPerRowNode);
-  const atlasX = col.mul(edge).add(int(ix));
-  const atlasY = row.mul(edge).add(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 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 = float(tilesPerRow * currentEdgeVertexCount);
-      return 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 ivec2(atlasX, atlasY);
-    },
-    sample(u, v, tileIndex) {
-      const tile = int(tileIndex);
-      const tilesPerRowNode = int(tilesPerRow);
-      const col = tile.mod(tilesPerRowNode);
-      const row = tile.div(tilesPerRowNode);
-      const invTilesPerRow = float(1 / tilesPerRow);
-      const atlasU = col.toFloat().add(u).mul(invTilesPerRow);
-      const atlasV = row.toFloat().add(v).mul(invTilesPerRow);
-      return texture(tex, 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 textureStore(
-      storage.texture,
-      uvec3(int(ix), int(iy), int(tileIndex)),
-      value
-    );
-  }
-  return 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 textureLoad(storage.texture, ivec2(int(ix), int(iy)), int(0)).depth(
-      int(tileIndex)
-    );
-  }
-  return textureLoad(storage.texture, storage.texel(ix, iy, tileIndex), 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 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 vec4(height, normal.x, normal.y, normal.z);
-}
-
-const createElevation = (tile, uniforms, elevationFn) => {
-  return function perVertexElevation(nodeIndex, localCoordinates) {
-    const ix = int(localCoordinates.x);
-    const iy = int(localCoordinates.y);
-    const edgeVertexCount = uniforms.uInnerTileSegments.toVar().add(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: 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 = int(nodeIndex).mul(int(4));
-  return {
-    level: leafStorage.node.element(nodeOffset).toInt(),
-    x: leafStorage.node.element(nodeOffset.add(int(1))).toFloat(),
-    y: leafStorage.node.element(nodeOffset.add(int(2))).toFloat(),
-    face: leafStorage.node.element(nodeOffset.add(int(3))).toInt()
-  };
-}
-function faceUVFromTileLocal(tile, localU, localV, baseU = float(1), baseV = float(1)) {
-  const levelScale = pow(float(2), tile.level.toFloat());
-  const nU = baseU.mul(levelScale);
-  const nV = baseV.mul(levelScale);
-  return vec2(tile.x.add(localU).div(nU), tile.y.add(localV).div(nV));
-}
-function createTileCompute(leafStorage, uniforms, projection) {
-  const baseU = float(projection.baseResolution?.u ?? 1);
-  const baseV = float(projection.baseResolution?.v ?? 1);
-  const tileLevel = Fn(([nodeIndex]) => decodeLeafTile(leafStorage, nodeIndex).level);
-  const tileFace = Fn(([nodeIndex]) => decodeLeafTile(leafStorage, nodeIndex).face);
-  const tileOriginVec2 = Fn(([nodeIndex]) => {
-    const tile = decodeLeafTile(leafStorage, nodeIndex);
-    return vec2(tile.x, tile.y);
-  });
-  const tileFaceUV = Fn(([nodeIndex, ix, iy]) => {
-    const tile = decodeLeafTile(leafStorage, nodeIndex);
-    const fInnerSegments = uniforms.uInnerTileSegments.toVar().toFloat();
-    const localU = int(ix).toFloat().sub(float(1)).div(fInnerSegments);
-    const localV = int(iy).toFloat().sub(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 = float(innerSegments).add(float(FIELD_EDGE_EXTRA_TEXELS));
-  return float(localCoord).mul(float(innerSegments)).add(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 StorageBufferAttribute(data, 4);
@@ -1176,97 +910,373 @@ function buildSeams2to1(topology, leaves, outSeams, outIndex) {
       if (j !== U32_EMPTY) neighbors[outOffset + 1] = j;
     }
   }
-  return outSeams;
+  return outSeams;
+}
+
+function createFlatNormalFromElevationField(elevationFieldNode, edgeVertexCount) {
+  return Fn(
+    ([nodeIndex, tileSize, ix, iy, elevationScale]) => {
+      const iEdge = int(edgeVertexCount);
+      const verticesPerNode = iEdge.mul(iEdge);
+      const baseOffset = int(nodeIndex).mul(verticesPerNode);
+      const xLeft = int(ix).sub(int(1));
+      const xRight = int(ix).add(int(1));
+      const yUp = int(iy).sub(int(1));
+      const yDown = int(iy).add(int(1));
+      const hLeft = elevationFieldNode.element(baseOffset.add(int(iy).mul(iEdge).add(xLeft))).mul(elevationScale);
+      const hRight = elevationFieldNode.element(baseOffset.add(int(iy).mul(iEdge).add(xRight))).mul(elevationScale);
+      const hUp = elevationFieldNode.element(baseOffset.add(yUp.mul(iEdge).add(int(ix)))).mul(elevationScale);
+      const hDown = elevationFieldNode.element(baseOffset.add(yDown.mul(iEdge).add(int(ix)))).mul(elevationScale);
+      const innerSegments = float(iEdge).sub(float(3));
+      const stepWorld = tileSize.div(innerSegments);
+      const inv2Step = float(0.5).div(stepWorld);
+      const dhdx = float(hRight).sub(float(hLeft)).mul(inv2Step);
+      const dhdz = float(hDown).sub(float(hUp)).mul(inv2Step);
+      return vec3(dhdx.negate(), float(1), dhdz.negate()).normalize();
+    }
+  );
+}
+function createDisplacedSurfaceNormalFromElevationField(elevationFieldNode, edgeVertexCount, makeSurfaceFns) {
+  return Fn(([nodeIndex, ix, iy, elevationScale]) => {
+    const iEdge = int(edgeVertexCount);
+    const verticesPerNode = iEdge.mul(iEdge);
+    const baseOffset = int(nodeIndex).mul(verticesPerNode);
+    const xLeft = int(ix).sub(int(1));
+    const xRight = int(ix).add(int(1));
+    const yUp = int(iy).sub(int(1));
+    const yDown = int(iy).add(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, int(iy), heightAt(xLeft, int(iy)));
+    const pRight = positionAt(xRight, int(iy), heightAt(xRight, int(iy)));
+    const pUp = positionAt(int(ix), yUp, heightAt(int(ix), yUp));
+    const pDown = positionAt(int(ix), yDown, heightAt(int(ix), yDown));
+    const tangentU = pRight.sub(pLeft);
+    const tangentV = pDown.sub(pUp);
+    const normal = cross(tangentU, tangentV).normalize();
+    const dir = dirAt(int(ix), int(iy));
+    return normal.mul(normal.dot(dir).sign());
+  });
+}
+
+const isSkirtVertex = Fn(([segments]) => {
+  const segmentsNode = typeof segments === "number" ? int(segments) : segments;
+  const vIndex = int(vertexIndex);
+  const segmentEdges = int(segmentsNode.add(3));
+  const vx = vIndex.mod(segmentEdges);
+  const vy = vIndex.div(segmentEdges);
+  const last = segmentEdges.sub(int(1));
+  return vx.equal(int(0)).or(vx.equal(last)).or(vy.equal(int(0))).or(vy.equal(last));
+});
+const isSkirtUV = Fn(([segments]) => {
+  const segmentsNode = typeof segments === "number" ? int(segments) : segments;
+  const ux = uv().x;
+  const uy = uv().y;
+  const segmentCount = segmentsNode.add(2);
+  const segmentStep = 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" ? HalfFloatType : FloatType;
+}
+function resolveFilter(mode) {
+  return mode === "linear" ? LinearFilter : NearestFilter;
+}
+function configureStorageTexture(texture2, format, filter) {
+  texture2.format = RGBAFormat;
+  texture2.type = resolveType(format);
+  texture2.magFilter = resolveFilter(filter);
+  texture2.minFilter = resolveFilter(filter);
+  texture2.wrapS = ClampToEdgeWrapping;
+  texture2.wrapT = ClampToEdgeWrapping;
+  texture2.generateMipmaps = false;
+  texture2.needsUpdate = true;
+}
+function ArrayTextureBackend(edgeVertexCount, tileCount, options) {
+  let currentEdgeVertexCount = edgeVertexCount;
+  let currentTileCount = tileCount;
+  const tex = new 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 vec2(ix.toFloat(), iy.toFloat());
+    },
+    texel(ix, iy, tileIndex) {
+      return ivec3(ix, iy, tileIndex);
+    },
+    sample(u, v, tileIndex) {
+      return texture(tex, vec2(u, v)).depth(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 = int(tilesPerRow);
+  const edge = int(edgeVertexCount);
+  const tile = int(tileIndex);
+  const col = tile.mod(tilesPerRowNode);
+  const row = tile.div(tilesPerRowNode);
+  const atlasX = col.mul(edge).add(int(ix));
+  const atlasY = row.mul(edge).add(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 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 = float(tilesPerRow * currentEdgeVertexCount);
+      return 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 ivec2(atlasX, atlasY);
+    },
+    sample(u, v, tileIndex) {
+      const tile = int(tileIndex);
+      const tilesPerRowNode = int(tilesPerRow);
+      const col = tile.mod(tilesPerRowNode);
+      const row = tile.div(tilesPerRowNode);
+      const invTilesPerRow = float(1 / tilesPerRow);
+      const atlasU = col.toFloat().add(u).mul(invTilesPerRow);
+      const atlasV = row.toFloat().add(v).mul(invTilesPerRow);
+      return texture(tex, 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 textureStore(
+      storage.texture,
+      uvec3(int(ix), int(iy), int(tileIndex)),
+      value
+    );
+  }
+  return 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 textureLoad(storage.texture, ivec2(int(ix), int(iy)), int(0)).depth(
+      int(tileIndex)
+    );
+  }
+  return textureLoad(storage.texture, storage.texel(ix, iy, tileIndex), 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 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 vec4(height, normal.x, normal.y, normal.z);
+}
+function loadTilePackBounds(boundsNode, tileIndex) {
+  const base = int(tileIndex).mul(int(TILE_BOUNDS_FLOATS_PER_TILE));
+  return {
+    packMin: boundsNode.element(base.add(int(TILE_BOUNDS_PACK_MIN_OFFSET))),
+    packMax: boundsNode.element(base.add(int(TILE_BOUNDS_PACK_MAX_OFFSET)))
+  };
+}
+function packNormalizedTerrainFieldSample(height, normal, packMin, packMax) {
+  const span = max(packMax.sub(packMin), float(TERRAIN_FIELD_PACK_EPSILON));
+  const normalized = height.sub(packMin).div(span);
+  return vec4(normalized, normal.x, normal.y, normal.z);
+}
+function denormalizeTerrainFieldElevation(normalized, packMin, packMax) {
+  const span = max(packMax.sub(packMin), float(TERRAIN_FIELD_PACK_EPSILON));
+  return packMin.add(normalized.mul(span));
 }
 
-function createFlatNormalFromElevationField(elevationFieldNode, edgeVertexCount) {
-  return Fn(
-    ([nodeIndex, tileSize, ix, iy, elevationScale]) => {
-      const iEdge = int(edgeVertexCount);
-      const verticesPerNode = iEdge.mul(iEdge);
-      const baseOffset = int(nodeIndex).mul(verticesPerNode);
-      const xLeft = int(ix).sub(int(1));
-      const xRight = int(ix).add(int(1));
-      const yUp = int(iy).sub(int(1));
-      const yDown = int(iy).add(int(1));
-      const hLeft = elevationFieldNode.element(baseOffset.add(int(iy).mul(iEdge).add(xLeft))).mul(elevationScale);
-      const hRight = elevationFieldNode.element(baseOffset.add(int(iy).mul(iEdge).add(xRight))).mul(elevationScale);
-      const hUp = elevationFieldNode.element(baseOffset.add(yUp.mul(iEdge).add(int(ix)))).mul(elevationScale);
-      const hDown = elevationFieldNode.element(baseOffset.add(yDown.mul(iEdge).add(int(ix)))).mul(elevationScale);
-      const innerSegments = float(iEdge).sub(float(3));
-      const stepWorld = tileSize.div(innerSegments);
-      const inv2Step = float(0.5).div(stepWorld);
-      const dhdx = float(hRight).sub(float(hLeft)).mul(inv2Step);
-      const dhdz = float(hDown).sub(float(hUp)).mul(inv2Step);
-      return vec3(dhdx.negate(), 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 Fn(([nodeIndex, ix, iy, elevationScale]) => {
-    const iEdge = int(edgeVertexCount);
-    const verticesPerNode = iEdge.mul(iEdge);
-    const baseOffset = int(nodeIndex).mul(verticesPerNode);
-    const xLeft = int(ix).sub(int(1));
-    const xRight = int(ix).add(int(1));
-    const yUp = int(iy).sub(int(1));
-    const yDown = int(iy).add(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, int(iy), heightAt(xLeft, int(iy)));
-    const pRight = positionAt(xRight, int(iy), heightAt(xRight, int(iy)));
-    const pUp = positionAt(int(ix), yUp, heightAt(int(ix), yUp));
-    const pDown = positionAt(int(ix), yDown, heightAt(int(ix), yDown));
-    const tangentU = pRight.sub(pLeft);
-    const tangentV = pDown.sub(pUp);
-    const normal = cross(tangentU, tangentV).normalize();
-    const dir = dirAt(int(ix), int(iy));
-    return normal.mul(normal.dot(dir).sign());
+function decodeLeafTile(leafStorage, nodeIndex) {
+  const nodeOffset = int(nodeIndex).mul(int(4));
+  return {
+    level: leafStorage.node.element(nodeOffset).toInt(),
+    x: leafStorage.node.element(nodeOffset.add(int(1))).toFloat(),
+    y: leafStorage.node.element(nodeOffset.add(int(2))).toFloat(),
+    face: leafStorage.node.element(nodeOffset.add(int(3))).toInt()
+  };
+}
+function faceUVFromTileLocal(tile, localU, localV, baseU = float(1), baseV = float(1)) {
+  const levelScale = pow(float(2), tile.level.toFloat());
+  const nU = baseU.mul(levelScale);
+  const nV = baseV.mul(levelScale);
+  return vec2(tile.x.add(localU).div(nU), tile.y.add(localV).div(nV));
+}
+function createTileCompute(leafStorage, uniforms, projection) {
+  const baseU = float(projection.baseResolution?.u ?? 1);
+  const baseV = float(projection.baseResolution?.v ?? 1);
+  const tileLevel = Fn(([nodeIndex]) => decodeLeafTile(leafStorage, nodeIndex).level);
+  const tileFace = Fn(([nodeIndex]) => decodeLeafTile(leafStorage, nodeIndex).face);
+  const tileOriginVec2 = Fn(([nodeIndex]) => {
+    const tile = decodeLeafTile(leafStorage, nodeIndex);
+    return vec2(tile.x, tile.y);
+  });
+  const tileFaceUV = Fn(([nodeIndex, ix, iy]) => {
+    const tile = decodeLeafTile(leafStorage, nodeIndex);
+    const fInnerSegments = uniforms.uInnerTileSegments.toVar().toFloat();
+    const localU = int(ix).toFloat().sub(float(1)).div(fInnerSegments);
+    const localV = int(iy).toFloat().sub(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 = float(innerSegments).add(float(FIELD_EDGE_EXTRA_TEXELS));
+  return float(localCoord).mul(float(innerSegments)).add(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 = Fn(([segments]) => {
-  const segmentsNode = typeof segments === "number" ? int(segments) : segments;
-  const vIndex = int(vertexIndex);
-  const segmentEdges = int(segmentsNode.add(3));
-  const vx = vIndex.mod(segmentEdges);
-  const vy = vIndex.div(segmentEdges);
-  const last = segmentEdges.sub(int(1));
-  return vx.equal(int(0)).or(vx.equal(last)).or(vy.equal(int(0))).or(vy.equal(last));
-});
-const isSkirtUV = Fn(([segments]) => {
-  const segmentsNode = typeof segments === "number" ? int(segments) : segments;
-  const ux = uv().x;
-  const uy = uv().y;
-  const segmentCount = segmentsNode.add(2);
-  const segmentStep = 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 float(0);
+function createTileElevation(terrainUniforms, terrainFieldStorage, tileBoundsNode) {
+  if (!terrainFieldStorage || !tileBoundsNode) return float(0);
   const innerSegs = terrainUniforms.uInnerTileSegments;
   const u = tileLocalToFieldUV(positionLocal.x.add(float(0.5)), innerSegs);
   const v = tileLocalToFieldUV(positionLocal.z.add(float(0.5)), innerSegs);
-  return sampleTerrainFieldElevation(terrainFieldStorage, u, v, int(instanceIndex)).mul(
+  const normalized = sampleTerrainFieldElevation(
+    terrainFieldStorage,
+    u,
+    v,
+    int(instanceIndex)
+  );
+  const { packMin, packMax } = loadTilePackBounds(tileBoundsNode, int(instanceIndex));
+  return denormalizeTerrainFieldElevation(normalized, packMin, packMax).mul(
     terrainUniforms.uElevationScale
   );
 }
 function loadWorldNormal(terrainUniforms, terrainFieldStorage) {
-  const nodeIndex = int(instanceIndex);
-  const edgeVertexCount = int(terrainUniforms.uInnerTileSegments.add(3));
-  const localVertexIndex = int(vertexIndex);
-  const ix = localVertexIndex.mod(edgeVertexCount);
-  const iy = localVertexIndex.div(edgeVertexCount);
-  return loadTerrainFieldNormal(terrainFieldStorage, ix, iy, nodeIndex);
+  const innerSegs = terrainUniforms.uInnerTileSegments;
+  const u = tileLocalToFieldUV(positionLocal.x.add(float(0.5)), innerSegs);
+  const v = tileLocalToFieldUV(positionLocal.z.add(float(0.5)), innerSegs);
+  const raw = sampleTerrainField(terrainFieldStorage, u, v, int(instanceIndex));
+  return vec3(raw.g, raw.b, raw.a).normalize();
 }
 function assignWorldNormal(terrainUniforms, terrainFieldStorage) {
   if (!terrainFieldStorage) return;
   normalLocal.assign(Fn(() => loadWorldNormal(terrainUniforms, terrainFieldStorage))());
 }
-function createFlatRenderVertexPosition(leafStorage, terrainUniforms, terrainFieldStorage) {
+function createFlatRenderVertexPosition(leafStorage, terrainUniforms, terrainFieldStorage, tileBoundsNode) {
   return Fn(() => {
     const tile = decodeLeafTile(leafStorage, int(instanceIndex));
     const rootSize = terrainUniforms.uRootSize.toVar();
@@ -1280,7 +1290,11 @@ function createFlatRenderVertexPosition(leafStorage, terrainUniforms, terrainFie
     const clampedZ = 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());
@@ -1289,7 +1303,7 @@ function createFlatRenderVertexPosition(leafStorage, terrainUniforms, terrainFie
     return 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 = float(baseU);
   const fBaseV = float(baseV);
   return Fn(() => {
@@ -1298,7 +1312,11 @@ function createCurvedRenderVertexPosition(leafStorage, terrainUniforms, terrainF
     const localU = positionLocal.x.max(half.negate()).min(half).add(half);
     const localV = 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 = select(
       skirtVertex,
@@ -1715,7 +1733,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) {
@@ -2278,9 +2301,11 @@ function packedSampleFromTileResult(params, tileResult) {
     fieldV,
     safeTileIndex
   ).toVar();
+  const { packMin, packMax } = loadTilePackBounds(params.tileBoundsNode, safeTileIndex);
+  const elevation = denormalizeTerrainFieldElevation(sampled.r, packMin, packMax);
   const normal = vec3(sampled.g, sampled.b, sampled.a);
   const valid = found.select(float(1), float(0)).toVar();
-  return vec4(sampled.r, normal.x, normal.y, normal.z).mul(valid);
+  return vec4(elevation, normal.x, normal.y, normal.z).mul(valid);
 }
 function createTerrainSampleNode(params) {
   const tileLookup = createTileIndexFromWorldPosition(
@@ -2508,7 +2533,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,
@@ -2856,6 +2882,7 @@ function createTorusProjection(config) {
           ctx.uniforms,
           ctx.terrainFieldStorage,
           (_tile, faceUV, displacement) => torusPosition(geometry, faceUV.x, faceUV.y, displacement),
+          ctx.tileBoundsNode,
           baseU,
           baseV
         );
@@ -3082,8 +3109,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(
@@ -3237,8 +3264,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,
@@ -3279,7 +3306,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;
         }
@@ -3301,8 +3328,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);
@@ -3338,7 +3365,7 @@ function triggerSnapshotReadback(state, renderer, attribute, spatialIndex, bound
           boundsAttribute,
           state.boundsReadback,
           state.backTileBounds,
-          activeLeafCount * 2,
+          activeLeafCount * TILE_BOUNDS_FLOATS_PER_TILE,
           "terrainBoundsReadback"
         );
       }
@@ -3357,7 +3384,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);
@@ -3471,8 +3500,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 {
@@ -3700,84 +3729,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 = int(localCoordinates.x);
+    const iy = int(localCoordinates.y);
+    const edgeVertexCount = uniforms.uInnerTileSegments.toVar().add(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: int(nodeIndex),
+      tileUV
+    });
+  };
+};
+
+function createTerrainUniforms(params) {
+  const sanitizedId = params.instanceId?.replace(/-/g, "_");
+  const suffix = sanitizedId ? `_${sanitizedId}` : "";
+  const uRootOrigin = uniform(
+    new Vector3$1(params.rootOrigin.x, params.rootOrigin.y, params.rootOrigin.z)
+  ).setName(`uRootOrigin${suffix}`);
+  const uRootSize = uniform(float(params.rootSize)).setName(`uRootSize${suffix}`);
+  const uInnerTileSegments = uniform(int(params.innerTileSegments)).setName(
+    `uInnerTileSegments${suffix}`
+  );
+  const uSkirtScale = uniform(float(params.skirtScale)).setName(`uSkirtScale${suffix}`);
+  const uElevationScale = uniform(float(params.elevationScale)).setName(`uElevationScale${suffix}`);
+  const uRadius = uniform(float(params.radius)).setName(`uRadius${suffix}`);
+  return {
+    uRootOrigin,
+    uRootSize,
+    uInnerTileSegments,
+    uSkirtScale,
+    uElevationScale,
+    uRadius
+  };
+}
+
+const instanceIdTask = task(() => crypto.randomUUID()).displayName("instanceIdTask").cache("once");
+
+const scratchVector3 = new Vector3();
+const createUniformsTask = 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 = 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 Fn(() => {
-    const sharedMin = workgroupArray("float", WGSIZE);
-    const sharedMax = workgroupArray("float", WGSIZE);
-    const tid = int(localId.x);
-    const tileIdx = int(workgroupId.z);
-    const baseOffset = tileIdx.mul(int(verticesPerNode));
-    const start = tid.mul(int(elemsPerThread));
-    const end = min(start.add(int(elemsPerThread)), int(verticesPerNode));
-    const localMin = float(1e10).toVar("localMin");
-    const localMax = float(-1e10).toVar("localMax");
-    const edge = int(edgeVertexCount);
-    const lastEdge = int(edgeVertexCount - 1);
-    Loop({ start, end, type: "int", condition: "<" }, ({ i }) => {
-      const ix = int(i).mod(edge);
-      const iy = int(i).div(edge);
-      const isSkirt = ix.equal(int(0)).or(ix.equal(lastEdge)).or(iy.equal(int(0))).or(iy.equal(lastEdge));
-      If(isSkirt.not(), () => {
-        const h = elevationFieldNode.element(baseOffset.add(i));
-        localMin.assign(min(localMin, h));
-        localMax.assign(max(localMax, h));
-      });
-    });
-    sharedMin.element(tid).assign(localMin);
-    sharedMax.element(tid).assign(localMax);
-    workgroupBarrier();
-    If(tid.equal(int(0)), () => {
-      const finalMin = float(1e10).toVar("finalMin");
-      const finalMax = float(-1e10).toVar("finalMax");
-      Loop(WGSIZE, ({ i }) => {
-        finalMin.assign(min(finalMin, sharedMin.element(i)));
-        finalMax.assign(max(finalMax, sharedMax.element(i)));
-      });
-      const outIdx = tileIdx.mul(int(2));
-      boundsNode.element(outIdx).assign(finalMin);
-      boundsNode.element(outIdx.add(int(1))).assign(finalMax);
-    });
-  })().computeKernel([WGSIZE, 1, 1]);
-}
-const tileBoundsContextTask = task((get, work) => {
-  const elevationFieldContext = get(createElevationFieldContextTask);
-  const maxNodesValue = get(maxNodes);
+const createElevationFieldContextTask = 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 StorageBufferAttribute(data, 1);
-    attribute.name = "tileBounds";
-    const node = 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 = storage(attribute, "float", totalElements).setName("elevationField");
+    return {
+      data,
+      attribute,
+      node
+    };
   });
-}).displayName("tileBoundsContextTask");
-const tileBoundsReductionTask = 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 = 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 = 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 = task((get, work) => {
   const maxNodesValue = get(maxNodes);
@@ -3920,107 +3997,88 @@ const leafGpuBufferTask = task((get, work) => {
   });
 }).displayName("leafGpuBufferTask");
 
-function createTerrainUniforms(params) {
-  const sanitizedId = params.instanceId?.replace(/-/g, "_");
-  const suffix = sanitizedId ? `_${sanitizedId}` : "";
-  const uRootOrigin = uniform(
-    new Vector3$1(params.rootOrigin.x, params.rootOrigin.y, params.rootOrigin.z)
-  ).setName(`uRootOrigin${suffix}`);
-  const uRootSize = uniform(float(params.rootSize)).setName(`uRootSize${suffix}`);
-  const uInnerTileSegments = uniform(int(params.innerTileSegments)).setName(
-    `uInnerTileSegments${suffix}`
-  );
-  const uSkirtScale = uniform(float(params.skirtScale)).setName(`uSkirtScale${suffix}`);
-  const uElevationScale = uniform(float(params.elevationScale)).setName(`uElevationScale${suffix}`);
-  const uRadius = uniform(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 Fn(() => {
+    const sharedLodMin = workgroupArray("float", WGSIZE);
+    const sharedLodMax = workgroupArray("float", WGSIZE);
+    const sharedPackMin = workgroupArray("float", WGSIZE);
+    const sharedPackMax = workgroupArray("float", WGSIZE);
+    const tid = int(localId.x);
+    const tileIdx = int(workgroupId.z);
+    const baseOffset = tileIdx.mul(int(verticesPerNode));
+    const start = tid.mul(int(elemsPerThread));
+    const end = min(start.add(int(elemsPerThread)), int(verticesPerNode));
+    const localLodMin = float(1e10).toVar("localLodMin");
+    const localLodMax = float(-1e10).toVar("localLodMax");
+    const localPackMin = float(1e10).toVar("localPackMin");
+    const localPackMax = float(-1e10).toVar("localPackMax");
+    const edge = int(edgeVertexCount);
+    const lastEdge = int(edgeVertexCount - 1);
+    Loop({ start, end, type: "int", condition: "<" }, ({ i }) => {
+      const ix = int(i).mod(edge);
+      const iy = int(i).div(edge);
+      const isSkirt = ix.equal(int(0)).or(ix.equal(lastEdge)).or(iy.equal(int(0))).or(iy.equal(lastEdge));
+      const h = elevationFieldNode.element(baseOffset.add(i));
+      localPackMin.assign(min(localPackMin, h));
+      localPackMax.assign(max(localPackMax, h));
+      If(isSkirt.not(), () => {
+        localLodMin.assign(min(localLodMin, h));
+        localLodMax.assign(max(localLodMax, h));
+      });
+    });
+    sharedLodMin.element(tid).assign(localLodMin);
+    sharedLodMax.element(tid).assign(localLodMax);
+    sharedPackMin.element(tid).assign(localPackMin);
+    sharedPackMax.element(tid).assign(localPackMax);
+    workgroupBarrier();
+    If(tid.equal(int(0)), () => {
+      const finalLodMin = float(1e10).toVar("finalLodMin");
+      const finalLodMax = float(-1e10).toVar("finalLodMax");
+      const finalPackMin = float(1e10).toVar("finalPackMin");
+      const finalPackMax = float(-1e10).toVar("finalPackMax");
+      Loop(WGSIZE, ({ i }) => {
+        finalLodMin.assign(min(finalLodMin, sharedLodMin.element(i)));
+        finalLodMax.assign(max(finalLodMax, sharedLodMax.element(i)));
+        finalPackMin.assign(min(finalPackMin, sharedPackMin.element(i)));
+        finalPackMax.assign(max(finalPackMax, sharedPackMax.element(i)));
+      });
+      const outIdx = tileIdx.mul(int(TILE_BOUNDS_FLOATS_PER_TILE));
+      boundsNode.element(outIdx.add(int(TILE_BOUNDS_LOD_MIN_OFFSET))).assign(finalLodMin);
+      boundsNode.element(outIdx.add(int(TILE_BOUNDS_LOD_MAX_OFFSET))).assign(finalLodMax);
+      boundsNode.element(outIdx.add(int(TILE_BOUNDS_PACK_MIN_OFFSET))).assign(finalPackMin);
+      boundsNode.element(outIdx.add(int(TILE_BOUNDS_PACK_MAX_OFFSET))).assign(finalPackMax);
+    });
+  })().computeKernel([WGSIZE, 1, 1]);
 }
-
-const instanceIdTask = task(() => crypto.randomUUID()).displayName("instanceIdTask").cache("once");
-
-const scratchVector3 = new Vector3();
-const createUniformsTask = 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 = 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 = task((get, work) => {
+function runTileBoundsReduction(renderer, boundsContext, leafCount) {
+  if (leafCount > 0) {
+    renderer.compute(boundsContext.kernel, [1, 1, leafCount]);
+  }
+}
+const tileBoundsContextTask = 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 StorageBufferAttribute(data, 1);
-    attribute.name = "elevationField";
-    const node = storage(attribute, "float", totalElements).setName("elevationField");
-    return {
-      data,
-      attribute,
-      node
-    };
-  });
-}).displayName("createElevationFieldContextTask");
-const tileNodesTask = 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 = 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 = 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 = task(
   (get, work, { resources }) => {
@@ -4045,6 +4103,7 @@ const terrainFieldStageTask = 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,
@@ -4059,12 +4118,13 @@ const terrainFieldStageTask = task((get, work) => {
         const iy = 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)
         );
       }
     ];
@@ -4076,23 +4136,28 @@ function createComputePipelineTasks(leafStageTask) {
   const compile = 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 = 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 = 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 = task((get, work) => {
+  get(executeComputeTask);
+  const boundsContext = get(tileBoundsContextTask);
+  return work(() => boundsContext);
+}).displayName("tileBoundsReductionTask").lane("gpu");
 
 const gpuSpatialIndexStorageTask = task((get, work) => {
   const maxNodesValue = get(maxNodes);
@@ -4110,6 +4175,7 @@ const gpuSpatialIndexUploadTask = task((get, work) => {
 
 const createTerrainSamplerTask = task((get, work) => {
   const terrainFieldStorage = get(createTerrainFieldTextureTask);
+  const tileBoundsContext = get(tileBoundsContextTask);
   const spatialIndex = get(gpuSpatialIndexStorageTask);
   const uniforms = get(updateUniformsTask);
   const elevationCallback = get(elevationFn);
@@ -4118,6 +4184,7 @@ const createTerrainSamplerTask = task((get, work) => {
   return work(
     () => createTerrainSampler({
       terrainFieldStorage,
+      tileBoundsNode: tileBoundsContext.node,
       spatialIndex,
       uniforms,
       elevationCallback,
@@ -4131,12 +4198,14 @@ const positionNodeTask = 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");
@@ -4257,6 +4326,17 @@ function terrainGraph() {
   return g;
 }
 
+const decodeUint16RG = Fn(
+  ([sample]) => sample.r.mul(float(256)).add(sample.g).div(float(257))
+);
+const sampleHeightmapMeters = Fn(
+  ([heightmapTexture, uv, minM, _maxM, rangeM]) => {
+    const sample = texture(heightmapTexture, uv);
+    const normalized = decodeUint16RG(sample);
+    return minM.add(normalized.mul(rangeM));
+  }
+);
+
 const textureSpaceToVectorSpace = Fn(([value]) => {
   return remap(value, float(0), float(1), float(-1), float(1));
 });
@@ -4309,4 +4389,4 @@ const voronoiCells = Fn((params) => {
   return k;
 });
 
-export { ArrayTextureBackend, AtlasBackend, CUBE_FACES, CUBE_FACE_COUNT, Dir, TerrainGeometry, TerrainMesh, U32_EMPTY, allocLeafSet, allocSeamTable, augmentCubeSphereSampler, beginUpdate, blendAngleCorrectedNormals, buildLeafIndex, buildSeams2to1, compileComputeTask, createComputePipelineTasks, createCubeSphereProjection, createCubeSphereTopology, createElevationFieldContextTask, createFlatProjection, createFlatTopology, createInfiniteFlatTopology, createSpatialIndex, createState, createTerrainFieldStorage, createTerrainFieldTextureTask, createTerrainQuery, createTerrainRaycast, createTerrainSampler, createTerrainSamplerTask, createTerrainSurfaceQuery, createTerrainUniforms, createTorusProjection, createTorusTopology, createUniformsTask, cubeFaceBasis, cubeFaceDirection, cubeFaceFromDirection, cubeFacePoint, cubeFaceUVFromDirection, deriveNormalZ, directionToFace, directionToFaceUV, directionToLatLong, elevationFieldStageTask, elevationFn, elevationScale, executeComputeTask, faceUVToCube, getDeviceComputeLimits, gpuSpatialIndexStorageTask, gpuSpatialIndexUploadTask, innerTileSegments, instanceIdTask, isSkirtUV, isSkirtVertex, latLongToDirection, leafGpuBufferTask, leafStorageTask, loadTerrainField, loadTerrainFieldElevation, loadTerrainFieldNormal, maxLevel, maxNodes, origin, packTerrainFieldSample, positionNodeTask, positionToTorusParams, quadtreeConfigTask, quadtreeUpdate, quadtreeUpdateTask, radius, resetLeafSet, resetSeamTable, rootSize, sampleTerrainField, sampleTerrainFieldElevation, skirtScale, sphereTangentFrameNormal, storeTerrainField, tangentFromAxis, terrainFieldFilter, terrainFieldStageTask, terrainGraph, terrainQueryTask, terrainRaycastTask, terrainReadbackTask, terrainTasks, textureSpaceToVectorSpace, tileNodesTask, topology, topologyTask, torusOutwardNormal$1 as torusOutwardNormal, torusUVToPoint, unpackTangentNormal, update, updateUniformsTask, vElevation, vGlobalVertexIndex, vectorSpaceToTextureSpace, voronoiCells, wrap01 };
+export { ArrayTextureBackend, AtlasBackend, CUBE_FACES, CUBE_FACE_COUNT, Dir, TERRAIN_FIELD_PACK_EPSILON, TILE_BOUNDS_FLOATS_PER_TILE, TILE_BOUNDS_LOD_MAX_OFFSET, TILE_BOUNDS_LOD_MIN_OFFSET, TILE_BOUNDS_PACK_MAX_OFFSET, TILE_BOUNDS_PACK_MIN_OFFSET, TerrainGeometry, TerrainMesh, U32_EMPTY, allocLeafSet, allocSeamTable, augmentCubeSphereSampler, beginUpdate, blendAngleCorrectedNormals, buildLeafIndex, buildSeams2to1, compileComputeTask, createComputePipelineTasks, createCubeSphereProjection, createCubeSphereTopology, createElevationFieldContextTask, createFlatProjection, createFlatTopology, createInfiniteFlatTopology, createSpatialIndex, createState, createTerrainFieldStorage, createTerrainFieldTextureTask, createTerrainQuery, createTerrainRaycast, createTerrainSampler, createTerrainSamplerTask, createTerrainSurfaceQuery, createTerrainUniforms, createTorusProjection, createTorusTopology, createUniformsTask, cubeFaceBasis, cubeFaceDirection, cubeFaceFromDirection, cubeFacePoint, cubeFaceUVFromDirection, decodeUint16RG, denormalizeTerrainFieldElevation, deriveNormalZ, directionToFace, directionToFaceUV, directionToLatLong, elevationFieldStageTask, elevationFn, elevationScale, executeComputeTask, faceUVToCube, getDeviceComputeLimits, gpuSpatialIndexStorageTask, gpuSpatialIndexUploadTask, innerTileSegments, instanceIdTask, isSkirtUV, isSkirtVertex, latLongToDirection, leafGpuBufferTask, leafStorageTask, loadTerrainField, loadTerrainFieldElevation, loadTerrainFieldNormal, loadTilePackBounds, maxLevel, maxNodes, origin, packNormalizedTerrainFieldSample, packTerrainFieldSample, positionNodeTask, positionToTorusParams, quadtreeConfigTask, quadtreeUpdate, quadtreeUpdateTask, radius, resetLeafSet, resetSeamTable, rootSize, runTileBoundsReduction, sampleHeightmapMeters, sampleTerrainField, sampleTerrainFieldElevation, skirtScale, sphereTangentFrameNormal, storeTerrainField, tangentFromAxis, terrainFieldFilter, terrainFieldStageTask, terrainGraph, terrainQueryTask, terrainRaycastTask, terrainReadbackTask, terrainTasks, textureSpaceToVectorSpace, tileBoundsContextTask, tileBoundsReductionTask, tileNodesTask, topology, topologyTask, torusOutwardNormal$1 as torusOutwardNormal, torusUVToPoint, unpackTangentNormal, update, updateUniformsTask, vElevation, vGlobalVertexIndex, vectorSpaceToTextureSpace, voronoiCells, wrap01 };