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

package/dist/index.cjs

@@ -7,38 +7,43 @@ const tsl = require('three/tsl');
 const TSL_js = require('three/src/nodes/TSL.js');
 
 class TerrainGeometry extends three.BufferGeometry {
-  constructor(innerSegments = 14, extendUV = false) {
+  /**
+   * @param flipWinding Reverse triangle winding so front faces point the
+   *   opposite way. The default winding makes flat tiles front-face `+Y`; the
+   *   cube-sphere maps `(u→right, v→up)`, which would otherwise leave the
+   *   planet's outer shell back-facing, so it passes `flipWinding` to render
+   *   the outer surface with `FrontSide`.
+   */
+  constructor(innerSegments = 14, extendUV = false, flipWinding = false) {
     super();
     if (innerSegments < 1 || !Number.isFinite(innerSegments) || !Number.isInteger(innerSegments)) {
-      throw new Error(
-        `Invalid innerSegments: ${innerSegments}. Must be a positive integer.`
-      );
+      throw new Error(`Invalid innerSegments: ${innerSegments}. Must be a positive integer.`);
     }
     try {
-      this.setIndex(this.generateIndices(innerSegments));
-      this.setAttribute(
-        "position",
-        new three.BufferAttribute(
-          new Float32Array(this.generatePositions(innerSegments)),
-          3
-        )
+      const index = this.generateIndices(innerSegments, flipWinding);
+      const indexAttribute = new three.BufferAttribute(new Uint32Array(index), 1);
+      indexAttribute.name = "terrainIndex";
+      this.setIndex(indexAttribute);
+      const positionAttribute = new three.BufferAttribute(
+        new Float32Array(this.generatePositions(innerSegments)),
+        3
       );
-      this.setAttribute(
-        "normal",
-        new three.BufferAttribute(
-          new Float32Array(this.generateNormals(innerSegments)),
-          3
-        )
+      positionAttribute.name = "terrainPosition";
+      this.setAttribute("position", positionAttribute);
+      const normalAttribute = new three.BufferAttribute(
+        new Float32Array(this.generateNormals(innerSegments)),
+        3
       );
-      this.setAttribute(
-        "uv",
-        new three.BufferAttribute(
-          new Float32Array(
-            extendUV ? this.generateUvsExtended(innerSegments) : this.generateUvsOnlyInner(innerSegments)
-          ),
-          2
-        )
+      normalAttribute.name = "terrainNormal";
+      this.setAttribute("normal", normalAttribute);
+      const uvAttribute = new three.BufferAttribute(
+        new Float32Array(
+          extendUV ? this.generateUvsExtended(innerSegments) : this.generateUvsOnlyInner(innerSegments)
+        ),
+        2
       );
+      uvAttribute.name = "terrainUv";
+      this.setAttribute("uv", uvAttribute);
     } catch (error) {
       console.error("Error creating TerrainGeometry:", error);
       throw error;
@@ -103,12 +108,16 @@ class TerrainGeometry extends three.BufferGeometry {
    *   triangle 1: a, c, b
    *   triangle 2: b, c, d
    */
-  generateIndices(innerSegments) {
+  generateIndices(innerSegments, flipWinding = false) {
     const innerEdgeVertexCount = innerSegments + 1;
     const edgeVertexCountWithSkirt = innerEdgeVertexCount + 2;
     const indices = [];
     const cellsPerEdge = edgeVertexCountWithSkirt - 1;
     const mid = Math.floor(cellsPerEdge / 2);
+    const pushTri = (v0, v1, v2) => {
+      if (flipWinding) indices.push(v0, v2, v1);
+      else indices.push(v0, v1, v2);
+    };
     for (let y = 0; y < cellsPerEdge; y++) {
       for (let x = 0; x < cellsPerEdge; x++) {
         const a = y * edgeVertexCountWithSkirt + x;
@@ -125,11 +134,11 @@ class TerrainGeometry extends three.BufferGeometry {
           useDefaultDiagonal = (x + y) % 2 === 0;
         }
         if (useDefaultDiagonal) {
-          indices.push(a, d, b);
-          indices.push(a, c, d);
+          pushTri(a, d, b);
+          pushTri(a, c, d);
         } else {
-          indices.push(a, c, b);
-          indices.push(b, c, d);
+          pushTri(a, c, b);
+          pushTri(b, c, d);
         }
       }
     }
@@ -220,32 +229,71 @@ class TerrainGeometry extends three.BufferGeometry {
   }
 }
 
+const rootSize = work.param(256).displayName("rootSize");
+const origin = work.param({
+  x: 0,
+  y: 0,
+  z: 0
+}).displayName("origin");
+const innerTileSegments = work.param(61).displayName("innerTileSegments");
+const skirtScale = work.param(100).displayName("skirtScale");
+const elevationScale = work.param(1).displayName("elevationScale");
+const radius = work.param(1e3).displayName("radius");
+const maxNodes = work.param(1024).displayName("maxNodes");
+const maxLevel = work.param(16).displayName("maxLevel");
+const quadtreeUpdate = work.param({
+  cameraOrigin: { x: 0, y: 0, z: 0 },
+  mode: "distance",
+  distanceFactor: 1.5
+}).displayName("quadtreeUpdate");
+const topology = work.param(null).displayName("topology");
+const terrainFieldFilter = work.param("linear").displayName(
+  "terrainFieldFilter"
+);
+const elevationFn = work.param(() => tsl.float(0));
+
 const defaultTerrainMeshParams = {
-  innerTileSegments: 14,
+  // Source of truth is the `innerTileSegments` param itself.
+  innerTileSegments: innerTileSegments.get(),
   maxNodes: 1024,
-  material: new webgpu.MeshStandardNodeMaterial()
+  material: new webgpu.MeshStandardNodeMaterial(),
+  flipWinding: false
 };
 class TerrainMesh extends webgpu.InstancedMesh {
   _innerTileSegments;
   _maxNodes;
+  _flipWinding;
   terrainRaycast = null;
   constructor(params = defaultTerrainMeshParams) {
     const mergedParams = { ...defaultTerrainMeshParams, ...params };
-    const { innerTileSegments, maxNodes, material } = mergedParams;
-    const geometry = new TerrainGeometry(innerTileSegments, true);
+    const { innerTileSegments, maxNodes, material, flipWinding } = mergedParams;
+    const geometry = new TerrainGeometry(innerTileSegments, true, flipWinding);
     super(geometry, material, maxNodes);
+    this.instanceMatrix.name = "terrainInstanceMatrix";
     this.frustumCulled = false;
     this._innerTileSegments = innerTileSegments;
     this._maxNodes = maxNodes;
+    this._flipWinding = flipWinding;
   }
   get innerTileSegments() {
     return this._innerTileSegments;
   }
   set innerTileSegments(tileSegments) {
+    if (tileSegments === this._innerTileSegments) return;
     const oldGeometry = this.geometry;
-    this.geometry = new TerrainGeometry(tileSegments, true);
+    this.geometry = new TerrainGeometry(tileSegments, true, this._flipWinding);
     this._innerTileSegments = tileSegments;
-    setTimeout(oldGeometry.dispose);
+    setTimeout(() => oldGeometry.dispose());
+  }
+  get flipWinding() {
+    return this._flipWinding;
+  }
+  set flipWinding(flip) {
+    if (flip === this._flipWinding) return;
+    const oldGeometry = this.geometry;
+    this.geometry = new TerrainGeometry(this._innerTileSegments, true, flip);
+    this._flipWinding = flip;
+    setTimeout(() => oldGeometry.dispose());
   }
   get maxNodes() {
     return this._maxNodes;
@@ -260,12 +308,14 @@ class TerrainMesh extends webgpu.InstancedMesh {
     const oldMatrixArray = this.instanceMatrix.array;
     nextMatrix.set(oldMatrixArray.subarray(0, Math.min(oldMatrixArray.length, nextMatrix.length)));
     this.instanceMatrix = new webgpu.InstancedBufferAttribute(nextMatrix, 16);
+    this.instanceMatrix.name = "terrainInstanceMatrix";
     if (this.instanceColor) {
       const itemSize = this.instanceColor.itemSize;
       const nextColor = new Float32Array(maxNodes * itemSize);
       const oldColorArray = this.instanceColor.array;
       nextColor.set(oldColorArray.subarray(0, Math.min(oldColorArray.length, nextColor.length)));
       this.instanceColor = new webgpu.InstancedBufferAttribute(nextColor, itemSize);
+      this.instanceColor.name = "terrainInstanceColor";
     }
     this._maxNodes = maxNodes;
     this.count = Math.min(this.count, maxNodes);
@@ -311,13 +361,8 @@ function compileComputePipeline(stages, width, options) {
     WORKGROUP_X,
     WORKGROUP_Y
   ];
-  const preferSingleKernelWhenPossible = options?.preferSingleKernelWhenPossible ?? true;
-  const uInstanceCount = tsl.uniform(0, "uint");
-  let singleKernel;
+  const uInstanceCount = tsl.uniform(0, "uint").setName("uInstanceCount");
   const stagedKernelCache = /* @__PURE__ */ new Map();
-  function canRunSingleKernel(widthValue, limits) {
-    return widthValue <= limits.maxWorkgroupSizeX && widthValue <= limits.maxWorkgroupSizeY && widthValue * widthValue <= limits.maxWorkgroupInvocations;
-  }
   function clampWorkgroupToLimits(requested, limits) {
     let x = Math.max(1, Math.floor(requested[0]));
     let y = Math.max(1, Math.floor(requested[1]));
@@ -333,37 +378,6 @@ function compileComputePipeline(stages, width, options) {
     );
     return [x, y];
   }
-  function buildSingleKernel(workgroupSize) {
-    return tsl.Fn(() => {
-      bindings?.forEach((b) => b.toVar());
-      const fWidth = tsl.float(width);
-      const activeIndex = tsl.globalId.z;
-      const nodeIndex = tsl.int(activeIndex).toVar();
-      const iWidth = tsl.int(width);
-      const ix = tsl.int(tsl.globalId.x);
-      const iy = tsl.int(tsl.globalId.y);
-      const texelSize = tsl.vec2(1, 1).div(fWidth);
-      const localCoordinates = tsl.vec2(tsl.globalId.x, tsl.globalId.y);
-      const localUVCoords = localCoordinates.div(fWidth);
-      const verticesPerNode = iWidth.mul(iWidth);
-      const globalIndex = tsl.int(nodeIndex).mul(verticesPerNode).add(iy.mul(iWidth).add(ix));
-      const inBounds = ix.lessThan(iWidth).and(iy.lessThan(iWidth)).and(tsl.uint(activeIndex).lessThan(uInstanceCount)).toVar();
-      for (let i = 0; i < stages.length; i++) {
-        if (i > 0) {
-          tsl.workgroupBarrier();
-        }
-        tsl.If(inBounds, () => {
-          stages[i](
-            nodeIndex,
-            globalIndex,
-            localUVCoords,
-            localCoordinates,
-            texelSize
-          );
-        });
-      }
-    })().computeKernel(workgroupSize);
-  }
   function buildStagedKernels(workgroupSize) {
     return stages.map(
       (stage) => tsl.Fn(() => {
@@ -394,15 +408,7 @@ function compileComputePipeline(stages, width, options) {
   }
   function execute(renderer, instanceCount) {
     const limits = getDeviceComputeLimits(renderer);
-    const canUseSingleKernel = preferSingleKernelWhenPossible && canRunSingleKernel(width, limits);
     uInstanceCount.value = instanceCount;
-    if (canUseSingleKernel) {
-      if (!singleKernel) {
-        singleKernel = buildSingleKernel([width, width, 1]);
-      }
-      renderer.compute(singleKernel, [1, 1, instanceCount]);
-      return;
-    }
     const [workgroupX, workgroupY] = clampWorkgroupToLimits(
       preferredWorkgroup,
       limits
@@ -446,6 +452,7 @@ function ArrayTextureBackend(edgeVertexCount, tileCount, options) {
     edgeVertexCount,
     tileCount
   );
+  tex.name = "terrainField";
   configureStorageTexture(tex, options.format, options.filter);
   return {
     backendType: "array-texture",
@@ -489,6 +496,7 @@ function AtlasBackend(edgeVertexCount, tileCount, options) {
   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",
@@ -545,40 +553,9 @@ function AtlasBackend(edgeVertexCount, tileCount, options) {
     }
   };
 }
-function Texture3DBackend(edgeVertexCount, tileCount, options) {
-  let currentEdgeVertexCount = edgeVertexCount;
-  let currentTileCount = tileCount;
-  const tex = new webgpu.StorageArrayTexture(
-    edgeVertexCount,
-    edgeVertexCount,
-    tileCount
-  );
-  configureStorageTexture(tex, options.format, options.filter);
-  return {
-    backendType: "texture-3d",
-    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 texture3DBackend(edgeVertexCount, tileCount, options) {
+  const storage = ArrayTextureBackend(edgeVertexCount, tileCount, options);
+  return { ...storage, backendType: "texture-3d" };
 }
 function tryGetDeviceLimits(renderer) {
   const backend = renderer;
@@ -592,7 +569,7 @@ function createTerrainFieldStorage(edgeVertexCount, tileCount, renderer, options
     return AtlasBackend(edgeVertexCount, tileCount, { filter, format });
   }
   if (forcedBackend === "texture-3d") {
-    return Texture3DBackend(edgeVertexCount, tileCount, { filter, format });
+    return texture3DBackend(edgeVertexCount, tileCount, { filter, format });
   }
   if (forcedBackend === "array-texture") {
     return ArrayTextureBackend(edgeVertexCount, tileCount, { filter, format });
@@ -627,7 +604,7 @@ function loadTerrainFieldElevation(storage, ix, iy, tileIndex) {
 }
 function loadTerrainFieldNormal(storage, ix, iy, tileIndex) {
   const raw = loadTerrainField(storage, ix, iy, tileIndex);
-  return tsl.vec2(raw.g, raw.b);
+  return tsl.vec3(raw.g, raw.b, raw.a);
 }
 function sampleTerrainField(storage, u, v, tileIndex) {
   return storage.sample(u, v, tileIndex);
@@ -635,12 +612,8 @@ function sampleTerrainField(storage, u, v, tileIndex) {
 function sampleTerrainFieldElevation(storage, u, v, tileIndex) {
   return sampleTerrainField(storage, u, v, tileIndex).r;
 }
-function sampleTerrainFieldNormal(storage, u, v, tileIndex) {
-  const raw = sampleTerrainField(storage, u, v, tileIndex);
-  return tsl.vec2(raw.g, raw.b);
-}
-function packTerrainFieldSample(height, normalXZ, extra = tsl.float(0)) {
-  return tsl.vec4(height, normalXZ.x, normalXZ.y, extra);
+function packTerrainFieldSample(height, normal) {
+  return tsl.vec4(height, normal.x, normal.y, normal.z);
 }
 
 const createElevation = (tile, uniforms, elevationFn) => {
@@ -665,99 +638,70 @@ const createElevation = (tile, uniforms, elevationFn) => {
   };
 };
 
-function createTileCompute(leafStorage, uniforms) {
-  const tileLevel = tsl.Fn(([nodeIndex]) => {
-    const nodeOffset = nodeIndex.mul(tsl.int(4));
-    return leafStorage.node.element(nodeOffset).toInt();
-  });
+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 nodeOffset = nodeIndex.mul(tsl.int(4));
-    const nodeX = leafStorage.node.element(nodeOffset.add(tsl.int(1))).toFloat();
-    const nodeY = leafStorage.node.element(nodeOffset.add(tsl.int(2))).toFloat();
-    return tsl.vec2(nodeX, nodeY);
-  });
-  const tileSize = tsl.Fn(([nodeIndex]) => {
-    const rootSize = uniforms.uRootSize.toVar();
-    const level = tileLevel(nodeIndex);
-    return tsl.float(rootSize).div(tsl.pow(tsl.float(2), level.toFloat()));
+    const tile = decodeLeafTile(leafStorage, nodeIndex);
+    return tsl.vec2(tile.x, tile.y);
   });
-  const rootUVCompute = tsl.Fn(([nodeIndex, ix, iy]) => {
-    const nodeVec2 = tileOriginVec2(nodeIndex);
-    const nodeX = nodeVec2.x;
-    const nodeY = nodeVec2.y;
-    const rootSize = uniforms.uRootSize.toVar();
-    const rootOrigin = uniforms.uRootOrigin.toVar();
-    const size = tileSize(nodeIndex);
-    const half = tsl.float(0.5);
-    const halfRoot = tsl.float(rootSize).mul(half);
+  const tileFaceUV = tsl.Fn(([nodeIndex, ix, iy]) => {
+    const tile = decodeLeafTile(leafStorage, nodeIndex);
     const fInnerSegments = uniforms.uInnerTileSegments.toVar().toFloat();
-    const texelSpacing = size.div(fInnerSegments);
-    const absX = nodeX.mul(fInnerSegments).add(tsl.int(ix).toFloat().sub(tsl.float(1)));
-    const absY = nodeY.mul(fInnerSegments).add(tsl.int(iy).toFloat().sub(tsl.float(1)));
-    const worldX = rootOrigin.x.add(absX.mul(texelSpacing)).sub(halfRoot);
-    const worldZ = rootOrigin.z.add(absY.mul(texelSpacing)).sub(halfRoot);
-    const centeredX = worldX.sub(rootOrigin.x);
-    const centeredZ = worldZ.sub(rootOrigin.z);
-    return tsl.vec2(
-      centeredX.div(rootSize).add(half),
-      centeredZ.div(rootSize).mul(tsl.float(-1)).add(half)
-    );
+    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 tileVertexWorldPositionCompute = tsl.Fn(
-    ([nodeIndex, ix, iy]) => {
-      const rootOrigin = uniforms.uRootOrigin.toVar();
-      const nodeVec2 = tileOriginVec2(nodeIndex);
-      const nodeX = nodeVec2.x;
-      const nodeY = nodeVec2.y;
-      const rootSize = uniforms.uRootSize.toVar();
-      const size = tileSize(nodeIndex);
-      const half = tsl.float(0.5);
-      const halfRoot = tsl.float(rootSize).mul(half);
-      const fInnerSegments = uniforms.uInnerTileSegments.toVar().toFloat();
-      const texelSpacing = size.div(fInnerSegments);
-      const absX = nodeX.mul(fInnerSegments).add(tsl.int(ix).toFloat().sub(tsl.float(1)));
-      const absY = nodeY.mul(fInnerSegments).add(tsl.int(iy).toFloat().sub(tsl.float(1)));
-      const worldX = rootOrigin.x.add(absX.mul(texelSpacing)).sub(halfRoot);
-      const worldZ = rootOrigin.z.add(absY.mul(texelSpacing)).sub(halfRoot);
-      return tsl.vec3(worldX, rootOrigin.y, worldZ);
-    }
-  );
+  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 {
-    tileLevel,
-    tileOriginVec2,
-    tileSize,
-    rootUVCompute,
-    tileVertexWorldPositionCompute
+    ...shared,
+    tileSize: parts.tileSize,
+    rootUVCompute: parts.rootUV,
+    tileVertexWorldPositionCompute: parts.tileVertexWorldPosition
   };
 }
-function tileLocalToFieldUV$1(localCoord, innerSegments) {
-  const edge = tsl.float(innerSegments).add(tsl.float(3));
-  return tsl.float(localCoord).mul(tsl.float(innerSegments)).add(tsl.float(1.5)).div(edge);
+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 rootSize = work.param(256).displayName("rootSize");
-const origin = work.param({
-  x: 0,
-  y: 0,
-  z: 0
-}).displayName("origin");
-const innerTileSegments = work.param(13).displayName("innerTileSegments");
-const skirtScale = work.param(100).displayName("skirtScale");
-const elevationScale = work.param(1).displayName("elevationScale");
-const maxNodes = work.param(1024).displayName("maxNodes");
-const maxLevel = work.param(16).displayName("maxLevel");
-const quadtreeUpdate = work.param({
-  cameraOrigin: { x: 0, y: 0, z: 0 },
-  mode: "distance",
-  distanceFactor: 1.5
-}).displayName("quadtreeUpdate");
-const surface = work.param(null).displayName("surface");
-const terrainFieldFilter = work.param("linear").displayName("terrainFieldFilter");
-const elevationFn = work.param(() => tsl.float(0));
 
 function createLeafStorage(maxNodes) {
   const data = new Int32Array(maxNodes * 4);
   const attribute = new webgpu.StorageBufferAttribute(data, 4);
+  attribute.name = "leafStorage";
   const node = tsl.storage(attribute, "i32", 1).toReadOnly().setName("leafStorage");
   return { data, attribute, node };
 }
@@ -850,12 +794,12 @@ function ensureChildren(store, parentId) {
   return childBase;
 }
 
-function nextPow2$1(n) {
+function nextPow2$2(n) {
   let x = 1;
   while (x < n) x <<= 1;
   return x;
 }
-function mix32$1(x) {
+function mix32$2(x) {
   x >>>= 0;
   x ^= x >>> 16;
   x = Math.imul(x, 2146121005) >>> 0;
@@ -864,12 +808,12 @@ function mix32$1(x) {
   x ^= x >>> 16;
   return x >>> 0;
 }
-function hashKey$1(space, level, x, y) {
-  const h = space & 255 ^ (level & 255) << 8 ^ mix32$1(x) >>> 0 ^ mix32$1(y) >>> 0;
-  return mix32$1(h);
+function hashKey$2(space, level, x, y) {
+  const h = space & 255 ^ (level & 255) << 8 ^ mix32$2(x) >>> 0 ^ mix32$2(y) >>> 0;
+  return mix32$2(h);
 }
 function createSpatialIndex(maxEntries) {
-  const size = nextPow2$1(Math.max(2, maxEntries * 2));
+  const size = nextPow2$2(Math.max(2, maxEntries * 2));
   return {
     size,
     mask: size - 1,
@@ -894,7 +838,7 @@ function insertSpatialIndexRaw(index, space, level, x, y, value) {
   const l = level & 255;
   const xx = x >>> 0;
   const yy = y >>> 0;
-  let slot = hashKey$1(s, l, xx, yy) & index.mask;
+  let slot = hashKey$2(s, l, xx, yy) & index.mask;
   for (let probes = 0; probes < index.size; probes++) {
     if (index.stamp[slot] !== index.stampGen) {
       index.stamp[slot] = index.stampGen;
@@ -918,7 +862,7 @@ function lookupSpatialIndexRaw(index, space, level, x, y) {
   const l = level & 255;
   const xx = x >>> 0;
   const yy = y >>> 0;
-  let slot = hashKey$1(s, l, xx, yy) & index.mask;
+  let slot = hashKey$2(s, l, xx, yy) & index.mask;
   for (let probes = 0; probes < index.size; probes++) {
     if (index.stamp[slot] !== index.stampGen) return U32_EMPTY;
     if (index.keysSpace[slot] === s && index.keysLevel[slot] === l && index.keysX[slot] === xx && index.keysY[slot] === yy) {
@@ -938,10 +882,10 @@ function buildLeafIndex(leaves, out) {
   return index;
 }
 
-function createState(cfg, surface) {
-  const store = createNodeStore(cfg.maxNodes, surface.spaceCount);
+function createState(cfg, topology) {
+  const store = createNodeStore(cfg.maxNodes, topology.spaceCount);
   const scratchRootTiles = [];
-  for (let i = 0; i < surface.maxRootCount; i++) {
+  for (let i = 0; i < topology.maxRootCount; i++) {
     scratchRootTiles.push({ space: 0, level: 0, x: 0, y: 0 });
   }
   return {
@@ -951,7 +895,7 @@ function createState(cfg, surface) {
     leafNodeIds: new Uint32Array(cfg.maxNodes),
     leafIndex: createSpatialIndex(cfg.maxNodes),
     stack: new Uint32Array(cfg.maxNodes),
-    rootNodeIds: new Uint32Array(surface.maxRootCount),
+    rootNodeIds: new Uint32Array(topology.maxRootCount),
     rootCount: 0,
     splitQueue: new Uint32Array(cfg.maxNodes),
     splitStamp: new Uint16Array(cfg.maxNodes),
@@ -959,26 +903,27 @@ function createState(cfg, surface) {
     scratchTile: { space: 0, level: 0, x: 0, y: 0 },
     scratchNeighbor: { space: 0, level: 0, x: 0, y: 0 },
     scratchBounds: { cx: 0, cy: 0, cz: 0, r: 0 },
+    scratchElevationRange: { min: 0, max: 0 },
     scratchRootTiles,
-    spaceCount: surface.spaceCount
+    spaceCount: topology.spaceCount
   };
 }
-function beginUpdate(state, surface, params) {
-  if (surface.spaceCount !== state.spaceCount) {
+function beginUpdate(state, topology, params) {
+  if (topology.spaceCount !== state.spaceCount) {
     throw new Error(
-      `Surface spaceCount changed (${state.spaceCount} -> ${surface.spaceCount}). Create a new quadtree state.`
+      `Topology spaceCount changed (${state.spaceCount} -> ${topology.spaceCount}). Create a new quadtree state.`
     );
   }
-  if (surface.maxRootCount !== state.rootNodeIds.length) {
+  if (topology.maxRootCount !== state.rootNodeIds.length) {
     throw new Error(
-      `Surface maxRootCount changed (${state.rootNodeIds.length} -> ${surface.maxRootCount}). Create a new quadtree state.`
+      `Topology maxRootCount changed (${state.rootNodeIds.length} -> ${topology.maxRootCount}). Create a new quadtree state.`
     );
   }
   beginFrame(state.store);
   state.rootCount = 0;
-  const rootCount = surface.rootTiles(params.cameraOrigin, state.scratchRootTiles);
-  if (rootCount < 0 || rootCount > surface.maxRootCount) {
-    throw new Error(`Surface returned invalid root count (${rootCount}).`);
+  const rootCount = topology.rootTiles(params.cameraOrigin, state.scratchRootTiles);
+  if (rootCount < 0 || rootCount > topology.maxRootCount) {
+    throw new Error(`Topology returned invalid root count (${rootCount}).`);
   }
   for (let i = 0; i < rootCount; i++) {
     const rootId = allocNode(state.store, state.scratchRootTiles[i]);
@@ -1015,7 +960,7 @@ function shouldSplit(bounds, level, maxLevel, params) {
   return safeDistSq < threshold * threshold;
 }
 
-function refineLeaves(state, surface, params, outLeaves) {
+function refineLeaves(state, topology, params, outLeaves) {
   const leaves = outLeaves ?? state.leaves;
   resetLeafSet(leaves);
   const store = state.store;
@@ -1036,7 +981,14 @@ function refineLeaves(state, surface, params, outLeaves) {
     tile.x = x;
     tile.y = y;
     const bounds = state.scratchBounds;
-    surface.tileBounds(tile, params.cameraOrigin, bounds);
+    let elevationRange;
+    if (params.tileElevationRange) {
+      const range = state.scratchElevationRange;
+      if (params.tileElevationRange(space, level, x, y, range)) {
+        elevationRange = range;
+      }
+    }
+    topology.tileBounds(tile, params.cameraOrigin, bounds, elevationRange);
     if (hasChildren(store, nodeId)) {
       const base = store.firstChild[nodeId];
       stack[sp++] = base + 3;
@@ -1084,7 +1036,7 @@ function scheduleSplit(state, nodeId, count) {
   state.splitQueue[count] = nodeId;
   return count + 1;
 }
-function balance2to1(state, surface, params, leaves) {
+function balance2to1(state, topology, params, leaves) {
   const maxIters = state.cfg.maxLevel + 1;
   for (let iter = 0; iter < maxIters; iter++) {
     const index = buildLeafIndex(leaves, state.leafIndex);
@@ -1105,7 +1057,7 @@ function balance2to1(state, surface, params, leaves) {
           tile.x = leafX >>> shift;
           tile.y = leafY >>> shift;
           const neighbor = state.scratchNeighbor;
-          if (!surface.neighborSameLevel(tile, dir, neighbor)) break;
+          if (!topology.neighborSameLevel(tile, dir, neighbor)) break;
           const j = lookupSpatialIndexRaw(
             index,
             neighbor.space,
@@ -1129,18 +1081,24 @@ function balance2to1(state, surface, params, leaves) {
       if (base !== U32_EMPTY) anySplit = true;
     }
     if (!anySplit) return leaves;
-    refineLeaves(state, surface, params, leaves);
+    refineLeaves(state, topology, params, leaves);
   }
   return leaves;
 }
 
-function update(state, surface, params, outLeaves) {
-  const origY = params.cameraOrigin.y;
-  params.cameraOrigin.y -= params.elevationAtCameraXZ ?? 0;
-  beginUpdate(state, surface, params);
-  const leaves = refineLeaves(state, surface, params, outLeaves);
-  const result = balance2to1(state, surface, params, leaves);
-  params.cameraOrigin.y = origY;
+function update(state, topology, params, outLeaves) {
+  const cam = params.cameraOrigin;
+  const elevation = params.elevationAtCameraXZ ?? 0;
+  const origX = cam.x;
+  const origY = cam.y;
+  const origZ = cam.z;
+  topology.projection.cpu.cameraSurfaceOffset(cam, elevation);
+  beginUpdate(state, topology, params);
+  const leaves = refineLeaves(state, topology, params, outLeaves);
+  const result = balance2to1(state, topology, params, leaves);
+  cam.x = origX;
+  cam.y = origY;
+  cam.z = origZ;
   return result;
 }
 
@@ -1148,7 +1106,7 @@ const scratchTile = { space: 0, level: 0, x: 0, y: 0 };
 const scratchNbr = { space: 0, level: 0, x: 0, y: 0 };
 const scratchParentTile = { space: 0, level: 0, x: 0, y: 0 };
 const scratchParentNbr = { space: 0, level: 0, x: 0, y: 0 };
-function buildSeams2to1(surface, leaves, outSeams, outIndex) {
+function buildSeams2to1(topology, leaves, outSeams, outIndex) {
   if (outSeams.capacity < leaves.count) {
     throw new Error("SeamTable capacity is smaller than LeafSet.count.");
   }
@@ -1169,7 +1127,7 @@ function buildSeams2to1(surface, leaves, outSeams, outIndex) {
       scratchTile.level = level;
       scratchTile.x = x;
       scratchTile.y = y;
-      if (!surface.neighborSameLevel(scratchTile, dir, scratchNbr)) continue;
+      if (!topology.neighborSameLevel(scratchTile, dir, scratchNbr)) continue;
       let j = lookupSpatialIndexRaw(index, scratchNbr.space, scratchNbr.level, scratchNbr.x, scratchNbr.y);
       if (j !== U32_EMPTY) {
         neighbors[outOffset + 0] = j;
@@ -1182,7 +1140,7 @@ function buildSeams2to1(surface, leaves, outSeams, outIndex) {
         scratchParentTile.level = level - 1;
         scratchParentTile.x = px;
         scratchParentTile.y = py;
-        if (surface.neighborSameLevel(scratchParentTile, dir, scratchParentNbr)) {
+        if (topology.neighborSameLevel(scratchParentTile, dir, scratchParentNbr)) {
           j = lookupSpatialIndexRaw(
             index,
             scratchParentNbr.space,
@@ -1238,157 +1196,2158 @@ function buildSeams2to1(surface, leaves, outSeams, outIndex) {
   return outSeams;
 }
 
-function createFlatSurface(cfg) {
-  const halfRoot = 0.5 * cfg.rootSize;
-  const maxHeight = cfg.maxHeight ?? 0;
-  const surface = {
-    spaceCount: 1,
-    maxRootCount: 1,
-    neighborSameLevel(tile, dir, out) {
-      const level = tile.level;
-      const x = tile.x;
-      const y = tile.y;
-      let nx = x;
-      let ny = y;
-      switch (dir) {
-        case Dir.LEFT:
-          nx = x - 1;
-          break;
-        case Dir.RIGHT:
-          nx = x + 1;
-          break;
-        case Dir.TOP:
-          ny = y - 1;
-          break;
-        case Dir.BOTTOM:
-          ny = y + 1;
-          break;
-      }
-      if (nx < 0 || ny < 0) return false;
-      const maxCoord = (1 << level) - 1;
-      if (nx > maxCoord || ny > maxCoord) return false;
-      out.space = 0;
-      out.level = level;
-      out.x = nx;
-      out.y = ny;
-      return true;
-    },
-    tileBounds(tile, cameraOrigin, out) {
-      const level = tile.level;
-      const scale = 1 / (1 << level);
-      const size = cfg.rootSize * scale;
-      const minX = cfg.origin.x + (tile.x * size - halfRoot);
-      const minZ = cfg.origin.z + (tile.y * size - halfRoot);
-      const centerX = minX + 0.5 * size;
-      const centerY = cfg.origin.y;
-      const centerZ = minZ + 0.5 * size;
-      out.cx = centerX - cameraOrigin.x;
-      out.cy = centerY - cameraOrigin.y;
-      out.cz = centerZ - cameraOrigin.z;
-      out.r = 0.7071067811865476 * size + maxHeight;
-    },
-    rootTiles(_cameraOrigin, out) {
-      const root = out[0];
-      root.space = 0;
-      root.level = 0;
-      root.x = 0;
-      root.y = 0;
-      return 1;
+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();
     }
-  };
-  return surface;
+  );
 }
-
-function createInfiniteFlatSurface(cfg) {
-  const halfRoot = 0.5 * cfg.rootSize;
-  const maxHeight = cfg.maxHeight ?? 0;
-  const rootGridRadius = Math.max(0, Math.floor(cfg.rootGridRadius ?? 1));
-  const rootWidth = rootGridRadius * 2 + 1;
-  return {
-    spaceCount: 1,
-    maxRootCount: rootWidth * rootWidth,
-    neighborSameLevel(tile, dir, out) {
-      let nx = tile.x;
-      let ny = tile.y;
-      switch (dir) {
-        case Dir.LEFT:
-          nx = tile.x - 1;
-          break;
-        case Dir.RIGHT:
-          nx = tile.x + 1;
-          break;
-        case Dir.TOP:
-          ny = tile.y - 1;
-          break;
-        case Dir.BOTTOM:
-          ny = tile.y + 1;
-          break;
-      }
-      out.space = tile.space;
-      out.level = tile.level;
-      out.x = nx;
-      out.y = ny;
-      return true;
-    },
-    tileBounds(tile, cameraOrigin, out) {
-      const level = tile.level;
-      const scale = 1 / (1 << level);
-      const size = cfg.rootSize * scale;
-      const minX = cfg.origin.x + (tile.x * size - halfRoot);
-      const minZ = cfg.origin.z + (tile.y * size - halfRoot);
-      const centerX = minX + 0.5 * size;
-      const centerY = cfg.origin.y;
-      const centerZ = minZ + 0.5 * size;
-      out.cx = centerX - cameraOrigin.x;
-      out.cy = centerY - cameraOrigin.y;
-      out.cz = centerZ - cameraOrigin.z;
-      out.r = 0.7071067811865476 * size + maxHeight;
-    },
-    rootTiles(cameraOrigin, out) {
-      const camRootX = Math.floor((cameraOrigin.x - cfg.origin.x + halfRoot) / cfg.rootSize);
-      const camRootY = Math.floor((cameraOrigin.z - cfg.origin.z + halfRoot) / cfg.rootSize);
-      let index = 0;
-      for (let dy = -rootGridRadius; dy <= rootGridRadius; dy++) {
-        for (let dx = -rootGridRadius; dx <= rootGridRadius; dx++) {
-          const root = out[index];
-          root.space = 0;
-          root.level = 0;
-          root.x = camRootX + dx;
-          root.y = camRootY + dy;
-          index++;
-        }
-      }
-      return index;
-    }
-  };
+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 createCubeSphereSurface(_cfg) {
+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);
+  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(
+    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);
+}
+function assignWorldNormal(terrainUniforms, terrainFieldStorage) {
+  if (!terrainFieldStorage) return;
+  tsl.normalLocal.assign(tsl.Fn(() => loadWorldNormal(terrainUniforms, terrainFieldStorage))());
+}
+function createFlatRenderVertexPosition(leafStorage, terrainUniforms, terrainFieldStorage) {
+  return tsl.Fn(() => {
+    const tile = decodeLeafTile(leafStorage, tsl.int(tsl.instanceIndex));
+    const rootSize = terrainUniforms.uRootSize.toVar();
+    const rootOrigin = terrainUniforms.uRootOrigin.toVar();
+    const half = tsl.float(0.5);
+    const size = rootSize.div(tsl.pow(tsl.float(2), tile.level.toFloat()));
+    const halfRoot = rootSize.mul(half);
+    const centerX = rootOrigin.x.add(tile.x.add(half).mul(size)).sub(halfRoot);
+    const centerZ = rootOrigin.z.add(tile.y.add(half).mul(size)).sub(halfRoot);
+    const clampedX = tsl.positionLocal.x.max(half.negate()).min(half);
+    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 skirtVertex = isSkirtVertex(terrainUniforms.uInnerTileSegments);
+    const baseY = rootOrigin.y.add(yElevation);
+    const skirtY = baseY.sub(terrainUniforms.uSkirtScale.toVar());
+    const worldY = tsl.select(skirtVertex, skirtY, baseY);
+    assignWorldNormal(terrainUniforms, terrainFieldStorage);
+    return tsl.vec3(worldX, worldY, worldZ);
+  })();
+}
+function createCurvedRenderVertexPosition(leafStorage, terrainUniforms, terrainFieldStorage, surfacePoint, baseU = 1, baseV = 1) {
+  const fBaseU = tsl.float(baseU);
+  const fBaseV = tsl.float(baseV);
+  return tsl.Fn(() => {
+    const tile = decodeLeafTile(leafStorage, tsl.int(tsl.instanceIndex));
+    const half = tsl.float(0.5);
+    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 skirtVertex = isSkirtVertex(terrainUniforms.uInnerTileSegments);
+    const displacement = tsl.select(
+      skirtVertex,
+      yElevation.sub(terrainUniforms.uSkirtScale.toVar()),
+      yElevation
+    );
+    assignWorldNormal(terrainUniforms, terrainFieldStorage);
+    return surfacePoint(tile, faceUV, displacement);
+  })();
+}
+
+const TWO_PI$2 = Math.PI * 2;
+function wrap01(t) {
+  const w = t - Math.floor(t);
+  return w >= 1 ? w - 1 : w;
+}
+function torusUVToPoint(u, v, majorRadius, minorRadius, displacement, center, out, invert = false) {
+  const theta = TWO_PI$2 * u;
+  const phi = TWO_PI$2 * v;
+  const sinT = Math.sin(theta);
+  const cosT = Math.cos(theta);
+  const sinP = Math.sin(phi);
+  const cosP = Math.cos(phi);
+  const disp = invert ? -displacement : displacement;
+  const tube = minorRadius + disp;
+  const ring = majorRadius + tube * cosP;
+  out[0] = center.x + ring * sinT;
+  out[1] = center.y + tube * sinP;
+  out[2] = center.z + ring * cosT;
+}
+function torusOutwardNormal$1(u, v, out, invert = false) {
+  const theta = TWO_PI$2 * u;
+  const phi = TWO_PI$2 * v;
+  const sinT = Math.sin(theta);
+  const cosT = Math.cos(theta);
+  const sinP = Math.sin(phi);
+  const cosP = Math.cos(phi);
+  const s = invert ? -1 : 1;
+  out[0] = cosP * sinT * s;
+  out[1] = sinP * s;
+  out[2] = cosP * cosT * s;
+}
+function positionToTorusParams(px, py, pz, majorRadius, center, out) {
+  const qx = px - center.x;
+  const qy = py - center.y;
+  const qz = pz - center.z;
+  const theta = Math.atan2(qx, qz);
+  const rho = Math.hypot(qx, qz);
+  const a = rho - majorRadius;
+  const phi = Math.atan2(qy, a);
+  out.u = wrap01(theta / TWO_PI$2);
+  out.v = wrap01(phi / TWO_PI$2);
+  out.tubeDistance = Math.hypot(a, qy);
+}
+
+function intersectRayAabb(ray, minX, minY, minZ, maxX, maxY, maxZ) {
+  let tMin = -Infinity;
+  let tMax = Infinity;
+  const origin = ray.origin;
+  const dir = ray.direction;
+  const slab = (originAxis, dirAxis, minAxis, maxAxis) => {
+    if (Math.abs(dirAxis) < 1e-8) {
+      if (originAxis < minAxis || originAxis > maxAxis) return false;
+      return true;
+    }
+    const inv = 1 / dirAxis;
+    let t0 = (minAxis - originAxis) * inv;
+    let t1 = (maxAxis - originAxis) * inv;
+    if (t0 > t1) {
+      const tmp = t0;
+      t0 = t1;
+      t1 = tmp;
+    }
+    tMin = Math.max(tMin, t0);
+    tMax = Math.min(tMax, t1);
+    return tMax >= tMin;
+  };
+  if (!slab(origin.x, dir.x, minX, maxX) || !slab(origin.y, dir.y, minY, maxY) || !slab(origin.z, dir.z, minZ, maxZ)) {
+    return null;
+  }
+  return { tMin, tMax };
+}
+function getTerrainBounds(config) {
+  const halfRoot = config.rootSize * 0.5;
+  return {
+    minX: config.originX - halfRoot,
+    maxX: config.originX + halfRoot,
+    minZ: config.originZ - halfRoot,
+    maxZ: config.originZ + halfRoot
+  };
+}
+function terrainSignedDistance(query, worldX, worldY, worldZ, skipBoundsFastPath) {
+  if (!skipBoundsFastPath) {
+    const tileBounds = query.getTileBounds(worldX, worldZ);
+    if (tileBounds) {
+      if (worldY > tileBounds.maxElevation) {
+        return worldY - tileBounds.maxElevation;
+      }
+      if (worldY < tileBounds.minElevation) {
+        return worldY - tileBounds.minElevation;
+      }
+    }
+  }
+  const elevation = query.getElevation(worldX, worldZ);
+  if (!Number.isFinite(elevation)) return void 0;
+  return worldY - elevation;
+}
+function marchSignedDistance(ray, startT, endT, stepSignedDistanceAt, refineSignedDistanceAt, options, point) {
+  let prevT = startT;
+  ray.at(prevT, point);
+  let prevSignedDistance = stepSignedDistanceAt(point.x, point.y, point.z);
+  if (prevSignedDistance !== void 0 && prevSignedDistance <= 0) {
+    return startT;
+  }
+  for (let i = 1; i <= options.maxSteps; i += 1) {
+    const t = startT + (endT - startT) * i / options.maxSteps;
+    ray.at(t, point);
+    const signedDistance = stepSignedDistanceAt(point.x, point.y, point.z);
+    if (signedDistance === void 0) {
+      prevSignedDistance = void 0;
+      prevT = t;
+      continue;
+    }
+    if (prevSignedDistance !== void 0 && prevSignedDistance > 0 && signedDistance <= 0) {
+      let lo = prevT;
+      let hi = t;
+      for (let r = 0; r < options.refinementSteps; r += 1) {
+        const mid = (lo + hi) * 0.5;
+        ray.at(mid, point);
+        const midDistance = refineSignedDistanceAt(point.x, point.y, point.z);
+        if (midDistance === void 0) {
+          lo = mid;
+          continue;
+        }
+        if (midDistance > 0) lo = mid;
+        else hi = mid;
+      }
+      return hi;
+    }
+    prevSignedDistance = signedDistance;
+    prevT = t;
+  }
+  return null;
+}
+function cpuRaycast(query, ray, config, options) {
+  const bounds = getTerrainBounds(config);
+  const segment = intersectRayAabb(
+    ray,
+    bounds.minX,
+    config.minY,
+    bounds.minZ,
+    bounds.maxX,
+    config.maxY,
+    bounds.maxZ
+  );
+  if (!segment) return null;
+  const maxDistance = options?.maxDistance ?? Number.POSITIVE_INFINITY;
+  const startT = Math.max(0, segment.tMin);
+  const endT = Math.min(segment.tMax, maxDistance);
+  if (endT < startT) return null;
+  const point = new three.Vector3();
+  const hitT = marchSignedDistance(
+    ray,
+    startT,
+    endT,
+    (px, py, pz) => terrainSignedDistance(query, px, py, pz, false),
+    (px, py, pz) => terrainSignedDistance(query, px, py, pz, true),
+    {
+      maxSteps: Math.max(8, options?.maxSteps ?? 128),
+      refinementSteps: Math.max(1, options?.refinementSteps ?? 8)
+    },
+    point
+  );
+  if (hitT === null) return null;
+  ray.at(hitT, point);
+  const sample = query.sampleTerrain(point.x, point.z);
+  if (!sample.valid) return null;
+  point.y = sample.elevation;
+  return {
+    position: point.clone(),
+    normal: sample.normal.clone(),
+    distance: ray.origin.distanceTo(point)
+  };
+}
+function cpuRaycastBoundsOnly(ray, config, options) {
+  const bounds = getTerrainBounds(config);
+  const planeY = (config.minY + config.maxY) * 0.5;
+  const dirY = ray.direction.y;
+  if (Math.abs(dirY) < 1e-8) return null;
+  const t = (planeY - ray.origin.y) / dirY;
+  if (t < 0) return null;
+  const maxDistance = options?.maxDistance ?? Number.POSITIVE_INFINITY;
+  if (t > maxDistance) return null;
+  const point = new three.Vector3();
+  ray.at(t, point);
+  if (point.x < bounds.minX || point.x > bounds.maxX || point.z < bounds.minZ || point.z > bounds.maxZ) {
+    return null;
+  }
+  return {
+    position: point,
+    normal: new three.Vector3(0, 1, 0),
+    distance: ray.origin.distanceTo(point)
+  };
+}
+function intersectRaySphere(ray, cx, cy, cz, radius) {
+  const ox = ray.origin.x - cx;
+  const oy = ray.origin.y - cy;
+  const oz = ray.origin.z - cz;
+  const dx = ray.direction.x;
+  const dy = ray.direction.y;
+  const dz = ray.direction.z;
+  const a = dx * dx + dy * dy + dz * dz;
+  const b = 2 * (ox * dx + oy * dy + oz * dz);
+  const c = ox * ox + oy * oy + oz * oz - radius * radius;
+  const disc = b * b - 4 * a * c;
+  if (disc < 0) return null;
+  const sqrtDisc = Math.sqrt(disc);
+  const inv2a = 1 / (2 * a);
+  return { t0: (-b - sqrtDisc) * inv2a, t1: (-b + sqrtDisc) * inv2a };
+}
+function sphereSignedDistance(query, params, px, py, pz, scratchDir) {
+  const dx = px - params.centerX;
+  const dy = py - params.centerY;
+  const dz = pz - params.centerZ;
+  const dist = Math.hypot(dx, dy, dz);
+  scratchDir.set(dx, dy, dz);
+  const elevation = query.getElevationByDirection(scratchDir);
+  if (elevation === null) return void 0;
+  const s = params.invert ? -1 : 1;
+  return s * (dist - (params.radius + s * elevation));
+}
+function cubeSphereRaycast(query, ray, params, options) {
+  const shell = intersectRaySphere(
+    ray,
+    params.centerX,
+    params.centerY,
+    params.centerZ,
+    params.maxRadius
+  );
+  if (!shell) return null;
+  const maxDistance = options?.maxDistance ?? Number.POSITIVE_INFINITY;
+  const startT = Math.max(0, shell.t0);
+  const endT = Math.min(shell.t1, maxDistance);
+  if (endT < startT) return null;
+  const scratchDir = new three.Vector3();
+  const point = new three.Vector3();
+  const signedDistanceAt = (px, py, pz) => sphereSignedDistance(query, params, px, py, pz, scratchDir);
+  const hitT = marchSignedDistance(
+    ray,
+    startT,
+    endT,
+    signedDistanceAt,
+    signedDistanceAt,
+    {
+      maxSteps: Math.max(8, options?.maxSteps ?? 256),
+      refinementSteps: Math.max(1, options?.refinementSteps ?? 12)
+    },
+    point
+  );
+  if (hitT === null) return null;
+  ray.at(hitT, point);
+  const sample = query.sampleTerrainByPosition(point);
+  if (!sample.valid) return null;
+  return {
+    position: sample.position.clone(),
+    normal: sample.normal.clone(),
+    distance: ray.origin.distanceTo(sample.position)
+  };
+}
+function cubeSphereRaycastBoundsOnly(ray, params, options) {
+  const shell = intersectRaySphere(ray, params.centerX, params.centerY, params.centerZ, params.radius);
+  if (!shell) return null;
+  const maxDistance = options?.maxDistance ?? Number.POSITIVE_INFINITY;
+  const t = shell.t0 >= 0 ? shell.t0 : shell.t1;
+  if (t < 0 || t > maxDistance) return null;
+  const point = new three.Vector3();
+  ray.at(t, point);
+  const normal = new three.Vector3(
+    point.x - params.centerX,
+    point.y - params.centerY,
+    point.z - params.centerZ
+  ).normalize();
+  if (params.invert) normal.negate();
+  return { position: point, normal, distance: ray.origin.distanceTo(point) };
+}
+function torusSignedDistance(query, params, px, py, pz, scratchPoint, scratchParams) {
+  positionToTorusParams(
+    px,
+    py,
+    pz,
+    params.majorRadius,
+    { x: params.centerX, y: params.centerY, z: params.centerZ },
+    scratchParams
+  );
+  scratchPoint.set(px, py, pz);
+  const elevation = query.getElevationByPosition(scratchPoint);
+  if (elevation === null) return void 0;
+  const s = params.invert ? -1 : 1;
+  return s * (scratchParams.tubeDistance - (params.minorRadius + s * elevation));
+}
+function torusRaycast(query, ray, params, options) {
+  const shell = intersectRaySphere(
+    ray,
+    params.centerX,
+    params.centerY,
+    params.centerZ,
+    params.outerRadius
+  );
+  if (!shell) return null;
+  const maxDistance = options?.maxDistance ?? Number.POSITIVE_INFINITY;
+  const startT = Math.max(0, shell.t0);
+  const endT = Math.min(shell.t1, maxDistance);
+  if (endT < startT) return null;
+  const scratchPoint = new three.Vector3();
+  const scratchParams = { u: 0, v: 0, tubeDistance: 0 };
+  const point = new three.Vector3();
+  const signedDistanceAt = (px, py, pz) => torusSignedDistance(query, params, px, py, pz, scratchPoint, scratchParams);
+  const hitT = marchSignedDistance(
+    ray,
+    startT,
+    endT,
+    signedDistanceAt,
+    signedDistanceAt,
+    {
+      maxSteps: Math.max(8, options?.maxSteps ?? 256),
+      refinementSteps: Math.max(1, options?.refinementSteps ?? 12)
+    },
+    point
+  );
+  if (hitT === null) return null;
+  ray.at(hitT, point);
+  const sample = query.sampleTerrainByPosition(point);
+  if (!sample.valid) return null;
+  return {
+    position: sample.position.clone(),
+    normal: sample.normal.clone(),
+    distance: ray.origin.distanceTo(sample.position)
+  };
+}
+function torusRaycastBoundsOnly(ray, params, options) {
+  const shell = intersectRaySphere(
+    ray,
+    params.centerX,
+    params.centerY,
+    params.centerZ,
+    params.outerRadius
+  );
+  if (!shell) return null;
+  const maxDistance = options?.maxDistance ?? Number.POSITIVE_INFINITY;
+  const t = shell.t0 >= 0 ? shell.t0 : shell.t1;
+  if (t < 0 || t > maxDistance) return null;
+  const point = new three.Vector3();
+  ray.at(t, point);
+  const normal = new three.Vector3(
+    point.x - params.centerX,
+    point.y - params.centerY,
+    point.z - params.centerZ
+  ).normalize();
+  if (params.invert) normal.negate();
+  return { position: point, normal, distance: ray.origin.distanceTo(point) };
+}
+
+function createTerrainQuery(cache) {
+  return {
+    get generation() {
+      return cache.generation;
+    },
+    getElevation(worldX, worldZ) {
+      return cache.getElevation(worldX, worldZ);
+    },
+    getNormal(worldX, worldZ) {
+      return cache.getNormal(worldX, worldZ);
+    },
+    getTile(worldX, worldZ) {
+      return cache.getTile(worldX, worldZ);
+    },
+    getTileBounds(worldX, worldZ) {
+      return cache.getTileBounds(worldX, worldZ);
+    },
+    getGlobalElevationRange() {
+      return cache.getGlobalElevationRange();
+    },
+    sampleTerrain(worldX, worldZ) {
+      return cache.sampleTerrain(worldX, worldZ);
+    },
+    sampleTerrainBatch(positions) {
+      return cache.sampleTerrainBatch(positions);
+    }
+  };
+}
+function createTerrainSurfaceQuery(cache) {
+  return {
+    get generation() {
+      return cache.generation;
+    },
+    getElevationByPosition(position) {
+      return cache.getElevationBySurfacePosition(position.x, position.y, position.z);
+    },
+    getNormalByPosition(position) {
+      return cache.getNormalBySurfacePosition(position.x, position.y, position.z);
+    },
+    sampleTerrainByPosition(position) {
+      return cache.sampleSurfaceByPosition(position.x, position.y, position.z);
+    },
+    getTileByPosition(position) {
+      return cache.getTileBySurfacePosition(position.x, position.y, position.z);
+    },
+    getTileBoundsByPosition(position) {
+      return cache.getTileBoundsBySurfacePosition(position.x, position.y, position.z);
+    },
+    sampleTerrainBatchByPosition(positions) {
+      return cache.sampleSurfaceBatchByPosition(positions);
+    }
+  };
+}
+
+function createFlatTileComputeParts(ctx) {
+  const { uniforms, shared } = ctx;
+  const tileSize = tsl.Fn(([nodeIndex]) => {
+    const level = shared.tileLevel(nodeIndex);
+    const divisor = tsl.pow(tsl.float(2), level.toFloat());
+    return tsl.float(uniforms.uRootSize.toVar()).div(divisor);
+  });
+  const rootUV = tsl.Fn(([nodeIndex, ix, iy]) => {
+    const nodeVec2 = shared.tileOriginVec2(nodeIndex);
+    const nodeX = nodeVec2.x;
+    const nodeY = nodeVec2.y;
+    const rootSize = uniforms.uRootSize.toVar();
+    const rootOrigin = uniforms.uRootOrigin.toVar();
+    const size = tileSize(nodeIndex);
+    const half = tsl.float(0.5);
+    const halfRoot = tsl.float(rootSize).mul(half);
+    const fInnerSegments = uniforms.uInnerTileSegments.toVar().toFloat();
+    const texelSpacing = size.div(fInnerSegments);
+    const absX = nodeX.mul(fInnerSegments).add(tsl.int(ix).toFloat().sub(tsl.float(1)));
+    const absY = nodeY.mul(fInnerSegments).add(tsl.int(iy).toFloat().sub(tsl.float(1)));
+    const worldX = rootOrigin.x.add(absX.mul(texelSpacing)).sub(halfRoot);
+    const worldZ = rootOrigin.z.add(absY.mul(texelSpacing)).sub(halfRoot);
+    const centeredX = worldX.sub(rootOrigin.x);
+    const centeredZ = worldZ.sub(rootOrigin.z);
+    return tsl.vec2(
+      centeredX.div(rootSize).add(half),
+      centeredZ.div(rootSize).mul(tsl.float(-1)).add(half)
+    );
+  });
+  const tileVertexWorldPosition = tsl.Fn(([nodeIndex, ix, iy]) => {
+    const rootOrigin = uniforms.uRootOrigin.toVar();
+    const nodeVec2 = shared.tileOriginVec2(nodeIndex);
+    const nodeX = nodeVec2.x;
+    const nodeY = nodeVec2.y;
+    const rootSize = uniforms.uRootSize.toVar();
+    const size = tileSize(nodeIndex);
+    const half = tsl.float(0.5);
+    const halfRoot = tsl.float(rootSize).mul(half);
+    const fInnerSegments = uniforms.uInnerTileSegments.toVar().toFloat();
+    const texelSpacing = size.div(fInnerSegments);
+    const absX = nodeX.mul(fInnerSegments).add(tsl.int(ix).toFloat().sub(tsl.float(1)));
+    const absY = nodeY.mul(fInnerSegments).add(tsl.int(iy).toFloat().sub(tsl.float(1)));
+    const worldX = rootOrigin.x.add(absX.mul(texelSpacing)).sub(halfRoot);
+    const worldZ = rootOrigin.z.add(absY.mul(texelSpacing)).sub(halfRoot);
+    return tsl.vec3(worldX, rootOrigin.y, worldZ);
+  });
+  return {
+    tileSize: (nodeIndex) => tileSize(nodeIndex),
+    rootUV: (nodeIndex, ix, iy) => rootUV(nodeIndex, ix, iy),
+    tileVertexWorldPosition: (nodeIndex, ix, iy) => tileVertexWorldPosition(nodeIndex, ix, iy)
+  };
+}
+function createFlatProjection() {
+  return {
+    kind: "flat",
+    faceOutward: false,
+    gpu: {
+      renderVertexPosition(ctx) {
+        return createFlatRenderVertexPosition(ctx.leafStorage, ctx.uniforms, ctx.terrainFieldStorage);
+      },
+      createTileComputeParts: createFlatTileComputeParts,
+      createFieldNormal(ctx) {
+        const computeNormal = createFlatNormalFromElevationField(
+          ctx.elevationFieldNode,
+          ctx.edgeVertexCount
+        );
+        return (nodeIndex, ix, iy) => computeNormal(nodeIndex, ctx.tile.tileSize(nodeIndex), ix, iy, ctx.uniforms.uElevationScale);
+      }
+    },
+    cpu: {
+      cameraSurfaceOffset(cam, elevation) {
+        cam.y -= elevation;
+      },
+      createSurfaceOps() {
+        return null;
+      },
+      createRuntimeQueries(cache) {
+        return { query: createTerrainQuery(cache), surfaceQuery: null, sphereQuery: null };
+      },
+      raycast(ctx) {
+        const { ray, options, terrainQuery, config } = ctx;
+        if (terrainQuery) {
+          const precise = cpuRaycast(terrainQuery, ray, config, options);
+          if (precise) return precise;
+        }
+        const coarse = cpuRaycastBoundsOnly(ray, config, options);
+        if (coarse && terrainQuery) {
+          const sample = terrainQuery.sampleTerrain(coarse.position.x, coarse.position.z);
+          if (sample.valid) {
+            coarse.position.y = sample.elevation;
+            coarse.normal.copy(sample.normal);
+          }
+        }
+        return coarse;
+      }
+    }
+  };
+}
+
+function createFlatTopology(cfg) {
+  const halfRoot = 0.5 * cfg.rootSize;
+  const topology = {
+    spaceCount: 1,
+    maxRootCount: 1,
+    projection: createFlatProjection(),
+    neighborSameLevel(tile, dir, out) {
+      const level = tile.level;
+      const x = tile.x;
+      const y = tile.y;
+      let nx = x;
+      let ny = y;
+      switch (dir) {
+        case Dir.LEFT:
+          nx = x - 1;
+          break;
+        case Dir.RIGHT:
+          nx = x + 1;
+          break;
+        case Dir.TOP:
+          ny = y - 1;
+          break;
+        case Dir.BOTTOM:
+          ny = y + 1;
+          break;
+      }
+      if (nx < 0 || ny < 0) return false;
+      const maxCoord = (1 << level) - 1;
+      if (nx > maxCoord || ny > maxCoord) return false;
+      out.space = 0;
+      out.level = level;
+      out.x = nx;
+      out.y = ny;
+      return true;
+    },
+    tileBounds(tile, cameraOrigin, out, elevationRange) {
+      const level = tile.level;
+      const scale = 1 / (1 << level);
+      const size = cfg.rootSize * scale;
+      const minX = cfg.origin.x + (tile.x * size - halfRoot);
+      const minZ = cfg.origin.z + (tile.y * size - halfRoot);
+      const centerX = minX + 0.5 * size;
+      const centerZ = minZ + 0.5 * size;
+      const centerY = cfg.origin.y + (elevationRange ? (elevationRange.min + elevationRange.max) * 0.5 : 0);
+      out.cx = centerX - cameraOrigin.x;
+      out.cy = centerY - cameraOrigin.y;
+      out.cz = centerZ - cameraOrigin.z;
+      const halfDiag = 0.7071067811865476 * size;
+      const vertExtent = elevationRange ? Math.max(Math.abs(elevationRange.min), Math.abs(elevationRange.max)) : 0;
+      out.r = halfDiag + vertExtent;
+    },
+    rootTiles(_cameraOrigin, out) {
+      const root = out[0];
+      root.space = 0;
+      root.level = 0;
+      root.x = 0;
+      root.y = 0;
+      return 1;
+    }
+  };
+  return topology;
+}
+
+function createInfiniteFlatTopology(cfg) {
+  const halfRoot = 0.5 * cfg.rootSize;
+  const rootGridRadius = Math.max(0, Math.floor(cfg.rootGridRadius ?? 1));
+  const rootWidth = rootGridRadius * 2 + 1;
+  return {
+    spaceCount: 1,
+    maxRootCount: rootWidth * rootWidth,
+    projection: createFlatProjection(),
+    neighborSameLevel(tile, dir, out) {
+      let nx = tile.x;
+      let ny = tile.y;
+      switch (dir) {
+        case Dir.LEFT:
+          nx = tile.x - 1;
+          break;
+        case Dir.RIGHT:
+          nx = tile.x + 1;
+          break;
+        case Dir.TOP:
+          ny = tile.y - 1;
+          break;
+        case Dir.BOTTOM:
+          ny = tile.y + 1;
+          break;
+      }
+      out.space = tile.space;
+      out.level = tile.level;
+      out.x = nx;
+      out.y = ny;
+      return true;
+    },
+    tileBounds(tile, cameraOrigin, out, elevationRange) {
+      const level = tile.level;
+      const scale = 1 / (1 << level);
+      const size = cfg.rootSize * scale;
+      const minX = cfg.origin.x + (tile.x * size - halfRoot);
+      const minZ = cfg.origin.z + (tile.y * size - halfRoot);
+      const centerX = minX + 0.5 * size;
+      const centerZ = minZ + 0.5 * size;
+      const centerY = cfg.origin.y + (elevationRange ? (elevationRange.min + elevationRange.max) * 0.5 : 0);
+      out.cx = centerX - cameraOrigin.x;
+      out.cy = centerY - cameraOrigin.y;
+      out.cz = centerZ - cameraOrigin.z;
+      const halfDiag = 0.7071067811865476 * size;
+      const vertExtent = elevationRange ? Math.max(Math.abs(elevationRange.min), Math.abs(elevationRange.max)) : 0;
+      out.r = halfDiag + vertExtent;
+    },
+    rootTiles(cameraOrigin, out) {
+      const camRootX = Math.floor((cameraOrigin.x - cfg.origin.x + halfRoot) / cfg.rootSize);
+      const camRootY = Math.floor((cameraOrigin.z - cfg.origin.z + halfRoot) / cfg.rootSize);
+      let index = 0;
+      for (let dy = -rootGridRadius; dy <= rootGridRadius; dy++) {
+        for (let dx = -rootGridRadius; dx <= rootGridRadius; dx++) {
+          const root = out[index];
+          root.space = 0;
+          root.level = 0;
+          root.x = camRootX + dx;
+          root.y = camRootY + dy;
+          index++;
+        }
+      }
+      return index;
+    }
+  };
+}
+
+const CUBE_FACE_COUNT = 6;
+const CUBE_FACES = [
+  // 0: +X
+  { forward: [1, 0, 0], right: [0, 0, -1], up: [0, 1, 0] },
+  // 1: -X
+  { forward: [-1, 0, 0], right: [0, 0, 1], up: [0, 1, 0] },
+  // 2: +Y (north pole)
+  { forward: [0, 1, 0], right: [1, 0, 0], up: [0, 0, -1] },
+  // 3: -Y (south pole)
+  { forward: [0, -1, 0], right: [1, 0, 0], up: [0, 0, 1] },
+  // 4: +Z
+  { forward: [0, 0, 1], right: [1, 0, 0], up: [0, 1, 0] },
+  // 5: -Z
+  { forward: [0, 0, -1], right: [-1, 0, 0], up: [0, 1, 0] }
+];
+
+function vec3Const(v) {
+  return tsl.vec3(tsl.float(v[0]), tsl.float(v[1]), tsl.float(v[2]));
+}
+function selectFaceVec3(face, pick) {
+  const last = CUBE_FACES.length - 1;
+  let acc = vec3Const(pick(CUBE_FACES[last]));
+  for (let i = last - 1; i >= 0; i--) {
+    acc = tsl.select(tsl.int(face).equal(tsl.int(i)), vec3Const(pick(CUBE_FACES[i])), acc);
+  }
+  return acc;
+}
+function cubeFaceBasis(face) {
+  return {
+    forward: selectFaceVec3(face, (f) => f.forward),
+    right: selectFaceVec3(face, (f) => f.right),
+    up: selectFaceVec3(face, (f) => f.up)
+  };
+}
+function cubeFacePoint(basis, u, v) {
+  const s = tsl.float(u).mul(2).sub(1);
+  const t = tsl.float(v).mul(2).sub(1);
+  return basis.forward.add(basis.right.mul(s)).add(basis.up.mul(t));
+}
+function cubeFaceDirection(basis, u, v) {
+  return cubeFacePoint(basis, u, v).normalize();
+}
+function tangentFromAxis(dir, axis) {
+  return axis.sub(dir.mul(dir.dot(axis))).normalize();
+}
+function unpackTangentNormal(nx, nz) {
+  const ny = tsl.float(1).sub(nx.mul(nx)).sub(nz.mul(nz)).max(tsl.float(0)).sqrt();
+  return tsl.vec3(nx, ny, nz);
+}
+function sphereTangentFrameNormal(dir, basis, tangentNormal) {
+  const n = tsl.vec3(tangentNormal);
+  const tu = tangentFromAxis(dir, basis.right);
+  const tv = tangentFromAxis(dir, basis.up);
+  return tu.mul(n.x).add(dir.mul(n.y)).add(tv.mul(n.z)).normalize();
+}
+function cubeFaceFromDirection(dir) {
+  const d = tsl.vec3(dir);
+  const ax = d.x.abs();
+  const ay = d.y.abs();
+  const az = d.z.abs();
+  const faceX = tsl.select(d.x.greaterThanEqual(tsl.float(0)), tsl.int(0), tsl.int(1));
+  const faceY = tsl.select(d.y.greaterThanEqual(tsl.float(0)), tsl.int(2), tsl.int(3));
+  const faceZ = tsl.select(d.z.greaterThanEqual(tsl.float(0)), tsl.int(4), tsl.int(5));
+  const xDominant = ax.greaterThanEqual(ay).and(ax.greaterThanEqual(az));
+  const yDominant = ay.greaterThanEqual(ax).and(ay.greaterThanEqual(az));
+  return tsl.select(xDominant, faceX, tsl.select(yDominant, faceY, faceZ));
+}
+function cubeFaceUVFromDirection(basis, dir) {
+  const d = tsl.vec3(dir);
+  const p = d.div(d.dot(basis.forward));
+  const s = p.dot(basis.right);
+  const t = p.dot(basis.up);
+  return tsl.vec2(s.add(tsl.float(1)).mul(tsl.float(0.5)), t.add(tsl.float(1)).mul(tsl.float(0.5)));
+}
+
+const DEG_TO_RAD = Math.PI / 180;
+const RAD_TO_DEG = 180 / Math.PI;
+function dot(a, b) {
+  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+function faceUVToCube(face, u, v, out) {
+  const f = CUBE_FACES[face];
+  const s = 2 * u - 1;
+  const t = 2 * v - 1;
+  out[0] = f.forward[0] + s * f.right[0] + t * f.up[0];
+  out[1] = f.forward[1] + s * f.right[1] + t * f.up[1];
+  out[2] = f.forward[2] + s * f.right[2] + t * f.up[2];
+}
+function directionToFace(d) {
+  const ax = Math.abs(d[0]);
+  const ay = Math.abs(d[1]);
+  const az = Math.abs(d[2]);
+  if (ax >= ay && ax >= az) return d[0] >= 0 ? 0 : 1;
+  if (ay >= ax && ay >= az) return d[1] >= 0 ? 2 : 3;
+  return d[2] >= 0 ? 4 : 5;
+}
+function directionToFaceUV(face, d, out) {
+  const f = CUBE_FACES[face];
+  const denom = dot(d, f.forward);
+  const inv = 1 / denom;
+  const px = d[0] * inv;
+  const py = d[1] * inv;
+  const pz = d[2] * inv;
+  const p = [px, py, pz];
+  const s = dot(p, f.right);
+  const t = dot(p, f.up);
+  out[0] = (s + 1) * 0.5;
+  out[1] = (t + 1) * 0.5;
+}
+function latLongToDirection(latDeg, lonDeg, out) {
+  const lat = latDeg * DEG_TO_RAD;
+  const lon = lonDeg * DEG_TO_RAD;
+  const cosLat = Math.cos(lat);
+  out[0] = cosLat * Math.sin(lon);
+  out[1] = Math.sin(lat);
+  out[2] = cosLat * Math.cos(lon);
+}
+function directionToLatLong(d) {
+  const len = Math.hypot(d[0], d[1], d[2]) || 1;
+  const y = Math.max(-1, Math.min(1, d[1] / len));
+  return {
+    latitude: Math.asin(y) * RAD_TO_DEG,
+    longitude: Math.atan2(d[0], d[2]) * RAD_TO_DEG
+  };
+}
+
+function readHeight(elevation, shape, leafIndex, ix, iy) {
+  const base = leafIndex * shape.verticesPerNode;
+  return elevation[base + iy * shape.edgeVertexCount + ix] ?? 0;
+}
+function sampleGridBilinear(elevation, shape, leafIndex, gx, gy) {
+  const max = shape.edgeVertexCount - 1;
+  const x = Math.max(0, Math.min(max, gx));
+  const y = Math.max(0, Math.min(max, gy));
+  const x0 = Math.floor(x);
+  const y0 = Math.floor(y);
+  const x1 = Math.min(max, x0 + 1);
+  const y1 = Math.min(max, y0 + 1);
+  const tx = x - x0;
+  const ty = y - y0;
+  const h00 = readHeight(elevation, shape, leafIndex, x0, y0);
+  const h10 = readHeight(elevation, shape, leafIndex, x1, y0);
+  const h01 = readHeight(elevation, shape, leafIndex, x0, y1);
+  const h11 = readHeight(elevation, shape, leafIndex, x1, y1);
+  const hx0 = h00 + (h10 - h00) * tx;
+  const hx1 = h01 + (h11 - h01) * tx;
+  return hx0 + (hx1 - hx0) * ty;
+}
+function elevationGradientAt(elevation, shape, leafIndex, gx, gy, stepWorld, elevationScale, out) {
+  const hLeft = sampleGridBilinear(elevation, shape, leafIndex, gx - 1, gy);
+  const hRight = sampleGridBilinear(elevation, shape, leafIndex, gx + 1, gy);
+  const hUp = sampleGridBilinear(elevation, shape, leafIndex, gx, gy - 1);
+  const hDown = sampleGridBilinear(elevation, shape, leafIndex, gx, gy + 1);
+  const inv2Step = 0.5 / stepWorld;
+  out.dhdu = (hRight - hLeft) * elevationScale * inv2Step;
+  out.dhdv = (hDown - hUp) * elevationScale * inv2Step;
+  return out;
+}
+
+function createElevationFunction(callback) {
+  const tslFunction = (args) => {
+    const params = {
+      worldPosition: args.worldPosition,
+      rootSize: args.rootSize,
+      rootUV: args.rootUV,
+      tileUV: args.tileUV,
+      tileLevel: args.tileLevel,
+      tileSize: args.tileSize,
+      tileOriginVec2: args.tileOriginVec2,
+      nodeIndex: args.nodeIndex
+    };
+    return callback(params);
+  };
+  return TSL_js.Fn(tslFunction);
+}
+
+const SLOT_STRIDE = 6;
+function nextPow2$1(n) {
+  let x = 1;
+  while (x < n) x <<= 1;
+  return x;
+}
+function createGpuSpatialIndex(maxEntries) {
+  const size = nextPow2$1(Math.max(2, maxEntries * 2));
+  const data = new Uint32Array(size * SLOT_STRIDE);
+  const attribute = new webgpu.StorageBufferAttribute(data, SLOT_STRIDE);
+  attribute.name = "gpuSpatialIndex";
+  const node = tsl.storage(attribute, "u32", 1).toReadOnly().setName("gpuSpatialIndex");
+  const stampGen = tsl.uniform(tsl.uint(1)).setName("uGpuSpatialIndexStampGen");
+  return {
+    data,
+    size,
+    mask: size - 1,
+    stampGen,
+    attribute,
+    node
+  };
+}
+function uploadGpuSpatialIndex(gpuIndex, cpuIndex) {
+  if (gpuIndex.size !== cpuIndex.size) {
+    throw new Error(
+      `Spatial index size mismatch (gpu=${gpuIndex.size}, cpu=${cpuIndex.size}).`
+    );
+  }
+  for (let i = 0; i < cpuIndex.size; i += 1) {
+    const base = i * SLOT_STRIDE;
+    gpuIndex.data[base] = cpuIndex.stamp[i] ?? 0;
+    gpuIndex.data[base + 1] = cpuIndex.keysSpace[i] ?? 0;
+    gpuIndex.data[base + 2] = cpuIndex.keysLevel[i] ?? 0;
+    gpuIndex.data[base + 3] = cpuIndex.keysX[i] ?? 0;
+    gpuIndex.data[base + 4] = cpuIndex.keysY[i] ?? 0;
+    gpuIndex.data[base + 5] = cpuIndex.values[i] ?? 0;
+  }
+  gpuIndex.stampGen.value = cpuIndex.stampGen >>> 0;
+  gpuIndex.attribute.needsUpdate = true;
+  gpuIndex.node.needsUpdate = true;
+}
+function readGpuSpatialIndexValue(spatialIndex, slot, fieldOffset) {
+  const offset = tsl.int(slot).mul(tsl.int(SLOT_STRIDE)).add(tsl.int(fieldOffset));
+  return spatialIndex.node.element(offset).toUint();
+}
+const mix32$1 = tsl.Fn(([x]) => {
+  const v = tsl.uint(x).toVar();
+  v.assign(v.bitXor(v.shiftRight(tsl.uint(16))));
+  v.assign(v.mul(tsl.uint(2146121005)));
+  v.assign(v.bitXor(v.shiftRight(tsl.uint(15))));
+  v.assign(v.mul(tsl.uint(2221713035)));
+  v.assign(v.bitXor(v.shiftRight(tsl.uint(16))));
+  return v;
+});
+const hashKey$1 = tsl.Fn(([space, level, x, y]) => {
+  const s = tsl.uint(space).bitAnd(tsl.uint(255));
+  const l = tsl.uint(level).bitAnd(tsl.uint(255));
+  const h = s.bitXor(l.shiftLeft(tsl.uint(8))).bitXor(mix32$1(tsl.uint(x))).bitXor(mix32$1(tsl.uint(y)));
+  return mix32$1(h);
+});
+const createGpuSpatialLookup = (spatialIndex) => {
+  const slotCount = spatialIndex.size;
+  const mask = tsl.uint(spatialIndex.mask);
+  const stampGen = spatialIndex.stampGen.toUint();
+  const emptyValue = tsl.int(-1);
+  return tsl.Fn(([space, level, x, y]) => {
+    const s = tsl.uint(space).bitAnd(tsl.uint(255));
+    const l = tsl.uint(level).bitAnd(tsl.uint(255));
+    const xx = tsl.uint(x);
+    const yy = tsl.uint(y);
+    const result = emptyValue.toVar();
+    const slot = hashKey$1(s, l, xx, yy).bitAnd(mask).toVar();
+    const probes = tsl.int(0).toVar();
+    tsl.Loop(slotCount, () => {
+      const stamp = readGpuSpatialIndexValue(spatialIndex, slot, 0);
+      tsl.If(stamp.notEqual(stampGen), () => {
+        tsl.Break();
+      });
+      const ks = readGpuSpatialIndexValue(spatialIndex, slot, 1);
+      const kl = readGpuSpatialIndexValue(spatialIndex, slot, 2);
+      const kx = readGpuSpatialIndexValue(spatialIndex, slot, 3);
+      const ky = readGpuSpatialIndexValue(spatialIndex, slot, 4);
+      tsl.If(
+        ks.equal(s).and(kl.equal(l)).and(kx.equal(xx)).and(ky.equal(yy)),
+        () => {
+          result.assign(tsl.int(readGpuSpatialIndexValue(spatialIndex, slot, 5)));
+          tsl.Break();
+        }
+      );
+      slot.assign(slot.add(tsl.uint(1)).bitAnd(mask));
+      probes.addAssign(1);
+    });
+    return result;
+  });
+};
+const createTileIndexFromWorldPosition = (spatialIndex, uniforms, maxLevel) => {
+  const lookup = createGpuSpatialLookup(spatialIndex);
+  const levelCount = Math.max(1, maxLevel + 1);
+  return tsl.Fn(([worldX, worldZ]) => {
+    const rootOrigin = uniforms.uRootOrigin.toVar();
+    const rootSize = uniforms.uRootSize.toVar();
+    const halfRoot = rootSize.mul(tsl.float(0.5));
+    const tileIndex = tsl.int(-1).toVar();
+    const tileU = tsl.float(0).toVar();
+    const tileV = tsl.float(0).toVar();
+    const i = tsl.int(0).toVar();
+    tsl.Loop(levelCount, () => {
+      const level = tsl.int(maxLevel).sub(i).toVar();
+      const scale = tsl.pow(tsl.float(2), level.toFloat());
+      const tileSize = rootSize.div(scale);
+      const tileX = worldX.sub(rootOrigin.x).add(halfRoot).div(tileSize).floor().toInt();
+      const tileY = worldZ.sub(rootOrigin.z).add(halfRoot).div(tileSize).floor().toInt();
+      const maybeIndex = lookup(tsl.int(0), level, tileX, tileY).toVar();
+      tsl.If(maybeIndex.greaterThanEqual(tsl.int(0)), () => {
+        const minX = rootOrigin.x.add(tileX.toFloat().mul(tileSize)).sub(halfRoot);
+        const minZ = rootOrigin.z.add(tileY.toFloat().mul(tileSize)).sub(halfRoot);
+        tileIndex.assign(maybeIndex);
+        tileU.assign(worldX.sub(minX).div(tileSize));
+        tileV.assign(worldZ.sub(minZ).div(tileSize));
+        tsl.Break();
+      });
+      i.addAssign(1);
+    });
+    return tsl.vec3(tileIndex.toFloat(), tileU, tileV);
+  });
+};
+const createTileIndexFromDirection = (spatialIndex, maxLevel) => {
+  const lookup = createGpuSpatialLookup(spatialIndex);
+  const levelCount = Math.max(1, maxLevel + 1);
+  return tsl.Fn(([direction]) => {
+    const dir = tsl.vec3(direction).normalize().toVar();
+    const face = cubeFaceFromDirection(dir).toVar();
+    const basis = cubeFaceBasis(face);
+    const faceUV = cubeFaceUVFromDirection(basis, dir).toVar();
+    const u = faceUV.x.toVar();
+    const v = faceUV.y.toVar();
+    const tileIndex = tsl.int(-1).toVar();
+    const tileU = tsl.float(0).toVar();
+    const tileV = tsl.float(0).toVar();
+    const i = tsl.int(0).toVar();
+    tsl.Loop(levelCount, () => {
+      const level = tsl.int(maxLevel).sub(i).toVar();
+      const n = tsl.pow(tsl.float(2), level.toFloat()).toVar();
+      const nInt = tsl.int(n).toVar();
+      const tileX = u.mul(n).floor().toInt().max(tsl.int(0)).min(nInt.sub(tsl.int(1))).toVar();
+      const tileY = v.mul(n).floor().toInt().max(tsl.int(0)).min(nInt.sub(tsl.int(1))).toVar();
+      const maybeIndex = lookup(face, level, tileX, tileY).toVar();
+      tsl.If(maybeIndex.greaterThanEqual(tsl.int(0)), () => {
+        tileIndex.assign(maybeIndex);
+        tileU.assign(u.mul(n).sub(tileX.toFloat()));
+        tileV.assign(v.mul(n).sub(tileY.toFloat()));
+        tsl.Break();
+      });
+      i.addAssign(1);
+    });
+    return tsl.vec3(tileIndex.toFloat(), tileU, tileV);
+  });
+};
+
+function packedSampleFromTileResult(params, tileResult) {
+  const tileIndex = tsl.int(tileResult.x).toVar();
+  const safeTileIndex = tileIndex.max(tsl.int(0)).toVar();
+  const fieldU = tileLocalToFieldUV(
+    tileResult.y,
+    params.uniforms.uInnerTileSegments
+  ).toVar();
+  const fieldV = tileLocalToFieldUV(
+    tileResult.z,
+    params.uniforms.uInnerTileSegments
+  ).toVar();
+  const found = tileIndex.greaterThanEqual(tsl.int(0)).toVar();
+  const sampled = sampleTerrainField(
+    params.terrainFieldStorage,
+    fieldU,
+    fieldV,
+    safeTileIndex
+  ).toVar();
+  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);
+}
+function createTerrainSampleNode(params) {
+  const tileLookup = createTileIndexFromWorldPosition(
+    params.spatialIndex,
+    params.uniforms,
+    params.maxLevel
+  );
+  return tsl.Fn(([worldX, worldZ]) => {
+    const tileResult = tileLookup(worldX, worldZ).toVar();
+    return packedSampleFromTileResult(params, tileResult);
+  });
+}
+function createTerrainSampleNodeByDirection(params) {
+  const tileLookup = createTileIndexFromDirection(params.spatialIndex, params.maxLevel);
+  return tsl.Fn(([direction]) => {
+    const tileResult = tileLookup(direction).toVar();
+    return packedSampleFromTileResult(params, tileResult);
+  });
+}
+function augmentCubeSphereSampler(sampler, params) {
+  const terrainSampleByDir = createTerrainSampleNodeByDirection(params);
+  sampler.sampleTerrainByDirection = tsl.Fn(([direction]) => terrainSampleByDir(direction));
+  sampler.sampleElevationByDirection = tsl.Fn(
+    ([direction]) => terrainSampleByDir(direction).x
+  );
+  sampler.sampleValidityByDirection = tsl.Fn(([direction]) => {
+    const sample = terrainSampleByDir(direction).toVar();
+    return sample.y.abs().add(sample.z.abs()).add(sample.w.abs()).greaterThan(tsl.float(0)).select(tsl.float(1), tsl.float(0));
+  });
+  sampler.sampleNormalByDirection = tsl.Fn(([direction]) => {
+    const packed = terrainSampleByDir(direction).toVar();
+    return tsl.vec3(packed.y, packed.z, packed.w).normalize();
+  });
+}
+function createTerrainSampler(params) {
+  const elevationNode = createElevationFunction(params.elevationCallback);
+  const terrainSampleAt = createTerrainSampleNode(params);
+  const evaluateElevationAt = tsl.Fn(([worldX, worldZ]) => {
+    const rootOrigin = params.uniforms.uRootOrigin.toVar();
+    const rootSize = params.uniforms.uRootSize.toVar();
+    const centeredX = worldX.sub(rootOrigin.x);
+    const centeredZ = worldZ.sub(rootOrigin.z);
+    const rootUV = tsl.vec2(
+      centeredX.div(rootSize).add(0.5),
+      centeredZ.div(rootSize).mul(tsl.float(-1)).add(0.5)
+    ).toVar();
+    return elevationNode({
+      worldPosition: tsl.vec3(worldX, rootOrigin.y, worldZ),
+      rootSize,
+      rootUV,
+      tileUV: rootUV,
+      tileLevel: tsl.int(0),
+      tileSize: rootSize,
+      tileOriginVec2: tsl.vec2(0, 0),
+      nodeIndex: tsl.int(0)
+    });
+  });
+  const sampleTerrain = tsl.Fn(
+    ([worldX, worldZ]) => terrainSampleAt(worldX, worldZ)
+  );
+  const sampleElevation = tsl.Fn(
+    ([worldX, worldZ]) => terrainSampleAt(worldX, worldZ).x
+  );
+  const sampleNormal = tsl.Fn(([worldX, worldZ]) => {
+    const sample = terrainSampleAt(worldX, worldZ).toVar();
+    return tsl.vec3(sample.y, sample.z, sample.w);
+  });
+  const sampleValidity = tsl.Fn(([worldX, worldZ]) => {
+    const sample = terrainSampleAt(worldX, worldZ).toVar();
+    return sample.y.abs().add(sample.z.abs()).add(sample.w.abs()).greaterThan(tsl.float(0)).select(tsl.float(1), tsl.float(0));
+  });
+  const evaluateElevation = tsl.Fn(
+    ([worldX, worldZ]) => evaluateElevationAt(worldX, worldZ)
+  );
+  const evaluateNormalNode = tsl.Fn(
+    ([worldX, worldZ, epsilon]) => {
+      const eps = epsilon ?? tsl.float(0.1);
+      const elevationScale = params.uniforms.uElevationScale.toVar();
+      const hL = evaluateElevationAt(worldX.sub(eps), worldZ).mul(
+        elevationScale
+      );
+      const hR = evaluateElevationAt(worldX.add(eps), worldZ).mul(
+        elevationScale
+      );
+      const hD = evaluateElevationAt(worldX, worldZ.sub(eps)).mul(
+        elevationScale
+      );
+      const hU = evaluateElevationAt(worldX, worldZ.add(eps)).mul(
+        elevationScale
+      );
+      const inv2eps = tsl.float(0.5).div(eps);
+      const dhdx = hR.sub(hL).mul(inv2eps);
+      const dhdz = hU.sub(hD).mul(inv2eps);
+      return tsl.vec3(dhdx.negate(), tsl.float(1), dhdz.negate()).normalize();
+    }
+  );
+  const evaluateNormal = (worldX, worldZ, epsilon) => evaluateNormalNode(worldX, worldZ, epsilon ?? tsl.float(0.1));
+  const sampler = {
+    sampleElevation,
+    sampleNormal,
+    sampleTerrain,
+    sampleValidity,
+    evaluateElevation,
+    evaluateNormal
+  };
+  params.projection.gpu.augmentSampler?.(sampler, params);
+  return sampler;
+}
+
+const RAYCAST_PADDING$1 = 1;
+function createSphereTileComputeParts(ctx) {
+  const { uniforms, shared } = ctx;
+  const tileSize = tsl.Fn(([nodeIndex]) => {
+    const level = shared.tileLevel(nodeIndex);
+    const divisor = tsl.pow(tsl.float(2), level.toFloat());
+    return uniforms.uRadius.toVar().mul(tsl.float(HALF_PI)).div(divisor);
+  });
+  const tileVertexWorldPosition = tsl.Fn(([nodeIndex, ix, iy]) => {
+    const rootOrigin = uniforms.uRootOrigin.toVar();
+    const faceUV = shared.tileFaceUV(nodeIndex, ix, iy);
+    const basis = cubeFaceBasis(shared.tileFace(nodeIndex));
+    const dir = cubeFaceDirection(basis, faceUV.x, faceUV.y);
+    return rootOrigin.add(dir.mul(uniforms.uRadius.toVar()));
+  });
+  return {
+    tileSize: (nodeIndex) => tileSize(nodeIndex),
+    rootUV: (nodeIndex, ix, iy) => shared.tileFaceUV(nodeIndex, ix, iy),
+    tileVertexWorldPosition: (nodeIndex, ix, iy) => tileVertexWorldPosition(nodeIndex, ix, iy)
+  };
+}
+function createCubeSphereProjection(config) {
+  const radius = config.radius;
+  const center = config.center ?? { x: 0, y: 0, z: 0 };
+  const invert = config.invert ?? false;
+  const cubeScratch = [0, 0, 0];
+  const uvScratch = [0, 0];
+  const dirScratch = [0, 0, 0];
+  const posLeft = [0, 0, 0];
+  const posRight = [0, 0, 0];
+  const posUp = [0, 0, 0];
+  const posDown = [0, 0, 0];
+  const neighborPos = (face, u, v, height, out) => {
+    faceUVToCube(face, u, v, cubeScratch);
+    const len = Math.hypot(cubeScratch[0], cubeScratch[1], cubeScratch[2]) || 1;
+    const r = invert ? (radius - height) / len : (radius + height) / len;
+    out[0] = cubeScratch[0] * r;
+    out[1] = cubeScratch[1] * r;
+    out[2] = cubeScratch[2] * r;
+  };
+  const surfaceOps = {
+    positionToKey(px, py, pz, out) {
+      const dx = px - center.x;
+      const dy = py - center.y;
+      const dz = pz - center.z;
+      const len = Math.hypot(dx, dy, dz);
+      if (len === 0) return false;
+      const nx = dx / len;
+      const ny = dy / len;
+      const nz = dz / len;
+      const dirSign = invert ? -1 : 1;
+      dirScratch[0] = nx;
+      dirScratch[1] = ny;
+      dirScratch[2] = nz;
+      const face = directionToFace(dirScratch);
+      directionToFaceUV(face, dirScratch, uvScratch);
+      out.space = face;
+      out.u = uvScratch[0];
+      out.v = uvScratch[1];
+      out.dirX = nx * dirSign;
+      out.dirY = ny * dirSign;
+      out.dirZ = nz * dirSign;
+      return true;
+    },
+    surfacePosition(key, elevation, outVec) {
+      const r = invert ? radius - elevation : radius + elevation;
+      outVec.set(center.x + key.dirX * r, center.y + key.dirY * r, center.z + key.dirZ * r);
+    },
+    surfaceNormal(key, ctx) {
+      const scale = ctx.elevationScale;
+      const duv = 1 / (ctx.innerTileSegments * 2 ** ctx.level);
+      dirScratch[0] = key.dirX;
+      dirScratch[1] = key.dirY;
+      dirScratch[2] = key.dirZ;
+      directionToFaceUV(key.space, dirScratch, uvScratch);
+      const u = uvScratch[0];
+      const v = uvScratch[1];
+      const hLeft = sampleGridBilinear(ctx.elevation, ctx.shape, ctx.leafIndex, ctx.gx - 1, ctx.gy) * scale;
+      const hRight = sampleGridBilinear(ctx.elevation, ctx.shape, ctx.leafIndex, ctx.gx + 1, ctx.gy) * scale;
+      const hUp = sampleGridBilinear(ctx.elevation, ctx.shape, ctx.leafIndex, ctx.gx, ctx.gy - 1) * scale;
+      const hDown = sampleGridBilinear(ctx.elevation, ctx.shape, ctx.leafIndex, ctx.gx, ctx.gy + 1) * scale;
+      neighborPos(key.space, u - duv, v, hLeft, posLeft);
+      neighborPos(key.space, u + duv, v, hRight, posRight);
+      neighborPos(key.space, u, v - duv, hUp, posUp);
+      neighborPos(key.space, u, v + duv, hDown, posDown);
+      const tux = posRight[0] - posLeft[0];
+      const tuy = posRight[1] - posLeft[1];
+      const tuz = posRight[2] - posLeft[2];
+      const tvx = posDown[0] - posUp[0];
+      const tvy = posDown[1] - posUp[1];
+      const tvz = posDown[2] - posUp[2];
+      let nx = tuy * tvz - tuz * tvy;
+      let ny = tuz * tvx - tux * tvz;
+      let nz = tux * tvy - tuy * tvx;
+      if (nx * key.dirX + ny * key.dirY + nz * key.dirZ < 0) {
+        nx = -nx;
+        ny = -ny;
+        nz = -nz;
+      }
+      return new three.Vector3(nx, ny, nz).normalize();
+    }
+  };
+  return {
+    kind: "cubeSphere",
+    radius,
+    center,
+    faceOutward: !invert,
+    gpu: {
+      renderVertexPosition(ctx) {
+        return createCurvedRenderVertexPosition(
+          ctx.leafStorage,
+          ctx.uniforms,
+          ctx.terrainFieldStorage,
+          (tile, faceUV, displacement) => {
+            const basis = cubeFaceBasis(tile.face);
+            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));
+          }
+        );
+      },
+      createTileComputeParts: createSphereTileComputeParts,
+      createFieldNormal(ctx) {
+        const computeNormal = createDisplacedSurfaceNormalFromElevationField(
+          ctx.elevationFieldNode,
+          ctx.edgeVertexCount,
+          (nodeIndex) => {
+            const basis = cubeFaceBasis(ctx.tile.tileFace(nodeIndex));
+            const r = ctx.uniforms.uRadius.toVar();
+            return {
+              positionAt: (gx, gy, height) => {
+                const uv = ctx.tile.tileFaceUV(nodeIndex, gx, gy);
+                const dir = cubeFaceDirection(basis, uv.x, uv.y);
+                return invert ? dir.mul(r.sub(height)) : dir.mul(r.add(height));
+              },
+              dirAt: (gx, gy) => {
+                const uv = ctx.tile.tileFaceUV(nodeIndex, gx, gy);
+                const dir = cubeFaceDirection(basis, uv.x, uv.y);
+                return invert ? dir.negate() : dir;
+              }
+            };
+          }
+        );
+        return (nodeIndex, ix, iy) => computeNormal(nodeIndex, ix, iy, ctx.uniforms.uElevationScale);
+      },
+      augmentSampler: augmentCubeSphereSampler
+    },
+    cpu: {
+      cameraSurfaceOffset(cam, elevation) {
+        const dx = cam.x - center.x;
+        const dy = cam.y - center.y;
+        const dz = cam.z - center.z;
+        const len = Math.hypot(dx, dy, dz);
+        if (len > 1e-12) {
+          const sign = invert ? 1 : -1;
+          const inv = sign * elevation / len;
+          cam.x += dx * inv;
+          cam.y += dy * inv;
+          cam.z += dz * inv;
+        }
+      },
+      createSurfaceOps() {
+        return surfaceOps;
+      },
+      createRuntimeQueries(cache) {
+        const query = createTerrainQuery(cache);
+        const surfaceQuery = createTerrainSurfaceQuery(cache);
+        const sphereQuery = createCubeSphereQuery(surfaceQuery, center);
+        return { query, surfaceQuery, sphereQuery };
+      },
+      raycast(ctx) {
+        const range = ctx.terrainQuery?.getGlobalElevationRange();
+        const dispMax = range ? Math.max(0, range.max - center.y) : radius * 0.1;
+        const outerPadding = invert ? 0 : dispMax + RAYCAST_PADDING$1;
+        const params = {
+          centerX: center.x,
+          centerY: center.y,
+          centerZ: center.z,
+          radius,
+          maxRadius: radius + outerPadding,
+          invert
+        };
+        if (ctx.sphereQuery) {
+          const precise = cubeSphereRaycast(ctx.sphereQuery, ctx.ray, params, ctx.options);
+          if (precise) return precise;
+        }
+        return cubeSphereRaycastBoundsOnly(ctx.ray, params, ctx.options);
+      }
+    }
+  };
+}
+function createCubeSphereQuery(surfaceQuery, center) {
+  const scratch = new three.Vector3();
+  const ll = [0, 0, 0];
+  const positionFromDirection = (dx, dy, dz) => scratch.set(center.x + dx, center.y + dy, center.z + dz);
+  return {
+    get generation() {
+      return surfaceQuery.generation;
+    },
+    getElevationByPosition: (position) => surfaceQuery.getElevationByPosition(position),
+    getNormalByPosition: (position) => surfaceQuery.getNormalByPosition(position),
+    sampleTerrainByPosition: (position) => surfaceQuery.sampleTerrainByPosition(position),
+    getTileByPosition: (position) => surfaceQuery.getTileByPosition(position),
+    getTileBoundsByPosition: (position) => surfaceQuery.getTileBoundsByPosition(position),
+    sampleTerrainBatchByPosition: (positions) => surfaceQuery.sampleTerrainBatchByPosition(positions),
+    getElevationByDirection: (direction) => surfaceQuery.getElevationByPosition(positionFromDirection(direction.x, direction.y, direction.z)),
+    getNormalByDirection: (direction) => surfaceQuery.getNormalByPosition(positionFromDirection(direction.x, direction.y, direction.z)),
+    sampleTerrainByDirection: (direction) => surfaceQuery.sampleTerrainByPosition(positionFromDirection(direction.x, direction.y, direction.z)),
+    getTileByDirection: (direction) => surfaceQuery.getTileByPosition(positionFromDirection(direction.x, direction.y, direction.z)),
+    getTileBoundsByDirection: (direction) => surfaceQuery.getTileBoundsByPosition(
+      positionFromDirection(direction.x, direction.y, direction.z)
+    ),
+    getElevationByLatLong: (lat, lon) => {
+      latLongToDirection(lat, lon, ll);
+      return surfaceQuery.getElevationByPosition(positionFromDirection(ll[0], ll[1], ll[2]));
+    },
+    getNormalByLatLong: (lat, lon) => {
+      latLongToDirection(lat, lon, ll);
+      return surfaceQuery.getNormalByPosition(positionFromDirection(ll[0], ll[1], ll[2]));
+    },
+    sampleTerrainByLatLong: (lat, lon) => {
+      latLongToDirection(lat, lon, ll);
+      return surfaceQuery.sampleTerrainByPosition(positionFromDirection(ll[0], ll[1], ll[2]));
+    },
+    getTileByLatLong: (lat, lon) => {
+      latLongToDirection(lat, lon, ll);
+      return surfaceQuery.getTileByPosition(positionFromDirection(ll[0], ll[1], ll[2]));
+    },
+    getTileBoundsByLatLong: (lat, lon) => {
+      latLongToDirection(lat, lon, ll);
+      return surfaceQuery.getTileBoundsByPosition(positionFromDirection(ll[0], ll[1], ll[2]));
+    },
+    sampleTerrainBatchByDirection: (directions) => {
+      const count = Math.floor(directions.length / 3);
+      const positions = new Float32Array(count * 3);
+      for (let i = 0; i < count; i += 1) {
+        positions[i * 3] = center.x + (directions[i * 3] ?? 0);
+        positions[i * 3 + 1] = center.y + (directions[i * 3 + 1] ?? 0);
+        positions[i * 3 + 2] = center.z + (directions[i * 3 + 2] ?? 0);
+      }
+      return surfaceQuery.sampleTerrainBatchByPosition(positions);
+    }
+  };
+}
+
+function createCubeSphereTopology(cfg) {
+  const radius = cfg.radius;
+  const center = cfg.center ?? { x: 0, y: 0, z: 0 };
+  const cube = [0, 0, 0];
+  const uv = [0, 0];
+  const px = new Float64Array(8);
+  const py = new Float64Array(8);
+  const pz = new Float64Array(8);
+  function crossFaceNeighbor(face, level, nx, ny, out) {
+    const n = 1 << level;
+    const u = (nx + 0.5) / n;
+    const v = (ny + 0.5) / n;
+    faceUVToCube(face, u, v, cube);
+    const len = Math.hypot(cube[0], cube[1], cube[2]);
+    const dir = [cube[0] / len, cube[1] / len, cube[2] / len];
+    const nbrFace = directionToFace(dir);
+    directionToFaceUV(nbrFace, dir, uv);
+    let bx = Math.floor(uv[0] * n);
+    let by = Math.floor(uv[1] * n);
+    if (bx < 0) bx = 0;
+    else if (bx > n - 1) bx = n - 1;
+    if (by < 0) by = 0;
+    else if (by > n - 1) by = n - 1;
+    out.space = nbrFace;
+    out.level = level;
+    out.x = bx;
+    out.y = by;
+  }
+  return {
+    spaceCount: 6,
+    maxRootCount: 6,
+    projection: createCubeSphereProjection({ radius, center, invert: cfg.invert }),
+    radius,
+    center,
+    neighborSameLevel(tile, dir, out) {
+      const level = tile.level;
+      const n = 1 << level;
+      let nx = tile.x;
+      let ny = tile.y;
+      switch (dir) {
+        case 0:
+          nx -= 1;
+          break;
+        case 1:
+          nx += 1;
+          break;
+        case 2:
+          ny -= 1;
+          break;
+        case 3:
+          ny += 1;
+          break;
+      }
+      if (nx >= 0 && ny >= 0 && nx < n && ny < n) {
+        out.space = tile.space;
+        out.level = level;
+        out.x = nx;
+        out.y = ny;
+        return true;
+      }
+      crossFaceNeighbor(tile.space, level, nx, ny, out);
+      return true;
+    },
+    tileBounds(tile, cameraOrigin, out, elevationRange) {
+      const level = tile.level;
+      const n = 1 << level;
+      const u0 = tile.x / n;
+      const u1 = (tile.x + 1) / n;
+      const v0 = tile.y / n;
+      const v1 = (tile.y + 1) / n;
+      const cornersU = [u0, u1, u0, u1];
+      const cornersV = [v0, v0, v1, v1];
+      const disps = elevationRange ? [elevationRange.min, elevationRange.max] : [0];
+      let pointCount = 0;
+      let sumX = 0;
+      let sumY = 0;
+      let sumZ = 0;
+      for (let i = 0; i < 4; i++) {
+        faceUVToCube(tile.space, cornersU[i], cornersV[i], cube);
+        const len = Math.hypot(cube[0], cube[1], cube[2]);
+        const dirX = cube[0] / len;
+        const dirY = cube[1] / len;
+        const dirZ = cube[2] / len;
+        for (let di = 0; di < disps.length; di++) {
+          const shellRadius = radius + disps[di];
+          const sx = center.x + dirX * shellRadius;
+          const sy = center.y + dirY * shellRadius;
+          const sz = center.z + dirZ * shellRadius;
+          px[pointCount] = sx;
+          py[pointCount] = sy;
+          pz[pointCount] = sz;
+          sumX += sx;
+          sumY += sy;
+          sumZ += sz;
+          pointCount += 1;
+        }
+      }
+      const cX = sumX / pointCount;
+      const cY = sumY / pointCount;
+      const cZ = sumZ / pointCount;
+      let maxDistSq = 0;
+      for (let i = 0; i < pointCount; i++) {
+        const dx = px[i] - cX;
+        const dy = py[i] - cY;
+        const dz = pz[i] - cZ;
+        const dSq = dx * dx + dy * dy + dz * dz;
+        if (dSq > maxDistSq) maxDistSq = dSq;
+      }
+      out.cx = cX - cameraOrigin.x;
+      out.cy = cY - cameraOrigin.y;
+      out.cz = cZ - cameraOrigin.z;
+      out.r = Math.sqrt(maxDistSq);
+    },
+    rootTiles(_cameraOrigin, out) {
+      for (let s = 0; s < 6; s++) {
+        const root = out[s];
+        root.space = s;
+        root.level = 0;
+        root.x = 0;
+        root.y = 0;
+      }
+      return 6;
+    }
+  };
+}
+
+const TWO_PI$1 = Math.PI * 2;
+function torusPosition(geometry, u, v, displacement) {
+  const theta = tsl.float(u).mul(TWO_PI$1);
+  const phi = tsl.float(v).mul(TWO_PI$1);
+  const sinT = tsl.sin(theta);
+  const cosT = tsl.cos(theta);
+  const sinP = tsl.sin(phi);
+  const cosP = tsl.cos(phi);
+  const disp = tsl.select(tsl.bool(geometry.invert), displacement.negate(), displacement);
+  const tube = disp.add(tsl.float(geometry.minorRadius));
+  const ring = tube.mul(cosP).add(tsl.float(geometry.majorRadius));
+  return tsl.vec3(
+    ring.mul(sinT).add(tsl.float(geometry.center.x)),
+    tube.mul(sinP).add(tsl.float(geometry.center.y)),
+    ring.mul(cosT).add(tsl.float(geometry.center.z))
+  );
+}
+function torusOutwardNormal(u, v, invert) {
+  const theta = tsl.float(u).mul(TWO_PI$1);
+  const phi = tsl.float(v).mul(TWO_PI$1);
+  const sinT = tsl.sin(theta);
+  const cosT = tsl.cos(theta);
+  const sinP = tsl.sin(phi);
+  const cosP = tsl.cos(phi);
+  const normal = tsl.vec3(cosP.mul(sinT), sinP, cosP.mul(cosT)).normalize();
+  return tsl.select(tsl.bool(invert), normal.negate(), normal);
+}
+
+const TWO_PI = Math.PI * 2;
+const RAYCAST_PADDING = 1;
+const ZERO_CENTER = { x: 0, y: 0, z: 0 };
+function createTorusTileComputeParts(ctx, geometry) {
+  const { shared } = ctx;
+  const tileSize = tsl.Fn(([nodeIndex]) => {
+    const level = shared.tileLevel(nodeIndex);
+    const levelScale = tsl.pow(tsl.float(2), level.toFloat());
+    return tsl.float(TWO_PI * geometry.majorRadius).div(tsl.float(geometry.baseU).mul(levelScale));
+  });
+  const tileVertexWorldPosition = tsl.Fn(([nodeIndex, ix, iy]) => {
+    const faceUV = shared.tileFaceUV(nodeIndex, ix, iy);
+    return torusPosition(geometry, faceUV.x, faceUV.y, tsl.float(0));
+  });
+  return {
+    tileSize: (nodeIndex) => tileSize(nodeIndex),
+    rootUV: (nodeIndex, ix, iy) => shared.tileFaceUV(nodeIndex, ix, iy),
+    tileVertexWorldPosition: (nodeIndex, ix, iy) => tileVertexWorldPosition(nodeIndex, ix, iy)
+  };
+}
+function createTorusProjection(config) {
+  const majorRadius = config.majorRadius;
+  const minorRadius = config.minorRadius;
+  const center = config.center ?? { x: 0, y: 0, z: 0 };
+  const invert = config.invert ?? false;
+  const baseU = config.baseU ?? 1;
+  const baseV = config.baseV ?? 1;
+  const geometry = { majorRadius, minorRadius, center, invert, baseU};
+  const params = { u: 0, v: 0, tubeDistance: 0 };
+  const normalScratch = [0, 0, 0];
+  const posLeft = [0, 0, 0];
+  const posRight = [0, 0, 0];
+  const posUp = [0, 0, 0];
+  const posDown = [0, 0, 0];
+  const surfaceOps = {
+    positionToKey(px, py, pz, out) {
+      positionToTorusParams(px, py, pz, majorRadius, center, params);
+      torusOutwardNormal$1(params.u, params.v, normalScratch, invert);
+      out.space = 0;
+      out.u = params.u;
+      out.v = params.v;
+      out.dirX = normalScratch[0];
+      out.dirY = normalScratch[1];
+      out.dirZ = normalScratch[2];
+      return true;
+    },
+    surfacePosition(key, elevation, outVec) {
+      torusUVToPoint(
+        key.u,
+        key.v,
+        majorRadius,
+        minorRadius,
+        elevation,
+        center,
+        normalScratch,
+        invert
+      );
+      outVec.set(normalScratch[0], normalScratch[1], normalScratch[2]);
+    },
+    surfaceNormal(key, ctx) {
+      const scale = ctx.elevationScale;
+      const levelScale = 2 ** ctx.level;
+      const duvU = 1 / (ctx.innerTileSegments * baseU * levelScale);
+      const duvV = 1 / (ctx.innerTileSegments * baseV * levelScale);
+      const u = key.u;
+      const v = key.v;
+      const hLeft = sampleGridBilinear(ctx.elevation, ctx.shape, ctx.leafIndex, ctx.gx - 1, ctx.gy) * scale;
+      const hRight = sampleGridBilinear(ctx.elevation, ctx.shape, ctx.leafIndex, ctx.gx + 1, ctx.gy) * scale;
+      const hUp = sampleGridBilinear(ctx.elevation, ctx.shape, ctx.leafIndex, ctx.gx, ctx.gy - 1) * scale;
+      const hDown = sampleGridBilinear(ctx.elevation, ctx.shape, ctx.leafIndex, ctx.gx, ctx.gy + 1) * scale;
+      torusUVToPoint(u - duvU, v, majorRadius, minorRadius, hLeft, ZERO_CENTER, posLeft, invert);
+      torusUVToPoint(u + duvU, v, majorRadius, minorRadius, hRight, ZERO_CENTER, posRight, invert);
+      torusUVToPoint(u, v - duvV, majorRadius, minorRadius, hUp, ZERO_CENTER, posUp, invert);
+      torusUVToPoint(u, v + duvV, majorRadius, minorRadius, hDown, ZERO_CENTER, posDown, invert);
+      const tux = posRight[0] - posLeft[0];
+      const tuy = posRight[1] - posLeft[1];
+      const tuz = posRight[2] - posLeft[2];
+      const tvx = posDown[0] - posUp[0];
+      const tvy = posDown[1] - posUp[1];
+      const tvz = posDown[2] - posUp[2];
+      let nx = tuy * tvz - tuz * tvy;
+      let ny = tuz * tvx - tux * tvz;
+      let nz = tux * tvy - tuy * tvx;
+      if (nx * key.dirX + ny * key.dirY + nz * key.dirZ < 0) {
+        nx = -nx;
+        ny = -ny;
+        nz = -nz;
+      }
+      return new three.Vector3(nx, ny, nz).normalize();
+    }
+  };
   return {
-    spaceCount: 6,
-    maxRootCount: 6,
-    neighborSameLevel(_tile, _dir, _out) {
-      return false;
+    kind: "torus",
+    radius: majorRadius + minorRadius,
+    center,
+    faceOutward: !invert,
+    baseResolution: { u: baseU, v: baseV },
+    gpu: {
+      renderVertexPosition(ctx) {
+        return createCurvedRenderVertexPosition(
+          ctx.leafStorage,
+          ctx.uniforms,
+          ctx.terrainFieldStorage,
+          (_tile, faceUV, displacement) => torusPosition(geometry, faceUV.x, faceUV.y, displacement),
+          baseU,
+          baseV
+        );
+      },
+      createTileComputeParts: (ctx) => createTorusTileComputeParts(ctx, geometry),
+      createFieldNormal(ctx) {
+        const computeNormal = createDisplacedSurfaceNormalFromElevationField(
+          ctx.elevationFieldNode,
+          ctx.edgeVertexCount,
+          (nodeIndex) => ({
+            positionAt: (gx, gy, height) => {
+              const uv = ctx.tile.tileFaceUV(nodeIndex, gx, gy);
+              return torusPosition(geometry, uv.x, uv.y, height);
+            },
+            dirAt: (gx, gy) => {
+              const uv = ctx.tile.tileFaceUV(nodeIndex, gx, gy);
+              return torusOutwardNormal(uv.x, uv.y, invert);
+            }
+          })
+        );
+        return (nodeIndex, ix, iy) => computeNormal(nodeIndex, ix, iy, ctx.uniforms.uElevationScale);
+      }
+    },
+    cpu: {
+      cameraSurfaceOffset(cam, elevation) {
+        positionToTorusParams(cam.x, cam.y, cam.z, majorRadius, center, params);
+        torusOutwardNormal$1(params.u, params.v, normalScratch, invert);
+        cam.x -= normalScratch[0] * elevation;
+        cam.y -= normalScratch[1] * elevation;
+        cam.z -= normalScratch[2] * elevation;
+      },
+      createSurfaceOps() {
+        return surfaceOps;
+      },
+      createRuntimeQueries(cache) {
+        const query = createTerrainQuery(cache);
+        const surfaceQuery = createTerrainSurfaceQuery(cache);
+        return { query, surfaceQuery, sphereQuery: null };
+      },
+      raycast(ctx) {
+        const range = ctx.terrainQuery?.getGlobalElevationRange();
+        const dispMax = range ? Math.max(0, range.max - ctx.config.originY) : minorRadius * 0.5;
+        const outerPadding = invert ? 0 : dispMax + RAYCAST_PADDING;
+        const raycastParams = {
+          centerX: center.x,
+          centerY: center.y,
+          centerZ: center.z,
+          majorRadius,
+          minorRadius,
+          outerRadius: majorRadius + minorRadius + outerPadding,
+          invert
+        };
+        if (ctx.surfaceQuery) {
+          const precise = torusRaycast(ctx.surfaceQuery, ctx.ray, raycastParams, ctx.options);
+          if (precise) return precise;
+        }
+        return torusRaycastBoundsOnly(ctx.ray, raycastParams, ctx.options);
+      }
+    }
+  };
+}
+
+function createTorusTopology(cfg) {
+  const majorRadius = cfg.majorRadius;
+  const minorRadius = cfg.minorRadius;
+  const center = cfg.center ?? { x: 0, y: 0, z: 0 };
+  const invert = cfg.invert ?? false;
+  const baseU = Math.max(1, Math.round(majorRadius / minorRadius));
+  const baseV = 1;
+  const corner = [0, 0, 0];
+  const px = new Float64Array(18);
+  const py = new Float64Array(18);
+  const pz = new Float64Array(18);
+  const wrap = (value, n) => (value % n + n) % n;
+  const levelResolution = (level) => {
+    const levelScale = 2 ** level;
+    return { nU: baseU * levelScale, nV: baseV * levelScale };
+  };
+  return {
+    spaceCount: 1,
+    maxRootCount: baseU * baseV,
+    projection: createTorusProjection({
+      majorRadius,
+      minorRadius,
+      center,
+      invert,
+      baseU,
+      baseV
+    }),
+    radius: majorRadius + minorRadius,
+    center,
+    neighborSameLevel(tile, dir, out) {
+      const { nU, nV } = levelResolution(tile.level);
+      let nx = tile.x;
+      let ny = tile.y;
+      switch (dir) {
+        case Dir.LEFT:
+          nx -= 1;
+          break;
+        case Dir.RIGHT:
+          nx += 1;
+          break;
+        case Dir.TOP:
+          ny -= 1;
+          break;
+        case Dir.BOTTOM:
+          ny += 1;
+          break;
+      }
+      out.space = 0;
+      out.level = tile.level;
+      out.x = wrap(nx, nU);
+      out.y = wrap(ny, nV);
+      return true;
     },
-    tileBounds(_tile, _cameraOrigin, out) {
-      out.cx = 0;
-      out.cy = 0;
-      out.cz = 0;
-      out.r = Number.MAX_VALUE;
+    tileBounds(tile, cameraOrigin, out, elevationRange) {
+      const { nU, nV } = levelResolution(tile.level);
+      const u0 = tile.x / nU;
+      const v0 = tile.y / nV;
+      const stepU = 1 / nU;
+      const stepV = 1 / nV;
+      const disps = elevationRange ? [elevationRange.min, elevationRange.max] : [0];
+      let pointCount = 0;
+      let sumX = 0;
+      let sumY = 0;
+      let sumZ = 0;
+      for (let sj = 0; sj <= 2; sj++) {
+        for (let si = 0; si <= 2; si++) {
+          const u = u0 + si * stepU / 2;
+          const v = v0 + sj * stepV / 2;
+          for (let di = 0; di < disps.length; di++) {
+            torusUVToPoint(u, v, majorRadius, minorRadius, disps[di], center, corner, invert);
+            px[pointCount] = corner[0];
+            py[pointCount] = corner[1];
+            pz[pointCount] = corner[2];
+            sumX += corner[0];
+            sumY += corner[1];
+            sumZ += corner[2];
+            pointCount += 1;
+          }
+        }
+      }
+      const cX = sumX / pointCount;
+      const cY = sumY / pointCount;
+      const cZ = sumZ / pointCount;
+      let maxDistSq = 0;
+      for (let i = 0; i < pointCount; i++) {
+        const dx = px[i] - cX;
+        const dy = py[i] - cY;
+        const dz = pz[i] - cZ;
+        const dSq = dx * dx + dy * dy + dz * dz;
+        if (dSq > maxDistSq) maxDistSq = dSq;
+      }
+      out.cx = cX - cameraOrigin.x;
+      out.cy = cY - cameraOrigin.y;
+      out.cz = cZ - cameraOrigin.z;
+      out.r = Math.sqrt(maxDistSq);
     },
     rootTiles(_cameraOrigin, out) {
-      for (let s = 0; s < 6; s++) {
-        const root = out[s];
-        root.space = s;
-        root.level = 0;
-        root.x = 0;
-        root.y = 0;
+      let count = 0;
+      for (let y = 0; y < baseV; y++) {
+        for (let x = 0; x < baseU; x++) {
+          const root = out[count];
+          root.space = 0;
+          root.level = 0;
+          root.x = x;
+          root.y = y;
+          count += 1;
+        }
       }
-      return 6;
+      return count;
     }
   };
 }
 
+function nextPow2(n) {
+  let x = 1;
+  while (x < n) x <<= 1;
+  return x;
+}
+function mix32(x) {
+  x >>>= 0;
+  x ^= x >>> 16;
+  x = Math.imul(x, 2146121005) >>> 0;
+  x ^= x >>> 15;
+  x = Math.imul(x, 2221713035) >>> 0;
+  x ^= x >>> 16;
+  return x >>> 0;
+}
+function hashKey(space, level, x, y) {
+  const h = space & 255 ^ (level & 255) << 8 ^ mix32(x) >>> 0 ^ mix32(y) >>> 0;
+  return mix32(h);
+}
+function createTileElevationPyramid(maxNodes, maxLevel) {
+  const size = nextPow2(Math.max(2, maxNodes * (maxLevel + 1) * 2));
+  return {
+    size,
+    mask: size - 1,
+    stampGen: 1,
+    stamp: new Uint16Array(size),
+    keysSpace: new Uint8Array(size),
+    keysLevel: new Uint8Array(size),
+    keysX: new Uint32Array(size),
+    keysY: new Uint32Array(size),
+    mins: new Float32Array(size),
+    maxs: new Float32Array(size)
+  };
+}
+function beginPyramidGeneration(pyramid) {
+  pyramid.stampGen = pyramid.stampGen + 1 & 65535;
+  if (pyramid.stampGen === 0) {
+    pyramid.stamp.fill(0);
+    pyramid.stampGen = 1;
+  }
+}
+function mergeRange(pyramid, space, level, x, y, min, max) {
+  const s = space & 255;
+  const l = level & 255;
+  const xx = x >>> 0;
+  const yy = y >>> 0;
+  let slot = hashKey(s, l, xx, yy) & pyramid.mask;
+  for (let probes = 0; probes < pyramid.size; probes++) {
+    if (pyramid.stamp[slot] !== pyramid.stampGen) {
+      pyramid.stamp[slot] = pyramid.stampGen;
+      pyramid.keysSpace[slot] = s;
+      pyramid.keysLevel[slot] = l;
+      pyramid.keysX[slot] = xx;
+      pyramid.keysY[slot] = yy;
+      pyramid.mins[slot] = min;
+      pyramid.maxs[slot] = max;
+      return;
+    }
+    if (pyramid.keysSpace[slot] === s && pyramid.keysLevel[slot] === l && pyramid.keysX[slot] === xx && pyramid.keysY[slot] === yy) {
+      if (min < pyramid.mins[slot]) pyramid.mins[slot] = min;
+      if (max > pyramid.maxs[slot]) pyramid.maxs[slot] = max;
+      return;
+    }
+    slot = slot + 1 & pyramid.mask;
+  }
+  throw new Error("TileElevationPyramid is full (no empty slot found).");
+}
+function buildTileElevationPyramid(pyramid, index, tileBounds, leafCount) {
+  beginPyramidGeneration(pyramid);
+  const stampGen = index.stampGen;
+  for (let slot = 0; slot < index.size; slot++) {
+    if (index.stamp[slot] !== stampGen) continue;
+    const leafIndex = index.values[slot];
+    if (leafIndex >= leafCount) continue;
+    const space = index.keysSpace[slot];
+    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];
+    for (let ancestorLevel = level; ancestorLevel >= 0; ancestorLevel--) {
+      const shift = level - ancestorLevel;
+      mergeRange(
+        pyramid,
+        space,
+        ancestorLevel,
+        x >>> shift,
+        y >>> shift,
+        rawMin,
+        rawMax
+      );
+    }
+  }
+}
+function lookupTileElevationRange(pyramid, space, level, x, y, out) {
+  const s = space & 255;
+  const l = level & 255;
+  const xx = x >>> 0;
+  const yy = y >>> 0;
+  let slot = hashKey(s, l, xx, yy) & pyramid.mask;
+  for (let probes = 0; probes < pyramid.size; probes++) {
+    if (pyramid.stamp[slot] !== pyramid.stampGen) return false;
+    if (pyramid.keysSpace[slot] === s && pyramid.keysLevel[slot] === l && pyramid.keysX[slot] === xx && pyramid.keysY[slot] === yy) {
+      out.min = pyramid.mins[slot];
+      out.max = pyramid.maxs[slot];
+      return true;
+    }
+    slot = slot + 1 & pyramid.mask;
+  }
+  return false;
+}
+
+const MISSED_LOOKUP = Object.freeze({
+  found: false,
+  leafIndex: -1,
+  space: -1,
+  level: -1,
+  tileX: -1,
+  tileY: -1,
+  tileSize: 0,
+  localU: 0,
+  localV: 0
+});
+function lookupTile(index, config, worldX, worldZ) {
+  const halfRoot = config.rootSize * 0.5;
+  for (let level = config.maxLevel; level >= 0; level -= 1) {
+    const scale = 2 ** level;
+    const tileSize = config.rootSize / scale;
+    const tileX = Math.floor((worldX - config.originX + halfRoot) / tileSize);
+    const tileY = Math.floor((worldZ - config.originZ + halfRoot) / tileSize);
+    const leafIndex = lookupSpatialIndexRaw(index, 0, level, tileX, tileY);
+    if (leafIndex !== U32_EMPTY) {
+      const tileMinX = config.originX + tileX * tileSize - halfRoot;
+      const tileMinZ = config.originZ + tileY * tileSize - halfRoot;
+      return {
+        found: true,
+        leafIndex,
+        space: 0,
+        level,
+        tileX,
+        tileY,
+        tileSize,
+        localU: (worldX - tileMinX) / tileSize,
+        localV: (worldZ - tileMinZ) / tileSize
+      };
+    }
+  }
+  return MISSED_LOOKUP;
+}
+function clamp01(value) {
+  return value < 0 ? 0 : value > 1 ? 1 : value;
+}
+function lookupTileByFaceUV(index, config, face, u, v) {
+  const baseU = config.baseU ?? 1;
+  const baseV = config.baseV ?? 1;
+  for (let level = config.maxLevel; level >= 0; level -= 1) {
+    const levelScale = 2 ** level;
+    const nU = baseU * levelScale;
+    const nV = baseV * levelScale;
+    let tileX = Math.floor(u * nU);
+    let tileY = Math.floor(v * nV);
+    if (tileX < 0) tileX = 0;
+    else if (tileX > nU - 1) tileX = nU - 1;
+    if (tileY < 0) tileY = 0;
+    else if (tileY > nV - 1) tileY = nV - 1;
+    const leafIndex = lookupSpatialIndexRaw(index, face, level, tileX, tileY);
+    if (leafIndex !== U32_EMPTY) {
+      const tileSize = sphereTileArcLength(config.radius, nU);
+      return {
+        found: true,
+        leafIndex,
+        space: face,
+        level,
+        tileX,
+        tileY,
+        tileSize,
+        localU: clamp01(u * nU - tileX),
+        localV: clamp01(v * nV - tileY)
+      };
+    }
+  }
+  return MISSED_LOOKUP;
+}
+
+function createReadbackSlot() {
+  return { buffer: null, size: 0 };
+}
+function getBackend(renderer) {
+  return renderer.backend;
+}
+function canDeviceReadback(renderer) {
+  const backend = getBackend(renderer);
+  return Boolean(backend?.device) && typeof backend?.get === "function";
+}
+async function readStorageBufferInto(renderer, attribute, slot, target, elementCount, label) {
+  const backend = getBackend(renderer);
+  const device = backend?.device;
+  const source = backend?.get?.(attribute)?.buffer;
+  if (!device || !source) return false;
+  const requestedBytes = elementCount * Float32Array.BYTES_PER_ELEMENT;
+  const copyBytes = Math.min(requestedBytes, source.size);
+  if (copyBytes <= 0) return true;
+  if (!slot.buffer || slot.size !== source.size) {
+    slot.buffer?.destroy();
+    slot.buffer = device.createBuffer({
+      label,
+      size: source.size,
+      usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
+    });
+    slot.size = source.size;
+  }
+  const staging = slot.buffer;
+  const encoder = device.createCommandEncoder({ label });
+  encoder.copyBufferToBuffer(source, 0, staging, 0, copyBytes);
+  device.queue.submit([encoder.finish()]);
+  await staging.mapAsync(GPUMapMode.READ, 0, copyBytes);
+  const mapped = new Float32Array(staging.getMappedRange(0, copyBytes));
+  target.set(mapped);
+  staging.unmap();
+  return true;
+}
+function disposeReadbackSlot(slot) {
+  slot.buffer?.destroy();
+  slot.buffer = null;
+  slot.size = 0;
+}
+
+function createTerrainSnapshotState(maxNodes, maxLevel, totalElements) {
+  return {
+    frontElevation: new Float32Array(totalElements),
+    backElevation: new Float32Array(totalElements),
+    frontIndex: createSpatialIndex(maxNodes),
+    backIndex: createSpatialIndex(maxNodes),
+    frontTileBounds: new Float32Array(maxNodes * 2),
+    backTileBounds: new Float32Array(maxNodes * 2),
+    frontLeafCount: 0,
+    globalRange: null,
+    hasSnapshot: false,
+    readbackPending: false,
+    generation: 0,
+    lastScheduledStampGen: -1,
+    elevationReadback: createReadbackSlot(),
+    boundsReadback: createReadbackSlot(),
+    elevationPyramid: createTileElevationPyramid(maxNodes, maxLevel)
+  };
+}
 function cloneSpatialIndex(target, source) {
   if (target.size !== source.size) {
     throw new Error(
@@ -1404,218 +3363,308 @@ function cloneSpatialIndex(target, source) {
   target.keysY.set(source.keysY);
   target.values.set(source.values);
 }
-function tileLocalToFieldUV(localCoord, innerSegments) {
-  const edge = innerSegments + 3;
-  return (localCoord * innerSegments + 1.5) / edge;
+function triggerSnapshotReadback(state, renderer, attribute, spatialIndex, boundsAttribute, captured) {
+  if (state.readbackPending) return;
+  const withReadback = renderer;
+  const useDeviceReadback = canDeviceReadback(renderer);
+  if (!useDeviceReadback && !withReadback.getArrayBufferAsync) return;
+  if (spatialIndex.stampGen === state.lastScheduledStampGen) return;
+  cloneSpatialIndex(state.backIndex, spatialIndex);
+  state.lastScheduledStampGen = spatialIndex.stampGen;
+  const { activeLeafCount, totalElements, verticesPerNode, elevationScale, originY } = captured;
+  state.readbackPending = true;
+  const applySnapshot = (boundsFilled) => {
+    let boundsValid = activeLeafCount === 0;
+    if (boundsFilled) {
+      for (let i = 0; i < activeLeafCount; i += 1) {
+        if ((state.backTileBounds[i * 2 + 1] ?? 0) !== 0) {
+          boundsValid = true;
+          break;
+        }
+      }
+    }
+    const oldFrontElevation = state.frontElevation;
+    const oldFrontIndex = state.frontIndex;
+    state.frontElevation = state.backElevation;
+    state.frontIndex = state.backIndex;
+    state.frontLeafCount = activeLeafCount;
+    state.backElevation = oldFrontElevation;
+    state.backIndex = oldFrontIndex;
+    if (boundsFilled && boundsValid) {
+      const oldFrontBounds = state.frontTileBounds;
+      state.frontTileBounds = state.backTileBounds;
+      state.backTileBounds = oldFrontBounds;
+    }
+    if (boundsFilled && boundsValid && activeLeafCount > 0) {
+      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 a = originY + rawMin * elevationScale;
+        const b = originY + rawMax * elevationScale;
+        gMin = Math.min(gMin, a, b);
+        gMax = Math.max(gMax, a, b);
+      }
+      state.globalRange = { min: gMin, max: gMax };
+      buildTileElevationPyramid(
+        state.elevationPyramid,
+        state.frontIndex,
+        state.frontTileBounds,
+        activeLeafCount
+      );
+    }
+    state.hasSnapshot = true;
+    state.generation += 1;
+  };
+  if (useDeviceReadback) {
+    const runDeviceReadback = async () => {
+      state.backElevation.fill(0);
+      await readStorageBufferInto(
+        renderer,
+        attribute,
+        state.elevationReadback,
+        state.backElevation,
+        activeLeafCount * verticesPerNode,
+        "terrainElevationReadback"
+      );
+      let boundsFilled = false;
+      if (boundsAttribute) {
+        state.backTileBounds.fill(0);
+        boundsFilled = await readStorageBufferInto(
+          renderer,
+          boundsAttribute,
+          state.boundsReadback,
+          state.backTileBounds,
+          activeLeafCount * 2,
+          "terrainBoundsReadback"
+        );
+      }
+      applySnapshot(boundsFilled);
+    };
+    runDeviceReadback().finally(() => {
+      state.readbackPending = false;
+    });
+    return;
+  }
+  const onComplete = (elevResult, boundsResult) => {
+    const data = new Float32Array(elevResult);
+    state.backElevation.fill(0);
+    state.backElevation.set(data.subarray(0, totalElements));
+    let boundsFilled = false;
+    if (boundsResult) {
+      const rawBounds = new Float32Array(boundsResult);
+      state.backTileBounds.fill(0);
+      state.backTileBounds.set(rawBounds.subarray(0, activeLeafCount * 2));
+      boundsFilled = true;
+    }
+    applySnapshot(boundsFilled);
+  };
+  const elevationPromise = withReadback.getArrayBufferAsync(attribute);
+  const boundsPromise = boundsAttribute ? withReadback.getArrayBufferAsync(boundsAttribute) : null;
+  if (boundsPromise) {
+    Promise.all([elevationPromise, boundsPromise]).then(([elev, bounds]) => onComplete(elev, bounds)).finally(() => {
+      state.readbackPending = false;
+    });
+  } else {
+    elevationPromise.then((elev) => onComplete(elev, null)).finally(() => {
+      state.readbackPending = false;
+    });
+  }
 }
-function createCpuTerrainCache(maxNodes, initialConfig) {
+function disposeSnapshotReadback(state) {
+  disposeReadbackSlot(state.elevationReadback);
+  disposeReadbackSlot(state.boundsReadback);
+}
+
+function createCpuTerrainCache(maxNodes, initialConfig, surfaceOps) {
   let config = initialConfig;
-  let edgeVertexCount = config.innerTileSegments + 3;
-  let verticesPerNode = edgeVertexCount * edgeVertexCount;
-  let totalElements = maxNodes * verticesPerNode;
-  let frontElevation = new Float32Array(totalElements);
-  let backElevation = new Float32Array(totalElements);
-  let frontIndex = createSpatialIndex(maxNodes);
-  let backIndex = createSpatialIndex(maxNodes);
-  let frontTileBounds = new Float32Array(maxNodes * 2);
-  let backTileBounds = new Float32Array(maxNodes * 2);
-  let frontLeafCount = 0;
-  let globalRange = null;
-  let hasSnapshot = false;
-  let readbackPending = false;
-  let generationCount = 0;
-  let lastScheduledStampGen = -1;
-  const readHeight = (leafIndex, ix, iy) => {
-    const base = leafIndex * verticesPerNode;
-    return frontElevation[base + iy * edgeVertexCount + ix] ?? 0;
+  const shape = {
+    edgeVertexCount: config.innerTileSegments + 3,
+    verticesPerNode: 0
   };
-  const sampleGridBilinear = (leafIndex, gx, gy) => {
-    const max = edgeVertexCount - 1;
-    const x = Math.max(0, Math.min(max, gx));
-    const y = Math.max(0, Math.min(max, gy));
-    const x0 = Math.floor(x);
-    const y0 = Math.floor(y);
-    const x1 = Math.min(max, x0 + 1);
-    const y1 = Math.min(max, y0 + 1);
-    const tx = x - x0;
-    const ty = y - y0;
-    const h00 = readHeight(leafIndex, x0, y0);
-    const h10 = readHeight(leafIndex, x1, y0);
-    const h01 = readHeight(leafIndex, x0, y1);
-    const h11 = readHeight(leafIndex, x1, y1);
-    const hx0 = h00 + (h10 - h00) * tx;
-    const hx1 = h01 + (h11 - h01) * tx;
-    return hx0 + (hx1 - hx0) * ty;
+  shape.verticesPerNode = shape.edgeVertexCount * shape.edgeVertexCount;
+  let totalElements = maxNodes * shape.verticesPerNode;
+  const state = createTerrainSnapshotState(
+    maxNodes,
+    initialConfig.maxLevel,
+    totalElements
+  );
+  const gridScratch = { gx: 0, gy: 0 };
+  const gradientScratch = { dhdu: 0, dhdv: 0 };
+  const keyScratch = { space: 0, u: 0, v: 0, dirX: 0, dirY: 0, dirZ: 0 };
+  const surfaceLookupConfig = () => ({
+    rootSize: config.rootSize,
+    originX: config.originX,
+    originZ: config.originZ,
+    maxLevel: config.maxLevel,
+    radius: config.radius,
+    baseU: config.baseU,
+    baseV: config.baseV
+  });
+  const gridCoordsFromLookup = (lookup) => {
+    const fieldU = tileLocalToFieldUVNumber(lookup.localU, config.innerTileSegments);
+    const fieldV = tileLocalToFieldUVNumber(lookup.localV, config.innerTileSegments);
+    gridScratch.gx = fieldU * (shape.edgeVertexCount - 1);
+    gridScratch.gy = fieldV * (shape.edgeVertexCount - 1);
+    return gridScratch;
+  };
+  const rawHeightFromLookup = (lookup) => {
+    const g = gridCoordsFromLookup(lookup);
+    return sampleGridBilinear(state.frontElevation, shape, lookup.leafIndex, g.gx, g.gy);
   };
   const computeNormal = (leafIndex, gx, gy, tileSize) => {
-    const hLeft = sampleGridBilinear(leafIndex, gx - 1, gy);
-    const hRight = sampleGridBilinear(leafIndex, gx + 1, gy);
-    const hUp = sampleGridBilinear(leafIndex, gx, gy - 1);
-    const hDown = sampleGridBilinear(leafIndex, gx, gy + 1);
     const stepWorld = tileSize / config.innerTileSegments;
-    const inv2Step = 0.5 / stepWorld;
-    const dhdx = (hRight - hLeft) * config.elevationScale * inv2Step;
-    const dhdz = (hDown - hUp) * config.elevationScale * inv2Step;
-    return new three.Vector3(-dhdx, 1, -dhdz).normalize();
-  };
-  const lookupTile = (worldX, worldZ) => {
-    const halfRoot = config.rootSize * 0.5;
-    for (let level = config.maxLevel; level >= 0; level -= 1) {
-      const scale = 2 ** level;
-      const tileSize = config.rootSize / scale;
-      const tileX = Math.floor((worldX - config.originX + halfRoot) / tileSize);
-      const tileY = Math.floor((worldZ - config.originZ + halfRoot) / tileSize);
-      const leafIndex = lookupSpatialIndexRaw(
-        frontIndex,
-        0,
-        level,
-        tileX,
-        tileY
-      );
-      if (leafIndex !== U32_EMPTY) {
-        const tileMinX = config.originX + tileX * tileSize - halfRoot;
-        const tileMinZ = config.originZ + tileY * tileSize - halfRoot;
-        return {
-          found: true,
-          leafIndex,
-          level,
-          tileX,
-          tileY,
-          tileSize,
-          localU: (worldX - tileMinX) / tileSize,
-          localV: (worldZ - tileMinZ) / tileSize
-        };
-      }
-    }
-    return {
-      found: false,
-      leafIndex: -1,
-      level: -1,
-      tileX: -1,
-      tileY: -1,
-      tileSize: 0,
-      localU: 0,
-      localV: 0
-    };
+    const { dhdu, dhdv } = elevationGradientAt(
+      state.frontElevation,
+      shape,
+      leafIndex,
+      gx,
+      gy,
+      stepWorld,
+      config.elevationScale,
+      gradientScratch
+    );
+    return new three.Vector3(-dhdu, 1, -dhdv).normalize();
   };
   const sampleFromLookup = (lookup) => {
-    const fieldU = tileLocalToFieldUV(lookup.localU, config.innerTileSegments);
-    const fieldV = tileLocalToFieldUV(lookup.localV, config.innerTileSegments);
-    const gx = fieldU * (edgeVertexCount - 1);
-    const gy = fieldV * (edgeVertexCount - 1);
-    const height = sampleGridBilinear(lookup.leafIndex, gx, gy);
+    const height = rawHeightFromLookup(lookup);
     const scaledHeight = config.originY + height * config.elevationScale;
-    const normal = computeNormal(lookup.leafIndex, gx, gy, lookup.tileSize);
+    const normal = computeNormal(lookup.leafIndex, gridScratch.gx, gridScratch.gy, lookup.tileSize);
     return { elevation: scaledHeight, normal, valid: true };
   };
-  const sampleElevationFromLookup = (lookup) => {
-    const fieldU = tileLocalToFieldUV(lookup.localU, config.innerTileSegments);
-    const fieldV = tileLocalToFieldUV(lookup.localV, config.innerTileSegments);
-    const gx = fieldU * (edgeVertexCount - 1);
-    const gy = fieldV * (edgeVertexCount - 1);
-    const height = sampleGridBilinear(lookup.leafIndex, gx, gy);
-    const scaledHeight = config.originY + height * config.elevationScale;
-    return { elevation: scaledHeight, valid: true };
-  };
   const sampleTerrain = (worldX, worldZ) => {
-    if (!hasSnapshot) {
+    if (!state.hasSnapshot) {
       return { elevation: 0, normal: new three.Vector3(0, 1, 0), valid: false };
     }
-    const lookup = lookupTile(worldX, worldZ);
+    const lookup = lookupTile(state.frontIndex, config, worldX, worldZ);
     if (!lookup.found) {
       return { elevation: 0, normal: new three.Vector3(0, 1, 0), valid: false };
     }
     return sampleFromLookup(lookup);
   };
   const getElevation = (worldX, worldZ) => {
-    if (!hasSnapshot) {
+    if (!state.hasSnapshot) {
       return { elevation: 0, valid: false };
     }
-    const lookup = lookupTile(worldX, worldZ);
+    const lookup = lookupTile(state.frontIndex, config, worldX, worldZ);
     if (!lookup.found) {
       return { elevation: 0, valid: false };
     }
-    return sampleElevationFromLookup(lookup);
+    const height = rawHeightFromLookup(lookup);
+    return {
+      elevation: config.originY + height * config.elevationScale,
+      valid: true
+    };
+  };
+  const tileFromLookup = (lookup) => {
+    if (!lookup.found) return null;
+    return {
+      space: lookup.space,
+      level: lookup.level,
+      x: lookup.tileX,
+      y: lookup.tileY,
+      index: lookup.leafIndex
+    };
+  };
+  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 a = elevationBase + rawMin * config.elevationScale;
+    const b = elevationBase + rawMax * config.elevationScale;
+    return {
+      space: lookup.space,
+      level: lookup.level,
+      x: lookup.tileX,
+      y: lookup.tileY,
+      index: lookup.leafIndex,
+      minElevation: Math.min(a, b),
+      maxElevation: Math.max(a, b)
+    };
+  };
+  const invalidSurfaceSample = (dx, dy, dz) => ({
+    position: new three.Vector3(),
+    normal: new three.Vector3(0, 1, 0),
+    direction: new three.Vector3(dx, dy, dz),
+    elevation: 0,
+    valid: false
+  });
+  const surfaceLookup = (px, py, pz) => {
+    if (!surfaceOps || !surfaceOps.positionToKey(px, py, pz, keyScratch)) {
+      return { found: false };
+    }
+    return lookupTileByFaceUV(
+      state.frontIndex,
+      surfaceLookupConfig(),
+      keyScratch.space,
+      keyScratch.u,
+      keyScratch.v
+    );
+  };
+  const sampleSurfaceByPosition = (px, py, pz) => {
+    if (!state.hasSnapshot || !surfaceOps) return invalidSurfaceSample(0, 1, 0);
+    if (!surfaceOps.positionToKey(px, py, pz, keyScratch)) {
+      return invalidSurfaceSample(0, 1, 0);
+    }
+    const key = keyScratch;
+    const lookup = lookupTileByFaceUV(
+      state.frontIndex,
+      surfaceLookupConfig(),
+      key.space,
+      key.u,
+      key.v
+    );
+    if (!lookup.found) return invalidSurfaceSample(key.dirX, key.dirY, key.dirZ);
+    const height = rawHeightFromLookup(lookup);
+    const elevation = height * config.elevationScale;
+    const position = new three.Vector3();
+    surfaceOps.surfacePosition(key, elevation, position);
+    const normal = surfaceOps.surfaceNormal(key, {
+      elevation: state.frontElevation,
+      shape,
+      leafIndex: lookup.leafIndex,
+      gx: gridScratch.gx,
+      gy: gridScratch.gy,
+      innerTileSegments: config.innerTileSegments,
+      elevationScale: config.elevationScale,
+      level: lookup.level
+    });
+    return {
+      position,
+      normal,
+      direction: new three.Vector3(key.dirX, key.dirY, key.dirZ),
+      elevation,
+      valid: true
+    };
   };
   const api = {
     get generation() {
-      return generationCount;
+      return state.generation;
     },
     get ready() {
-      return hasSnapshot;
+      return state.hasSnapshot;
+    },
+    get hasSurface() {
+      return surfaceOps !== null;
     },
     updateConfig(nextConfig) {
       config = nextConfig;
-      edgeVertexCount = config.innerTileSegments + 3;
-      verticesPerNode = edgeVertexCount * edgeVertexCount;
-      totalElements = maxNodes * verticesPerNode;
+      shape.edgeVertexCount = config.innerTileSegments + 3;
+      shape.verticesPerNode = shape.edgeVertexCount * shape.edgeVertexCount;
+      totalElements = maxNodes * shape.verticesPerNode;
     },
     triggerReadback(renderer, attribute, spatialIndex, boundsAttribute, activeLeafCount) {
-      if (readbackPending) return;
-      const withReadback = renderer;
-      if (!withReadback.getArrayBufferAsync) return;
-      if (spatialIndex.stampGen === lastScheduledStampGen) return;
-      cloneSpatialIndex(backIndex, spatialIndex);
-      lastScheduledStampGen = spatialIndex.stampGen;
-      const capturedLeafCount = activeLeafCount ?? 0;
-      const capturedScale = config.elevationScale;
-      const capturedOriginY = config.originY;
-      readbackPending = true;
-      const elevationPromise = withReadback.getArrayBufferAsync(attribute);
-      const boundsPromise = boundsAttribute ? withReadback.getArrayBufferAsync(boundsAttribute) : null;
-      const onComplete = (elevResult, boundsResult) => {
-        const data = new Float32Array(elevResult);
-        backElevation.fill(0);
-        backElevation.set(data.subarray(0, totalElements));
-        let boundsValid = capturedLeafCount === 0;
-        if (boundsResult) {
-          const rawBounds = new Float32Array(boundsResult);
-          backTileBounds.fill(0);
-          backTileBounds.set(rawBounds.subarray(0, capturedLeafCount * 2));
-          for (let i = 0; i < capturedLeafCount; i += 1) {
-            if ((rawBounds[i * 2 + 1] ?? 0) !== 0) {
-              boundsValid = true;
-              break;
-            }
-          }
-        }
-        const oldFrontElevation = frontElevation;
-        const oldFrontIndex = frontIndex;
-        frontElevation = backElevation;
-        frontIndex = backIndex;
-        frontLeafCount = capturedLeafCount;
-        backElevation = oldFrontElevation;
-        backIndex = oldFrontIndex;
-        if (boundsResult && boundsValid) {
-          const oldFrontBounds = frontTileBounds;
-          frontTileBounds = backTileBounds;
-          backTileBounds = oldFrontBounds;
-        }
-        if (boundsResult && boundsValid && capturedLeafCount > 0) {
-          let gMin = Infinity;
-          let gMax = -Infinity;
-          for (let i = 0; i < capturedLeafCount; i++) {
-            const rawMin = frontTileBounds[i * 2];
-            const rawMax = frontTileBounds[i * 2 + 1];
-            const a = capturedOriginY + rawMin * capturedScale;
-            const b = capturedOriginY + rawMax * capturedScale;
-            gMin = Math.min(gMin, a, b);
-            gMax = Math.max(gMax, a, b);
-          }
-          globalRange = { min: gMin, max: gMax };
-        }
-        hasSnapshot = true;
-        generationCount += 1;
-      };
-      if (boundsPromise) {
-        Promise.all([elevationPromise, boundsPromise]).then(([elev, bounds]) => onComplete(elev, bounds)).finally(() => {
-          readbackPending = false;
-        });
-      } else {
-        elevationPromise.then((elev) => onComplete(elev, null)).finally(() => {
-          readbackPending = false;
-        });
-      }
+      triggerSnapshotReadback(state, renderer, attribute, spatialIndex, boundsAttribute, {
+        activeLeafCount: activeLeafCount ?? 0,
+        totalElements,
+        verticesPerNode: shape.verticesPerNode,
+        elevationScale: config.elevationScale,
+        originY: config.originY
+      });
+    },
+    dispose() {
+      disposeSnapshotReadback(state);
     },
     getElevation(worldX, worldZ) {
       const sample = getElevation(worldX, worldZ);
@@ -1625,43 +3674,26 @@ function createCpuTerrainCache(maxNodes, initialConfig) {
       return sampleTerrain(worldX, worldZ).normal;
     },
     getTile(worldX, worldZ) {
-      if (!hasSnapshot) return null;
-      const lookup = lookupTile(worldX, worldZ);
-      if (!lookup.found) return null;
-      return {
-        level: lookup.level,
-        x: lookup.tileX,
-        y: lookup.tileY,
-        index: lookup.leafIndex
-      };
+      if (!state.hasSnapshot) return null;
+      return tileFromLookup(lookupTile(state.frontIndex, config, worldX, worldZ));
     },
     getTileBounds(worldX, worldZ) {
-      if (!hasSnapshot) return null;
-      const lookup = lookupTile(worldX, worldZ);
-      if (!lookup.found || lookup.leafIndex >= frontLeafCount) return null;
-      const rawMin = frontTileBounds[lookup.leafIndex * 2];
-      const rawMax = frontTileBounds[lookup.leafIndex * 2 + 1];
-      const a = config.originY + rawMin * config.elevationScale;
-      const b = config.originY + rawMax * config.elevationScale;
-      return {
-        level: lookup.level,
-        x: lookup.tileX,
-        y: lookup.tileY,
-        index: lookup.leafIndex,
-        minElevation: Math.min(a, b),
-        maxElevation: Math.max(a, b)
-      };
+      if (!state.hasSnapshot) return null;
+      return tileBoundsFromLookup(
+        lookupTile(state.frontIndex, config, worldX, worldZ),
+        config.originY
+      );
     },
     getGlobalElevationRange() {
-      return globalRange;
+      return state.globalRange;
     },
     sampleTerrainBatch(positions) {
       const count = Math.floor(positions.length / 2);
       const elevations = new Float32Array(count);
       const normals = new Float32Array(count * 3);
       const valid = new Uint8Array(count);
-      if (!hasSnapshot) {
-        return { elevations, normals, valid, generation: generationCount };
+      if (!state.hasSnapshot) {
+        return { elevations, normals, valid, generation: state.generation };
       }
       let lastTile;
       for (let i = 0; i < count; i += 1) {
@@ -1672,6 +3704,7 @@ function createCpuTerrainCache(maxNodes, initialConfig) {
           lookup = {
             found: true,
             leafIndex: lastTile.leafIndex,
+            space: 0,
             level: lastTile.level,
             tileX: lastTile.tileX,
             tileY: lastTile.tileY,
@@ -1680,7 +3713,7 @@ function createCpuTerrainCache(maxNodes, initialConfig) {
             localV: (worldZ - lastTile.tileMinZ) / lastTile.tileSize
           };
         } else {
-          lookup = lookupTile(worldX, worldZ);
+          lookup = lookupTile(state.frontIndex, config, worldX, worldZ);
           if (lookup.found) {
             lastTile = {
               leafIndex: lookup.leafIndex,
@@ -1706,40 +3739,63 @@ function createCpuTerrainCache(maxNodes, initialConfig) {
         normals[i * 3 + 2] = sample.normal.z;
         valid[i] = 1;
       }
-      return { elevations, normals, valid, generation: generationCount };
-    },
-    sampleTerrain
-  };
-  return api;
-}
-
-function createTerrainQuery(cache) {
-  return {
-    get generation() {
-      return cache.generation;
-    },
-    getElevation(worldX, worldZ) {
-      return cache.getElevation(worldX, worldZ);
+      return { elevations, normals, valid, generation: state.generation };
     },
-    getNormal(worldX, worldZ) {
-      return cache.getNormal(worldX, worldZ);
+    sampleTerrain,
+    // ── Generic surface ──
+    sampleSurfaceByPosition,
+    getElevationBySurfacePosition(px, py, pz) {
+      const sample = sampleSurfaceByPosition(px, py, pz);
+      return sample.valid ? sample.elevation : null;
     },
-    getTile(worldX, worldZ) {
-      return cache.getTile(worldX, worldZ);
+    getNormalBySurfacePosition(px, py, pz) {
+      const sample = sampleSurfaceByPosition(px, py, pz);
+      return sample.valid ? sample.normal : null;
     },
-    getTileBounds(worldX, worldZ) {
-      return cache.getTileBounds(worldX, worldZ);
+    getTileBySurfacePosition(px, py, pz) {
+      if (!state.hasSnapshot || !surfaceOps) return null;
+      return tileFromLookup(surfaceLookup(px, py, pz));
     },
-    getGlobalElevationRange() {
-      return cache.getGlobalElevationRange();
+    getTileBoundsBySurfacePosition(px, py, pz) {
+      if (!state.hasSnapshot || !surfaceOps) return null;
+      return tileBoundsFromLookup(surfaceLookup(px, py, pz), 0);
     },
-    sampleTerrain(worldX, worldZ) {
-      return cache.sampleTerrain(worldX, worldZ);
+    sampleSurfaceBatchByPosition(positions) {
+      const count = Math.floor(positions.length / 3);
+      const outPositions = new Float32Array(count * 3);
+      const normals = new Float32Array(count * 3);
+      const elevations = new Float32Array(count);
+      const valid = new Uint8Array(count);
+      if (!state.hasSnapshot || !surfaceOps) {
+        return { positions: outPositions, normals, elevations, valid, generation: state.generation };
+      }
+      for (let i = 0; i < count; i += 1) {
+        const sample = sampleSurfaceByPosition(
+          positions[i * 3] ?? 0,
+          positions[i * 3 + 1] ?? 0,
+          positions[i * 3 + 2] ?? 0
+        );
+        if (!sample.valid) {
+          normals[i * 3 + 1] = 1;
+          continue;
+        }
+        outPositions[i * 3] = sample.position.x;
+        outPositions[i * 3 + 1] = sample.position.y;
+        outPositions[i * 3 + 2] = sample.position.z;
+        normals[i * 3] = sample.normal.x;
+        normals[i * 3 + 1] = sample.normal.y;
+        normals[i * 3 + 2] = sample.normal.z;
+        elevations[i] = sample.elevation;
+        valid[i] = 1;
+      }
+      return { positions: outPositions, normals, elevations, valid, generation: state.generation };
     },
-    sampleTerrainBatch(positions) {
-      return cache.sampleTerrainBatch(positions);
+    getTileElevationRange(space, level, x, y, out) {
+      if (!state.hasSnapshot) return false;
+      return lookupTileElevationRange(state.elevationPyramid, space, level, x, y, out);
     }
   };
+  return api;
 }
 
 const WGSIZE = 64;
@@ -1783,7 +3839,10 @@ const tileBoundsContextTask = work.task((get, work) => {
   return work(() => {
     const data = new Float32Array(maxNodesValue * 2);
     const attribute = new webgpu.StorageBufferAttribute(data, 1);
-    const node = tsl.storage(attribute, "float", maxNodesValue * 2);
+    attribute.name = "tileBounds";
+    const node = tsl.storage(attribute, "float", maxNodesValue * 2).setName(
+      "tileBounds"
+    );
     const verticesPerNode = edgeVertexCount * edgeVertexCount;
     const kernel = buildReductionKernel(elevationFieldContext.node, node, verticesPerNode);
     return { data, attribute, node, kernel };
@@ -1810,8 +3869,11 @@ const terrainQueryTask = work.task((get, work) => {
   const rootSizeValue = get(rootSize);
   const originValue = get(origin);
   const elevationScaleValue = get(elevationScale);
+  const radiusValue = get(radius);
+  const topologyValue = get(topologyTask);
+  const projection = topologyValue.projection;
   return work((prev) => {
-    const shapeKey = `${maxNodesValue}:${innerTileSegmentsValue}`;
+    const shapeKey = `${maxNodesValue}:${innerTileSegmentsValue}:${projection.kind}`;
     const configValues = {
       rootSize: rootSizeValue,
       originX: originValue.x,
@@ -1819,16 +3881,25 @@ const terrainQueryTask = work.task((get, work) => {
       originZ: originValue.z,
       innerTileSegments: innerTileSegmentsValue,
       elevationScale: elevationScaleValue,
-      maxLevel: maxLevelValue
+      maxLevel: maxLevelValue,
+      radius: topologyValue.radius ?? radiusValue,
+      baseU: projection.baseResolution?.u ?? 1,
+      baseV: projection.baseResolution?.v ?? 1
     };
     let cache = prev?.cache;
     let query = prev?.query;
+    let surfaceQuery = prev?.surfaceQuery ?? null;
+    let sphereQuery = prev?.sphereQuery ?? null;
     if (!cache || !query || prev?.shapeKey !== shapeKey) {
-      cache = createCpuTerrainCache(maxNodesValue, configValues);
-      query = createTerrainQuery(cache);
+      prev?.cache?.dispose();
+      cache = createCpuTerrainCache(maxNodesValue, configValues, projection.cpu.createSurfaceOps());
+      const runtime = projection.cpu.createRuntimeQueries(cache);
+      query = runtime.query;
+      surfaceQuery = runtime.surfaceQuery;
+      sphereQuery = runtime.sphereQuery;
     }
     cache.updateConfig(configValues);
-    return { cache, query, shapeKey };
+    return { cache, query, surfaceQuery, sphereQuery, shapeKey };
   });
 }).displayName("terrainQueryTask");
 const terrainReadbackTask = work.task(
@@ -1851,38 +3922,54 @@ const terrainReadbackTask = work.task(
   }
 ).displayName("terrainReadbackTask").lane("gpu");
 
-const surfaceTask = work.task((get, work) => {
-  const customSurface = get(surface);
+const topologyTask = work.task((get, work) => {
+  const customTopology = get(topology);
   const rootSizeVal = get(rootSize);
   const originVal = get(origin);
   return work(() => {
-    if (customSurface) return customSurface;
-    return createFlatSurface({ rootSize: rootSizeVal, origin: originVal });
+    if (customTopology) return customTopology;
+    return createFlatTopology({ rootSize: rootSizeVal, origin: originVal });
   });
-}).displayName("surfaceTask");
+}).displayName("topologyTask");
 const quadtreeConfigTask = work.task((get, work) => {
-  const surfaceVal = get(surfaceTask);
+  const topologyVal = get(topologyTask);
   const maxNodesVal = get(maxNodes);
   const maxLevelVal = get(maxLevel);
   return work(() => {
-    const state = createState({ maxNodes: maxNodesVal, maxLevel: maxLevelVal }, surfaceVal);
+    const state = createState({ maxNodes: maxNodesVal, maxLevel: maxLevelVal }, topologyVal);
     return {
       state,
-      surface: surfaceVal
+      topology: topologyVal
     };
   });
 }).displayName("quadtreeConfigTask");
 const quadtreeUpdateTask = work.task((get, work) => {
   const quadtreeConfig = get(quadtreeConfigTask);
   const quadtreeUpdateConfig = get(quadtreeUpdate);
-  const { query: terrainQuery } = get(terrainQueryTask);
+  const { query: terrainQuery, surfaceQuery, cache } = get(terrainQueryTask);
+  const elevationScaleValue = get(elevationScale);
   let outLeaves = void 0;
+  const cameraPosition = new three.Vector3();
+  const elevationRangeScratch = { min: 0, max: 0 };
   return work(() => {
     const cam = quadtreeUpdateConfig.cameraOrigin;
-    quadtreeUpdateConfig.elevationAtCameraXZ = terrainQuery.getElevation(cam.x, cam.z) ?? 0;
+    if (surfaceQuery) {
+      cameraPosition.set(cam.x, cam.y, cam.z);
+      quadtreeUpdateConfig.elevationAtCameraXZ = surfaceQuery.getElevationByPosition(cameraPosition) ?? 0;
+    } else {
+      quadtreeUpdateConfig.elevationAtCameraXZ = terrainQuery.getElevation(cam.x, cam.z) ?? 0;
+    }
+    quadtreeUpdateConfig.tileElevationRange = (space, level, x, y, out) => {
+      if (!cache.getTileElevationRange(space, level, x, y, elevationRangeScratch)) {
+        return false;
+      }
+      out.min = elevationRangeScratch.min * elevationScaleValue;
+      out.max = elevationRangeScratch.max * elevationScaleValue;
+      return true;
+    };
     outLeaves = update(
       quadtreeConfig.state,
-      quadtreeConfig.surface,
+      quadtreeConfig.topology,
       quadtreeUpdateConfig,
       outLeaves
     );
@@ -1904,7 +3991,7 @@ const leafGpuBufferTask = work.task((get, work) => {
       leafStorage.data[offset] = leafSet.level[i] ?? 0;
       leafStorage.data[offset + 1] = leafSet.x[i] ?? 0;
       leafStorage.data[offset + 2] = leafSet.y[i] ?? 0;
-      leafStorage.data[offset + 3] = 1;
+      leafStorage.data[offset + 3] = leafSet.space[i] ?? 0;
     }
     leafStorage.attribute.needsUpdate = true;
     leafStorage.node.needsUpdate = true;
@@ -1917,23 +4004,6 @@ const leafGpuBufferTask = work.task((get, work) => {
   });
 }).displayName("leafGpuBufferTask");
 
-function createElevationFunction(callback) {
-  const tslFunction = (args) => {
-    const params = {
-      worldPosition: args.worldPosition,
-      rootSize: args.rootSize,
-      rootUV: args.rootUV,
-      tileUV: args.tileUV,
-      tileLevel: args.tileLevel,
-      tileSize: args.tileSize,
-      tileOriginVec2: args.tileOriginVec2,
-      nodeIndex: args.nodeIndex
-    };
-    return callback(params);
-  };
-  return TSL_js.Fn(tslFunction);
-}
-
 function createTerrainUniforms(params) {
   const sanitizedId = params.instanceId?.replace(/-/g, "_");
   const suffix = sanitizedId ? `_${sanitizedId}` : "";
@@ -1946,12 +4016,14 @@ function createTerrainUniforms(params) {
   );
   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
+    uElevationScale,
+    uRadius
   };
 }
 
@@ -1965,6 +4037,7 @@ const createUniformsTask = work.task((get, work) => {
     innerTileSegments: get(innerTileSegments),
     skirtScale: get(skirtScale),
     elevationScale: get(elevationScale),
+    radius: get(radius),
     instanceId: get(instanceIdTask)
   };
   return work(() => createTerrainUniforms(uniformParams));
@@ -1976,6 +4049,7 @@ const updateUniformsTask = work.task((get, work) => {
   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(
@@ -1986,6 +4060,7 @@ const updateUniformsTask = work.task((get, work) => {
     terrainUniformsContext.uInnerTileSegments.value = innerTileSegmentsVal;
     terrainUniformsContext.uSkirtScale.value = skirtScaleVal;
     terrainUniformsContext.uElevationScale.value = elevationScaleVal;
+    terrainUniformsContext.uRadius.value = radiusVal;
     return terrainUniformsContext;
   });
 }).displayName("updateUniformsTask");
@@ -1997,7 +4072,8 @@ const createElevationFieldContextTask = work.task((get, work) => {
   return work(() => {
     const data = new Float32Array(totalElements);
     const attribute = new webgpu.StorageBufferAttribute(data, 1);
-    const node = tsl.storage(attribute, "float", totalElements);
+    attribute.name = "elevationField";
+    const node = tsl.storage(attribute, "float", totalElements).setName("elevationField");
     return {
       data,
       attribute,
@@ -2008,8 +4084,9 @@ const createElevationFieldContextTask = work.task((get, work) => {
 const tileNodesTask = work.task((get, work) => {
   const leafStorage = get(leafStorageTask);
   const uniforms = get(updateUniformsTask);
+  const topology = get(topologyTask);
   return work(() => {
-    return createTileCompute(leafStorage, uniforms);
+    return createTileCompute(leafStorage, uniforms, topology.projection);
   });
 }).displayName("tileNodesTask");
 const elevationFieldStageTask = work.task((get, work) => {
@@ -2044,30 +4121,6 @@ const createTerrainFieldTextureTask = work.task(
     );
   }
 ).displayName("createTerrainFieldTextureTask");
-function createNormalFromElevationField(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);
-      const normal = tsl.vec3(dhdx.negate(), tsl.float(1), dhdz.negate()).normalize();
-      return tsl.vec2(normal.x, normal.z);
-    }
-  );
-}
 const terrainFieldStageTask = work.task((get, work) => {
   const upstream = get(elevationFieldStageTask);
   const elevationFieldContext = get(createElevationFieldContextTask);
@@ -2075,635 +4128,115 @@ const terrainFieldStageTask = work.task((get, work) => {
   const tileEdgeVertexCount = get(innerTileSegments) + 3;
   const tile = get(tileNodesTask);
   const uniforms = get(updateUniformsTask);
+  const topology = get(topologyTask);
   return work(() => {
-    const computeNormal = createNormalFromElevationField(
-      elevationFieldContext.node,
-      tileEdgeVertexCount
-    );
+    const computeNormal = topology.projection.gpu.createFieldNormal({
+      elevationFieldNode: elevationFieldContext.node,
+      edgeVertexCount: tileEdgeVertexCount,
+      tile,
+      uniforms
+    });
     return [
       ...upstream,
       (nodeIndex, globalVertexIndex, _uv, localCoordinates) => {
         const ix = tsl.int(localCoordinates.x);
         const iy = tsl.int(localCoordinates.y);
-        const tileSize = tile.tileSize(nodeIndex);
         const height = elevationFieldContext.node.element(globalVertexIndex);
-        const normalXZ = computeNormal(
-          nodeIndex,
-          tileSize,
-          ix,
-          iy,
-          uniforms.uElevationScale
-        );
+        const normal = computeNormal(nodeIndex, ix, iy);
         storeTerrainField(
           terrainFieldStorage,
           ix,
           iy,
           nodeIndex,
-          packTerrainFieldSample(height, normalXZ)
+          packTerrainFieldSample(height, normal)
         );
-      }
-    ];
-  });
-}).displayName("terrainFieldStageTask");
-
-const compileComputeTask = work.task((get, work) => {
-  const pipeline = get(terrainFieldStageTask);
-  const edgeVertexCount = get(innerTileSegments) + 3;
-  return work(
-    () => compileComputePipeline(pipeline, edgeVertexCount, {
-      preferSingleKernelWhenPossible: false
-    })
-  );
-}).displayName("compileComputeTask");
-const executeComputeTask = work.task(
-  (get, work, { resources }) => {
-    const { execute } = get(compileComputeTask);
-    const leafState = get(leafGpuBufferTask);
-    return work(
-      () => resources?.renderer ? execute(resources.renderer, leafState.count) : () => {
-      }
-    );
-  }
-).displayName("executeComputeTask").lane("gpu");
-function createComputePipelineTasks(leafStageTask) {
-  const compile = work.task((get, work) => {
-    const pipeline = get(leafStageTask);
-    const edgeVertexCount = get(innerTileSegments) + 3;
-    return work(
-      () => compileComputePipeline(pipeline, edgeVertexCount, {
-        preferSingleKernelWhenPossible: false
-      })
-    );
-  }).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");
-  return { compile, execute };
-}
-
-const SLOT_STRIDE = 6;
-function nextPow2(n) {
-  let x = 1;
-  while (x < n) x <<= 1;
-  return x;
-}
-function createGpuSpatialIndex(maxEntries) {
-  const size = nextPow2(Math.max(2, maxEntries * 2));
-  const data = new Uint32Array(size * SLOT_STRIDE);
-  const attribute = new webgpu.StorageBufferAttribute(data, SLOT_STRIDE);
-  const node = tsl.storage(attribute, "u32", 1).toReadOnly().setName("gpuSpatialIndex");
-  const stampGen = tsl.uniform(tsl.uint(1)).setName("uGpuSpatialIndexStampGen");
-  return {
-    data,
-    size,
-    mask: size - 1,
-    stampGen,
-    attribute,
-    node
-  };
-}
-function uploadGpuSpatialIndex(gpuIndex, cpuIndex) {
-  if (gpuIndex.size !== cpuIndex.size) {
-    throw new Error(
-      `Spatial index size mismatch (gpu=${gpuIndex.size}, cpu=${cpuIndex.size}).`
-    );
-  }
-  for (let i = 0; i < cpuIndex.size; i += 1) {
-    const base = i * SLOT_STRIDE;
-    gpuIndex.data[base] = cpuIndex.stamp[i] ?? 0;
-    gpuIndex.data[base + 1] = cpuIndex.keysSpace[i] ?? 0;
-    gpuIndex.data[base + 2] = cpuIndex.keysLevel[i] ?? 0;
-    gpuIndex.data[base + 3] = cpuIndex.keysX[i] ?? 0;
-    gpuIndex.data[base + 4] = cpuIndex.keysY[i] ?? 0;
-    gpuIndex.data[base + 5] = cpuIndex.values[i] ?? 0;
-  }
-  gpuIndex.stampGen.value = cpuIndex.stampGen >>> 0;
-  gpuIndex.attribute.needsUpdate = true;
-  gpuIndex.node.needsUpdate = true;
-}
-function readGpuSpatialIndexValue(spatialIndex, slot, fieldOffset) {
-  const offset = tsl.int(slot).mul(tsl.int(SLOT_STRIDE)).add(tsl.int(fieldOffset));
-  return spatialIndex.node.element(offset).toUint();
-}
-const mix32 = tsl.Fn(([x]) => {
-  const v = tsl.uint(x).toVar();
-  v.assign(v.bitXor(v.shiftRight(tsl.uint(16))));
-  v.assign(v.mul(tsl.uint(2146121005)));
-  v.assign(v.bitXor(v.shiftRight(tsl.uint(15))));
-  v.assign(v.mul(tsl.uint(2221713035)));
-  v.assign(v.bitXor(v.shiftRight(tsl.uint(16))));
-  return v;
-});
-const hashKey = tsl.Fn(([space, level, x, y]) => {
-  const s = tsl.uint(space).bitAnd(tsl.uint(255));
-  const l = tsl.uint(level).bitAnd(tsl.uint(255));
-  const h = s.bitXor(l.shiftLeft(tsl.uint(8))).bitXor(mix32(tsl.uint(x))).bitXor(mix32(tsl.uint(y)));
-  return mix32(h);
-});
-const createGpuSpatialLookup = (spatialIndex) => {
-  const slotCount = spatialIndex.size;
-  const mask = tsl.uint(spatialIndex.mask);
-  const stampGen = spatialIndex.stampGen.toUint();
-  const emptyValue = tsl.int(-1);
-  return tsl.Fn(([space, level, x, y]) => {
-    const s = tsl.uint(space).bitAnd(tsl.uint(255));
-    const l = tsl.uint(level).bitAnd(tsl.uint(255));
-    const xx = tsl.uint(x);
-    const yy = tsl.uint(y);
-    const result = emptyValue.toVar();
-    const slot = hashKey(s, l, xx, yy).bitAnd(mask).toVar();
-    const probes = tsl.int(0).toVar();
-    tsl.Loop(slotCount, () => {
-      const stamp = readGpuSpatialIndexValue(spatialIndex, slot, 0);
-      tsl.If(stamp.notEqual(stampGen), () => {
-        tsl.Break();
-      });
-      const ks = readGpuSpatialIndexValue(spatialIndex, slot, 1);
-      const kl = readGpuSpatialIndexValue(spatialIndex, slot, 2);
-      const kx = readGpuSpatialIndexValue(spatialIndex, slot, 3);
-      const ky = readGpuSpatialIndexValue(spatialIndex, slot, 4);
-      tsl.If(
-        ks.equal(s).and(kl.equal(l)).and(kx.equal(xx)).and(ky.equal(yy)),
-        () => {
-          result.assign(tsl.int(readGpuSpatialIndexValue(spatialIndex, slot, 5)));
-          tsl.Break();
-        }
-      );
-      slot.assign(slot.add(tsl.uint(1)).bitAnd(mask));
-      probes.addAssign(1);
-    });
-    return result;
-  });
-};
-const createTileIndexFromWorldPosition = (spatialIndex, uniforms, maxLevel) => {
-  const lookup = createGpuSpatialLookup(spatialIndex);
-  const levelCount = Math.max(1, maxLevel + 1);
-  return tsl.Fn(([worldX, worldZ]) => {
-    const rootOrigin = uniforms.uRootOrigin.toVar();
-    const rootSize = uniforms.uRootSize.toVar();
-    const halfRoot = rootSize.mul(tsl.float(0.5));
-    const tileIndex = tsl.int(-1).toVar();
-    const tileU = tsl.float(0).toVar();
-    const tileV = tsl.float(0).toVar();
-    const i = tsl.int(0).toVar();
-    tsl.Loop(levelCount, () => {
-      const level = tsl.int(maxLevel).sub(i).toVar();
-      const scale = tsl.pow(tsl.float(2), level.toFloat());
-      const tileSize = rootSize.div(scale);
-      const tileX = worldX.sub(rootOrigin.x).add(halfRoot).div(tileSize).floor().toInt();
-      const tileY = worldZ.sub(rootOrigin.z).add(halfRoot).div(tileSize).floor().toInt();
-      const maybeIndex = lookup(tsl.int(0), level, tileX, tileY).toVar();
-      tsl.If(maybeIndex.greaterThanEqual(tsl.int(0)), () => {
-        const minX = rootOrigin.x.add(tileX.toFloat().mul(tileSize)).sub(halfRoot);
-        const minZ = rootOrigin.z.add(tileY.toFloat().mul(tileSize)).sub(halfRoot);
-        tileIndex.assign(maybeIndex);
-        tileU.assign(worldX.sub(minX).div(tileSize));
-        tileV.assign(worldZ.sub(minZ).div(tileSize));
-        tsl.Break();
-      });
-      i.addAssign(1);
-    });
-    return tsl.vec3(tileIndex.toFloat(), tileU, tileV);
-  });
-};
-
-const gpuSpatialIndexStorageTask = work.task((get, work) => {
-  const maxNodesValue = get(maxNodes);
-  return work(() => createGpuSpatialIndex(maxNodesValue));
-}).displayName("gpuSpatialIndexStorageTask");
-const gpuSpatialIndexUploadTask = work.task((get, work) => {
-  const quadtreeConfig = get(quadtreeConfigTask);
-  get(quadtreeUpdateTask);
-  const gpuSpatialIndex = get(gpuSpatialIndexStorageTask);
-  return work(() => {
-    uploadGpuSpatialIndex(gpuSpatialIndex, quadtreeConfig.state.leafIndex);
-    return gpuSpatialIndex;
-  });
-}).displayName("gpuSpatialIndexUploadTask");
-
-function createTerrainSampleNode(params) {
-  const tileLookup = createTileIndexFromWorldPosition(
-    params.spatialIndex,
-    params.uniforms,
-    maxLevel.get()
-  );
-  return tsl.Fn(([worldX, worldZ]) => {
-    const tileResult = tileLookup(worldX, worldZ).toVar();
-    const tileIndex = tsl.int(tileResult.x).toVar();
-    const safeTileIndex = tileIndex.max(tsl.int(0)).toVar();
-    const u = tileResult.y.toVar();
-    const v = tileResult.z.toVar();
-    const fieldU = tileLocalToFieldUV$1(
-      u,
-      params.uniforms.uInnerTileSegments
-    ).toVar();
-    const fieldV = tileLocalToFieldUV$1(
-      v,
-      params.uniforms.uInnerTileSegments
-    ).toVar();
-    const found = tileIndex.greaterThanEqual(tsl.int(0)).toVar();
-    const sampled = sampleTerrainField(
-      params.terrainFieldStorage,
-      fieldU,
-      fieldV,
-      safeTileIndex
-    ).toVar();
-    const nx = sampled.g.toVar();
-    const nz = sampled.b.toVar();
-    const ny = tsl.float(1).sub(nx.mul(nx)).sub(nz.mul(nz)).max(0).sqrt();
-    const valid = found.select(tsl.float(1), tsl.float(0)).toVar();
-    return tsl.vec4(
-      sampled.r.mul(valid),
-      nx.mul(valid),
-      ny.mul(valid),
-      nz.mul(valid)
-    );
-  });
-}
-function createTerrainSampler(params) {
-  const elevationNode = createElevationFunction(params.elevationCallback);
-  const terrainSampleAt = createTerrainSampleNode(params);
-  const evaluateElevationAt = tsl.Fn(([worldX, worldZ]) => {
-    const rootOrigin = params.uniforms.uRootOrigin.toVar();
-    const rootSize = params.uniforms.uRootSize.toVar();
-    const centeredX = worldX.sub(rootOrigin.x);
-    const centeredZ = worldZ.sub(rootOrigin.z);
-    const rootUV = tsl.vec2(
-      centeredX.div(rootSize).add(0.5),
-      centeredZ.div(rootSize).mul(tsl.float(-1)).add(0.5)
-    ).toVar();
-    return elevationNode({
-      worldPosition: tsl.vec3(worldX, rootOrigin.y, worldZ),
-      rootSize,
-      rootUV,
-      tileUV: rootUV,
-      tileLevel: tsl.int(0),
-      tileSize: rootSize,
-      tileOriginVec2: tsl.vec2(0, 0),
-      nodeIndex: tsl.int(0)
-    });
+      }
+    ];
   });
-  const sampleTerrain = tsl.Fn(
-    ([worldX, worldZ]) => terrainSampleAt(worldX, worldZ)
-  );
-  const sampleElevation = tsl.Fn(
-    ([worldX, worldZ]) => terrainSampleAt(worldX, worldZ).x
-  );
-  const sampleNormal = tsl.Fn(
-    ([worldX, worldZ]) => tsl.vec3(
-      terrainSampleAt(worldX, worldZ).y,
-      terrainSampleAt(worldX, worldZ).z,
-      terrainSampleAt(worldX, worldZ).w
-    )
-  );
-  const sampleValidity = tsl.Fn(
-    ([worldX, worldZ]) => terrainSampleAt(worldX, worldZ).y.abs().add(terrainSampleAt(worldX, worldZ).z.abs()).add(terrainSampleAt(worldX, worldZ).w.abs()).greaterThan(tsl.float(0)).select(tsl.float(1), tsl.float(0))
-  );
-  const evaluateElevation = tsl.Fn(
-    ([worldX, worldZ]) => evaluateElevationAt(worldX, worldZ)
-  );
-  const evaluateNormalNode = tsl.Fn(
-    ([worldX, worldZ, epsilon]) => {
-      const eps = epsilon ?? tsl.float(0.1);
-      const elevationScale = params.uniforms.uElevationScale.toVar();
-      const hL = evaluateElevationAt(worldX.sub(eps), worldZ).mul(
-        elevationScale
-      );
-      const hR = evaluateElevationAt(worldX.add(eps), worldZ).mul(
-        elevationScale
-      );
-      const hD = evaluateElevationAt(worldX, worldZ.sub(eps)).mul(
-        elevationScale
-      );
-      const hU = evaluateElevationAt(worldX, worldZ.add(eps)).mul(
-        elevationScale
+}).displayName("terrainFieldStageTask");
+
+const { compile: compileComputeTask, execute: executeComputeTask } = createComputePipelineTasks(terrainFieldStageTask);
+function createComputePipelineTasks(leafStageTask) {
+  const compile = work.task((get, work) => {
+    const pipeline = get(leafStageTask);
+    const edgeVertexCount = get(innerTileSegments) + 3;
+    return work(
+      () => compileComputePipeline(pipeline, edgeVertexCount, {
+        })
+    );
+  }).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) : () => {
+        }
       );
-      const inv2eps = tsl.float(0.5).div(eps);
-      const dhdx = hR.sub(hL).mul(inv2eps);
-      const dhdz = hU.sub(hD).mul(inv2eps);
-      return tsl.vec3(dhdx.negate(), tsl.float(1), dhdz.negate()).normalize();
     }
-  );
-  const evaluateNormal = (worldX, worldZ, epsilon) => evaluateNormalNode(worldX, worldZ, epsilon ?? tsl.float(0.1));
-  return {
-    sampleElevation,
-    sampleNormal,
-    sampleTerrain,
-    sampleValidity,
-    evaluateElevation,
-    evaluateNormal
-  };
+  ).displayName("executeComputeTask").lane("gpu");
+  return { compile, execute };
 }
 
+const gpuSpatialIndexStorageTask = work.task((get, work) => {
+  const maxNodesValue = get(maxNodes);
+  return work(() => createGpuSpatialIndex(maxNodesValue));
+}).displayName("gpuSpatialIndexStorageTask");
+const gpuSpatialIndexUploadTask = work.task((get, work) => {
+  const quadtreeConfig = get(quadtreeConfigTask);
+  get(quadtreeUpdateTask);
+  const gpuSpatialIndex = get(gpuSpatialIndexStorageTask);
+  return work(() => {
+    uploadGpuSpatialIndex(gpuSpatialIndex, quadtreeConfig.state.leafIndex);
+    return gpuSpatialIndex;
+  });
+}).displayName("gpuSpatialIndexUploadTask");
+
 const createTerrainSamplerTask = work.task((get, work) => {
   const terrainFieldStorage = get(createTerrainFieldTextureTask);
   const spatialIndex = get(gpuSpatialIndexStorageTask);
   const uniforms = get(updateUniformsTask);
   const elevationCallback = get(elevationFn);
+  const maxLevelValue = get(maxLevel);
+  const projection = get(topologyTask).projection;
   return work(
     () => createTerrainSampler({
       terrainFieldStorage,
       spatialIndex,
       uniforms,
-      elevationCallback
+      elevationCallback,
+      maxLevel: maxLevelValue,
+      projection
     })
   );
 }).displayName("createTerrainSamplerTask");
 
-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 createTileBaseWorldPosition(leafStorage, terrainUniforms) {
-  return tsl.Fn(() => {
-    const nodeIndex = tsl.int(tsl.instanceIndex);
-    const nodeOffset = nodeIndex.mul(tsl.int(4));
-    const nodeLevel = leafStorage.node.element(nodeOffset).toInt();
-    const nodeX = leafStorage.node.element(nodeOffset.add(tsl.int(1))).toFloat();
-    const nodeY = leafStorage.node.element(nodeOffset.add(tsl.int(2))).toFloat();
-    const rootSize = terrainUniforms.uRootSize.toVar();
-    const rootOrigin = terrainUniforms.uRootOrigin.toVar();
-    const half = tsl.float(0.5);
-    const size = rootSize.div(tsl.pow(tsl.float(2), nodeLevel.toFloat()));
-    const halfRoot = rootSize.mul(half);
-    const centerX = rootOrigin.x.add(nodeX.add(half).mul(size)).sub(halfRoot);
-    const centerZ = rootOrigin.z.add(nodeY.add(half).mul(size)).sub(halfRoot);
-    const clampedX = tsl.positionLocal.x.max(half.negate()).min(half);
-    const clampedZ = tsl.positionLocal.z.max(half.negate()).min(half);
-    const worldX = centerX.add(clampedX.mul(size));
-    const worldZ = centerZ.add(clampedZ.mul(size));
-    return tsl.vec3(worldX, rootOrigin.y, worldZ);
-  });
-}
-function createTileElevation(terrainUniforms, terrainFieldStorage) {
-  if (!terrainFieldStorage) return tsl.float(0);
-  const innerSegs = terrainUniforms.uInnerTileSegments;
-  const u = tileLocalToFieldUV$1(tsl.positionLocal.x.add(tsl.float(0.5)), innerSegs);
-  const v = tileLocalToFieldUV$1(tsl.positionLocal.z.add(tsl.float(0.5)), innerSegs);
-  return sampleTerrainFieldElevation(
-    terrainFieldStorage,
-    u,
-    v,
-    tsl.int(tsl.instanceIndex)
-  ).mul(terrainUniforms.uElevationScale);
-}
-function createNormalAssignment(terrainUniforms, terrainFieldStorage) {
-  if (!terrainFieldStorage) return;
-  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);
-  const normalXZ = loadTerrainFieldNormal(
-    terrainFieldStorage,
-    ix,
-    iy,
-    nodeIndex
-  );
-  const nx = normalXZ.x;
-  const nz = normalXZ.y;
-  const nySq = tsl.float(1).sub(nx.mul(nx)).sub(nz.mul(nz)).max(tsl.float(0));
-  const ny = nySq.sqrt();
-  tsl.normalLocal.assign(tsl.vec3(nx, ny, nz));
-}
-function createTileWorldPosition(leafStorage, terrainUniforms, terrainFieldStorage) {
-  const baseWorldPosition = createTileBaseWorldPosition(
-    leafStorage,
-    terrainUniforms
-  );
-  return tsl.Fn(() => {
-    const base = baseWorldPosition();
-    const yElevation = createTileElevation(
-      terrainUniforms,
-      terrainFieldStorage
-    );
-    const skirtVertex = isSkirtVertex(terrainUniforms.uInnerTileSegments);
-    const skirtY = base.y.add(yElevation).sub(terrainUniforms.uSkirtScale.toVar());
-    const worldY = tsl.select(skirtVertex, skirtY, base.y.add(yElevation));
-    createNormalAssignment(terrainUniforms, terrainFieldStorage);
-    return tsl.vec3(base.x, worldY, base.z);
-  })();
-}
-
 const positionNodeTask = work.task((get, work) => {
   const leafStorage = get(leafStorageTask);
   const terrainUniforms = get(updateUniformsTask);
   const terrainFieldStorage = get(createTerrainFieldTextureTask);
+  const topology = get(topologyTask);
   return work(
-    () => createTileWorldPosition(
+    () => topology.projection.gpu.renderVertexPosition({
       leafStorage,
-      terrainUniforms,
+      uniforms: terrainUniforms,
       terrainFieldStorage
-    )
+    })
   );
 }).displayName("positionNodeTask");
 
-function intersectRayAabb(ray, minX, minY, minZ, maxX, maxY, maxZ) {
-  let tMin = -Infinity;
-  let tMax = Infinity;
-  const origin = ray.origin;
-  const dir = ray.direction;
-  const slab = (originAxis, dirAxis, minAxis, maxAxis) => {
-    if (Math.abs(dirAxis) < 1e-8) {
-      if (originAxis < minAxis || originAxis > maxAxis) return false;
-      return true;
-    }
-    const inv = 1 / dirAxis;
-    let t0 = (minAxis - originAxis) * inv;
-    let t1 = (maxAxis - originAxis) * inv;
-    if (t0 > t1) {
-      const tmp = t0;
-      t0 = t1;
-      t1 = tmp;
-    }
-    tMin = Math.max(tMin, t0);
-    tMax = Math.min(tMax, t1);
-    return tMax >= tMin;
-  };
-  if (!slab(origin.x, dir.x, minX, maxX) || !slab(origin.y, dir.y, minY, maxY) || !slab(origin.z, dir.z, minZ, maxZ)) {
-    return null;
-  }
-  return { tMin, tMax };
-}
-function getTerrainBounds(config) {
-  const halfRoot = config.rootSize * 0.5;
-  return {
-    minX: config.originX - halfRoot,
-    maxX: config.originX + halfRoot,
-    minZ: config.originZ - halfRoot,
-    maxZ: config.originZ + halfRoot
-  };
-}
-function terrainSignedDistanceFromBounds(query, worldX, worldY, worldZ) {
-  const tileBounds = query.getTileBounds(worldX, worldZ);
-  if (tileBounds) {
-    if (worldY > tileBounds.maxElevation) {
-      return worldY - tileBounds.maxElevation;
-    }
-    if (worldY < tileBounds.minElevation) {
-      return worldY - tileBounds.minElevation;
-    }
-  }
-  const elevation = query.getElevation(worldX, worldZ);
-  if (!Number.isFinite(elevation)) return void 0;
-  return worldY - elevation;
-}
-function terrainSignedDistancePrecise(query, worldX, worldY, worldZ) {
-  const elevation = query.getElevation(worldX, worldZ);
-  if (!Number.isFinite(elevation)) return void 0;
-  return worldY - elevation;
-}
-function cpuRaycast(query, ray, config, options) {
-  const bounds = getTerrainBounds(config);
-  const segment = intersectRayAabb(
-    ray,
-    bounds.minX,
-    config.minY,
-    bounds.minZ,
-    bounds.maxX,
-    config.maxY,
-    bounds.maxZ
-  );
-  if (!segment) return null;
-  const maxDistance = options?.maxDistance ?? Number.POSITIVE_INFINITY;
-  let startT = Math.max(0, segment.tMin);
-  const endT = Math.min(segment.tMax, maxDistance);
-  if (endT < startT) return null;
-  const maxSteps = Math.max(8, options?.maxSteps ?? 128);
-  const refinementSteps = Math.max(1, options?.refinementSteps ?? 8);
-  const point = new three.Vector3();
-  let prevT = startT;
-  ray.at(prevT, point);
-  let prevSignedDistance = terrainSignedDistanceFromBounds(
-    query,
-    point.x,
-    point.y,
-    point.z
-  );
-  if (prevSignedDistance !== void 0 && prevSignedDistance <= 0) {
-    const sample = query.sampleTerrain(point.x, point.z);
-    if (!sample.valid) return null;
-    point.y = sample.elevation;
-    return {
-      position: point.clone(),
-      normal: sample.normal.clone(),
-      distance: ray.origin.distanceTo(point)
-    };
-  }
-  for (let i = 1; i <= maxSteps; i += 1) {
-    const t = startT + (endT - startT) * i / maxSteps;
-    ray.at(t, point);
-    const signedDistance = terrainSignedDistanceFromBounds(
-      query,
-      point.x,
-      point.y,
-      point.z
-    );
-    if (signedDistance === void 0) {
-      prevSignedDistance = void 0;
-      prevT = t;
-      continue;
-    }
-    if (prevSignedDistance !== void 0 && prevSignedDistance > 0 && signedDistance <= 0) {
-      let lo = prevT;
-      let hi = t;
-      for (let r = 0; r < refinementSteps; r += 1) {
-        const mid = (lo + hi) * 0.5;
-        ray.at(mid, point);
-        const midDistance = terrainSignedDistancePrecise(
-          query,
-          point.x,
-          point.y,
-          point.z
-        );
-        if (midDistance === void 0) {
-          lo = mid;
-          continue;
-        }
-        if (midDistance > 0) lo = mid;
-        else hi = mid;
-      }
-      const hitT = hi;
-      ray.at(hitT, point);
-      const sample = query.sampleTerrain(point.x, point.z);
-      if (!sample.valid) return null;
-      point.y = sample.elevation;
-      return {
-        position: point.clone(),
-        normal: sample.normal.clone(),
-        distance: ray.origin.distanceTo(point)
-      };
-    }
-    prevSignedDistance = signedDistance;
-    prevT = t;
-  }
-  return null;
-}
-function cpuRaycastBoundsOnly(ray, config, options) {
-  const bounds = getTerrainBounds(config);
-  const planeY = (config.minY + config.maxY) * 0.5;
-  const dirY = ray.direction.y;
-  if (Math.abs(dirY) < 1e-8) return null;
-  const t = (planeY - ray.origin.y) / dirY;
-  if (t < 0) return null;
-  const maxDistance = options?.maxDistance ?? Number.POSITIVE_INFINITY;
-  if (t > maxDistance) return null;
-  const point = new three.Vector3();
-  ray.at(t, point);
-  if (point.x < bounds.minX || point.x > bounds.maxX || point.z < bounds.minZ || point.z > bounds.maxZ) {
-    return null;
-  }
-  return {
-    position: point,
-    normal: new three.Vector3(0, 1, 0),
-    distance: ray.origin.distanceTo(point)
-  };
-}
-
 function createTerrainRaycast(params) {
   return {
     pick(ray, options) {
-      const config = params.getConfig();
-      const terrainQuery = params.getTerrainQuery();
-      if (terrainQuery) {
-        const precise = cpuRaycast(terrainQuery, ray, config, options);
-        if (precise) return precise;
-      }
-      const coarse = cpuRaycastBoundsOnly(ray, config, options);
-      if (coarse && terrainQuery) {
-        const sample = terrainQuery.sampleTerrain(
-          coarse.position.x,
-          coarse.position.z
-        );
-        if (sample.valid) {
-          coarse.position.y = sample.elevation;
-          coarse.normal.copy(sample.normal);
-        }
-      }
-      return coarse;
+      const projection = params.getProjection();
+      return projection.cpu.raycast({
+        ray,
+        options,
+        terrainQuery: params.getTerrainQuery(),
+        surfaceQuery: params.getSurfaceQuery(),
+        sphereQuery: params.getSphereQuery(),
+        config: params.getConfig()
+      });
     }
   };
 }
@@ -2712,42 +4245,60 @@ const BOUNDS_PADDING = 1;
 const RAYCAST_STATE = Symbol("terrainRaycastTaskState");
 const terrainRaycastTask = work.task(
   (get, work) => {
-    const { query: terrainQuery } = get(terrainQueryTask);
+    const { query: terrainQuery, surfaceQuery, sphereQuery } = get(terrainQueryTask);
     const rootSizeValue = get(rootSize);
     const originValue = get(origin);
     const elevationScaleValue = get(elevationScale);
+    const projection = get(topologyTask).projection;
     return work((prev) => {
       let raycast = prev;
       let state = raycast?.[RAYCAST_STATE];
       if (!state) {
         state = {
+          projection,
           terrainQuery: null,
-          bounds: {
+          surfaceQuery: null,
+          sphereQuery: null,
+          config: {
             rootSize: 0,
             originX: 0,
+            originY: 0,
             originZ: 0,
             minY: 0,
-            maxY: 0
+            maxY: 0,
+            centerX: 0,
+            centerY: 0,
+            centerZ: 0
           }
         };
       }
+      state.projection = projection;
       state.terrainQuery = terrainQuery;
-      state.bounds.rootSize = rootSizeValue;
-      state.bounds.originX = originValue.x;
-      state.bounds.originZ = originValue.z;
+      state.surfaceQuery = surfaceQuery;
+      state.sphereQuery = sphereQuery;
+      state.config.rootSize = rootSizeValue;
+      state.config.originX = originValue.x;
+      state.config.originY = originValue.y;
+      state.config.originZ = originValue.z;
+      state.config.centerX = projection.center?.x ?? originValue.x;
+      state.config.centerY = projection.center?.y ?? originValue.y;
+      state.config.centerZ = projection.center?.z ?? originValue.z;
       const range = terrainQuery.getGlobalElevationRange();
       if (range) {
-        state.bounds.minY = range.min - BOUNDS_PADDING;
-        state.bounds.maxY = range.max + BOUNDS_PADDING;
+        state.config.minY = range.min - BOUNDS_PADDING;
+        state.config.maxY = range.max + BOUNDS_PADDING;
       } else {
         const verticalExtent = Math.max(1, Math.abs(elevationScaleValue) * 2);
-        state.bounds.minY = originValue.y - verticalExtent;
-        state.bounds.maxY = originValue.y + verticalExtent;
+        state.config.minY = originValue.y - verticalExtent;
+        state.config.maxY = originValue.y + verticalExtent;
       }
       if (!raycast) {
         raycast = createTerrainRaycast({
+          getProjection: () => state.projection,
           getTerrainQuery: () => state.terrainQuery,
-          getConfig: () => state.bounds
+          getSurfaceQuery: () => state.surfaceQuery,
+          getSphereQuery: () => state.sphereQuery,
+          getConfig: () => state.config
         });
       }
       raycast[RAYCAST_STATE] = state;
@@ -2756,15 +4307,12 @@ const terrainRaycastTask = work.task(
   }
 ).displayName("terrainRaycastTask");
 
-function terrainGraph() {
-  return work.graph().add(instanceIdTask).add(quadtreeConfigTask).add(quadtreeUpdateTask).add(leafStorageTask).add(surfaceTask).add(leafGpuBufferTask).add(gpuSpatialIndexStorageTask).add(gpuSpatialIndexUploadTask).add(createUniformsTask).add(updateUniformsTask).add(positionNodeTask).add(createElevationFieldContextTask).add(tileNodesTask).add(createTerrainFieldTextureTask).add(createTerrainSamplerTask).add(elevationFieldStageTask).add(terrainFieldStageTask).add(compileComputeTask).add(executeComputeTask).add(tileBoundsContextTask).add(tileBoundsReductionTask).add(terrainQueryTask).add(terrainReadbackTask).add(terrainRaycastTask);
-}
 const terrainTasks = {
   instanceId: instanceIdTask,
   quadtreeConfig: quadtreeConfigTask,
   quadtreeUpdate: quadtreeUpdateTask,
   leafStorage: leafStorageTask,
-  surface: surfaceTask,
+  topology: topologyTask,
   leafGpuBuffer: leafGpuBufferTask,
   gpuSpatialIndexStorage: gpuSpatialIndexStorageTask,
   gpuSpatialIndexUpload: gpuSpatialIndexUploadTask,
@@ -2785,6 +4333,13 @@ const terrainTasks = {
   terrainReadback: terrainReadbackTask,
   terrainRaycast: terrainRaycastTask
 };
+function terrainGraph() {
+  const g = work.graph();
+  for (const t of Object.values(terrainTasks)) {
+    g.add(t);
+  }
+  return g;
+}
 
 const textureSpaceToVectorSpace = tsl.Fn(([value]) => {
   return tsl.remap(value, tsl.float(0), tsl.float(1), tsl.float(-1), tsl.float(1));
@@ -2840,23 +4395,27 @@ const voronoiCells = tsl.Fn((params) => {
 
 exports.ArrayTextureBackend = ArrayTextureBackend;
 exports.AtlasBackend = AtlasBackend;
+exports.CUBE_FACES = CUBE_FACES;
+exports.CUBE_FACE_COUNT = CUBE_FACE_COUNT;
 exports.Dir = Dir;
 exports.TerrainGeometry = TerrainGeometry;
 exports.TerrainMesh = TerrainMesh;
-exports.Texture3DBackend = Texture3DBackend;
 exports.U32_EMPTY = U32_EMPTY;
 exports.allocLeafSet = allocLeafSet;
 exports.allocSeamTable = allocSeamTable;
+exports.augmentCubeSphereSampler = augmentCubeSphereSampler;
 exports.beginUpdate = beginUpdate;
 exports.blendAngleCorrectedNormals = blendAngleCorrectedNormals;
 exports.buildLeafIndex = buildLeafIndex;
 exports.buildSeams2to1 = buildSeams2to1;
 exports.compileComputeTask = compileComputeTask;
 exports.createComputePipelineTasks = createComputePipelineTasks;
-exports.createCubeSphereSurface = createCubeSphereSurface;
+exports.createCubeSphereProjection = createCubeSphereProjection;
+exports.createCubeSphereTopology = createCubeSphereTopology;
 exports.createElevationFieldContextTask = createElevationFieldContextTask;
-exports.createFlatSurface = createFlatSurface;
-exports.createInfiniteFlatSurface = createInfiniteFlatSurface;
+exports.createFlatProjection = createFlatProjection;
+exports.createFlatTopology = createFlatTopology;
+exports.createInfiniteFlatTopology = createInfiniteFlatTopology;
 exports.createSpatialIndex = createSpatialIndex;
 exports.createState = createState;
 exports.createTerrainFieldStorage = createTerrainFieldStorage;
@@ -2865,13 +4424,25 @@ exports.createTerrainQuery = createTerrainQuery;
 exports.createTerrainRaycast = createTerrainRaycast;
 exports.createTerrainSampler = createTerrainSampler;
 exports.createTerrainSamplerTask = createTerrainSamplerTask;
+exports.createTerrainSurfaceQuery = createTerrainSurfaceQuery;
 exports.createTerrainUniforms = createTerrainUniforms;
+exports.createTorusProjection = createTorusProjection;
+exports.createTorusTopology = createTorusTopology;
 exports.createUniformsTask = createUniformsTask;
+exports.cubeFaceBasis = cubeFaceBasis;
+exports.cubeFaceDirection = cubeFaceDirection;
+exports.cubeFaceFromDirection = cubeFaceFromDirection;
+exports.cubeFacePoint = cubeFacePoint;
+exports.cubeFaceUVFromDirection = cubeFaceUVFromDirection;
 exports.deriveNormalZ = deriveNormalZ;
+exports.directionToFace = directionToFace;
+exports.directionToFaceUV = directionToFaceUV;
+exports.directionToLatLong = directionToLatLong;
 exports.elevationFieldStageTask = elevationFieldStageTask;
 exports.elevationFn = elevationFn;
 exports.elevationScale = elevationScale;
 exports.executeComputeTask = executeComputeTask;
+exports.faceUVToCube = faceUVToCube;
 exports.getDeviceComputeLimits = getDeviceComputeLimits;
 exports.gpuSpatialIndexStorageTask = gpuSpatialIndexStorageTask;
 exports.gpuSpatialIndexUploadTask = gpuSpatialIndexUploadTask;
@@ -2879,6 +4450,7 @@ exports.innerTileSegments = innerTileSegments;
 exports.instanceIdTask = instanceIdTask;
 exports.isSkirtUV = isSkirtUV;
 exports.isSkirtVertex = isSkirtVertex;
+exports.latLongToDirection = latLongToDirection;
 exports.leafGpuBufferTask = leafGpuBufferTask;
 exports.leafStorageTask = leafStorageTask;
 exports.loadTerrainField = loadTerrainField;
@@ -2889,19 +4461,20 @@ exports.maxNodes = maxNodes;
 exports.origin = origin;
 exports.packTerrainFieldSample = packTerrainFieldSample;
 exports.positionNodeTask = positionNodeTask;
+exports.positionToTorusParams = positionToTorusParams;
 exports.quadtreeConfigTask = quadtreeConfigTask;
 exports.quadtreeUpdate = quadtreeUpdate;
 exports.quadtreeUpdateTask = quadtreeUpdateTask;
+exports.radius = radius;
 exports.resetLeafSet = resetLeafSet;
 exports.resetSeamTable = resetSeamTable;
 exports.rootSize = rootSize;
 exports.sampleTerrainField = sampleTerrainField;
 exports.sampleTerrainFieldElevation = sampleTerrainFieldElevation;
-exports.sampleTerrainFieldNormal = sampleTerrainFieldNormal;
 exports.skirtScale = skirtScale;
+exports.sphereTangentFrameNormal = sphereTangentFrameNormal;
 exports.storeTerrainField = storeTerrainField;
-exports.surface = surface;
-exports.surfaceTask = surfaceTask;
+exports.tangentFromAxis = tangentFromAxis;
 exports.terrainFieldFilter = terrainFieldFilter;
 exports.terrainFieldStageTask = terrainFieldStageTask;
 exports.terrainGraph = terrainGraph;
@@ -2911,9 +4484,15 @@ exports.terrainReadbackTask = terrainReadbackTask;
 exports.terrainTasks = terrainTasks;
 exports.textureSpaceToVectorSpace = textureSpaceToVectorSpace;
 exports.tileNodesTask = tileNodesTask;
+exports.topology = topology;
+exports.topologyTask = topologyTask;
+exports.torusOutwardNormal = torusOutwardNormal$1;
+exports.torusUVToPoint = torusUVToPoint;
+exports.unpackTangentNormal = unpackTangentNormal;
 exports.update = update;
 exports.updateUniformsTask = updateUniformsTask;
 exports.vElevation = vElevation;
 exports.vGlobalVertexIndex = vGlobalVertexIndex;
 exports.vectorSpaceToTextureSpace = vectorSpaceToTextureSpace;
 exports.voronoiCells = voronoiCells;
+exports.wrap01 = wrap01;