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

package/dist/index.cjs

@@ -937,20 +937,15 @@ function beginUpdate(state, topology, params) {
 
 function shouldSplit(bounds, level, maxLevel, params) {
   if (level >= maxLevel) return false;
-  const mode = params.mode ?? "distance";
   const cx = bounds.cx;
   const cy = bounds.cy;
   const cz = bounds.cz;
   const distSq = cx * cx + cy * cy + cz * cz;
   const safeDistSq = distSq > 1e-12 ? distSq : 1e-12;
-  if (mode === "screen") {
-    const proj = params.projectionFactor ?? 0;
-    const target = params.targetPixels ?? 0;
-    if (proj <= 0 || target <= 0) {
-      const f2 = params.distanceFactor ?? 2;
-      const threshold2 = bounds.r * f2;
-      return safeDistSq < threshold2 * threshold2;
-    }
+  if (params.mode === "screen") {
+    const proj = params.projectionFactor;
+    const target = params.targetPixels;
+    if (proj <= 0 || target <= 0) return false;
     const left = bounds.r * bounds.r * proj * proj;
     const right = safeDistSq * target * target;
     return left > right;
@@ -984,7 +979,7 @@ function refineLeaves(state, topology, params, outLeaves) {
     let elevationRange;
     if (params.tileElevationRange) {
       const range = state.scratchElevationRange;
-      if (params.tileElevationRange(space, level, x, y, range)) {
+      if (params.tileElevationRange(tile, range)) {
         elevationRange = range;
       }
     }
@@ -1087,19 +1082,9 @@ function balance2to1(state, topology, params, leaves) {
 }
 
 function update(state, topology, params, outLeaves) {
-  const cam = params.cameraOrigin;
-  const elevation = params.elevationAtCameraXZ ?? 0;
-  const origX = cam.x;
-  const origY = cam.y;
-  const origZ = cam.z;
-  topology.projection.cpu.cameraSurfaceOffset(cam, elevation);
   beginUpdate(state, topology, params);
   const leaves = refineLeaves(state, topology, params, outLeaves);
-  const result = balance2to1(state, topology, params, leaves);
-  cam.x = origX;
-  cam.y = origY;
-  cam.z = origZ;
-  return result;
+  return balance2to1(state, topology, params, leaves);
 }
 
 const scratchTile = { space: 0, level: 0, x: 0, y: 0 };
@@ -1500,26 +1485,6 @@ function cpuRaycast(query, ray, config, options) {
     distance: ray.origin.distanceTo(point)
   };
 }
-function cpuRaycastBoundsOnly(ray, config, options) {
-  const bounds = getTerrainBounds(config);
-  const planeY = (config.minY + config.maxY) * 0.5;
-  const dirY = ray.direction.y;
-  if (Math.abs(dirY) < 1e-8) return null;
-  const t = (planeY - ray.origin.y) / dirY;
-  if (t < 0) return null;
-  const maxDistance = options?.maxDistance ?? Number.POSITIVE_INFINITY;
-  if (t > maxDistance) return null;
-  const point = new three.Vector3();
-  ray.at(t, point);
-  if (point.x < bounds.minX || point.x > bounds.maxX || point.z < bounds.minZ || point.z > bounds.maxZ) {
-    return null;
-  }
-  return {
-    position: point,
-    normal: new three.Vector3(0, 1, 0),
-    distance: ray.origin.distanceTo(point)
-  };
-}
 function intersectRaySphere(ray, cx, cy, cz, radius) {
   const ox = ray.origin.x - cx;
   const oy = ray.origin.y - cy;
@@ -1585,22 +1550,6 @@ function cubeSphereRaycast(query, ray, params, options) {
     distance: ray.origin.distanceTo(sample.position)
   };
 }
-function cubeSphereRaycastBoundsOnly(ray, params, options) {
-  const shell = intersectRaySphere(ray, params.centerX, params.centerY, params.centerZ, params.radius);
-  if (!shell) return null;
-  const maxDistance = options?.maxDistance ?? Number.POSITIVE_INFINITY;
-  const t = shell.t0 >= 0 ? shell.t0 : shell.t1;
-  if (t < 0 || t > maxDistance) return null;
-  const point = new three.Vector3();
-  ray.at(t, point);
-  const normal = new three.Vector3(
-    point.x - params.centerX,
-    point.y - params.centerY,
-    point.z - params.centerZ
-  ).normalize();
-  if (params.invert) normal.negate();
-  return { position: point, normal, distance: ray.origin.distanceTo(point) };
-}
 function torusSignedDistance(query, params, px, py, pz, scratchPoint, scratchParams) {
   positionToTorusParams(
     px,
@@ -1655,28 +1604,6 @@ function torusRaycast(query, ray, params, options) {
     distance: ray.origin.distanceTo(sample.position)
   };
 }
-function torusRaycastBoundsOnly(ray, params, options) {
-  const shell = intersectRaySphere(
-    ray,
-    params.centerX,
-    params.centerY,
-    params.centerZ,
-    params.outerRadius
-  );
-  if (!shell) return null;
-  const maxDistance = options?.maxDistance ?? Number.POSITIVE_INFINITY;
-  const t = shell.t0 >= 0 ? shell.t0 : shell.t1;
-  if (t < 0 || t > maxDistance) return null;
-  const point = new three.Vector3();
-  ray.at(t, point);
-  const normal = new three.Vector3(
-    point.x - params.centerX,
-    point.y - params.centerY,
-    point.z - params.centerZ
-  ).normalize();
-  if (params.invert) normal.negate();
-  return { position: point, normal, distance: ray.origin.distanceTo(point) };
-}
 
 function createTerrainQuery(cache) {
   return {
@@ -1802,9 +1729,6 @@ function createFlatProjection() {
       }
     },
     cpu: {
-      cameraSurfaceOffset(cam, elevation) {
-        cam.y -= elevation;
-      },
       createSurfaceOps() {
         return null;
       },
@@ -1813,26 +1737,44 @@ function createFlatProjection() {
       },
       raycast(ctx) {
         const { ray, options, terrainQuery, config } = ctx;
-        if (terrainQuery) {
-          const precise = cpuRaycast(terrainQuery, ray, config, options);
-          if (precise) return precise;
-        }
-        const coarse = cpuRaycastBoundsOnly(ray, config, options);
-        if (coarse && terrainQuery) {
-          const sample = terrainQuery.sampleTerrain(coarse.position.x, coarse.position.z);
-          if (sample.valid) {
-            coarse.position.y = sample.elevation;
-            coarse.normal.copy(sample.normal);
-          }
-        }
-        return coarse;
+        if (!terrainQuery) return null;
+        return cpuRaycast(terrainQuery, ray, config, options);
       }
     }
   };
 }
 
+function boundingSphereFromPoints(px, py, pz, count, cameraOrigin, out) {
+  let sumX = 0;
+  let sumY = 0;
+  let sumZ = 0;
+  for (let i = 0; i < count; i++) {
+    sumX += px[i];
+    sumY += py[i];
+    sumZ += pz[i];
+  }
+  const cX = sumX / count;
+  const cY = sumY / count;
+  const cZ = sumZ / count;
+  let maxDistSq = 0;
+  for (let i = 0; i < count; i++) {
+    const dx = px[i] - cX;
+    const dy = py[i] - cY;
+    const dz = pz[i] - cZ;
+    const dSq = dx * dx + dy * dy + dz * dz;
+    if (dSq > maxDistSq) maxDistSq = dSq;
+  }
+  out.cx = cX - cameraOrigin.x;
+  out.cy = cY - cameraOrigin.y;
+  out.cz = cZ - cameraOrigin.z;
+  out.r = Math.sqrt(maxDistSq);
+}
+
 function createFlatTopology(cfg) {
   const halfRoot = 0.5 * cfg.rootSize;
+  const px = new Float64Array(8);
+  const py = new Float64Array(8);
+  const pz = new Float64Array(8);
   const topology = {
     spaceCount: 1,
     maxRootCount: 1,
@@ -1872,15 +1814,26 @@ function createFlatTopology(cfg) {
       const size = cfg.rootSize * scale;
       const minX = cfg.origin.x + (tile.x * size - halfRoot);
       const minZ = cfg.origin.z + (tile.y * size - halfRoot);
-      const centerX = minX + 0.5 * size;
-      const centerZ = minZ + 0.5 * size;
-      const centerY = cfg.origin.y + (elevationRange ? (elevationRange.min + elevationRange.max) * 0.5 : 0);
-      out.cx = centerX - cameraOrigin.x;
-      out.cy = centerY - cameraOrigin.y;
-      out.cz = centerZ - cameraOrigin.z;
-      const halfDiag = 0.7071067811865476 * size;
-      const vertExtent = elevationRange ? Math.max(Math.abs(elevationRange.min), Math.abs(elevationRange.max)) : 0;
-      out.r = halfDiag + vertExtent;
+      const maxX = minX + size;
+      const maxZ = minZ + size;
+      const yLo = cfg.origin.y + (elevationRange ? elevationRange.min : 0);
+      const yHi = elevationRange ? cfg.origin.y + elevationRange.max : 0;
+      let pointCount = 0;
+      for (let i = 0; i < 4; i++) {
+        const cornerX = (i & 1) === 0 ? minX : maxX;
+        const cornerZ = i < 2 ? minZ : maxZ;
+        px[pointCount] = cornerX;
+        py[pointCount] = yLo;
+        pz[pointCount] = cornerZ;
+        pointCount += 1;
+        if (elevationRange) {
+          px[pointCount] = cornerX;
+          py[pointCount] = yHi;
+          pz[pointCount] = cornerZ;
+          pointCount += 1;
+        }
+      }
+      boundingSphereFromPoints(px, py, pz, pointCount, cameraOrigin, out);
     },
     rootTiles(_cameraOrigin, out) {
       const root = out[0];
@@ -1898,6 +1851,9 @@ function createInfiniteFlatTopology(cfg) {
   const halfRoot = 0.5 * cfg.rootSize;
   const rootGridRadius = Math.max(0, Math.floor(cfg.rootGridRadius ?? 1));
   const rootWidth = rootGridRadius * 2 + 1;
+  const px = new Float64Array(8);
+  const py = new Float64Array(8);
+  const pz = new Float64Array(8);
   return {
     spaceCount: 1,
     maxRootCount: rootWidth * rootWidth,
@@ -1931,15 +1887,26 @@ function createInfiniteFlatTopology(cfg) {
       const size = cfg.rootSize * scale;
       const minX = cfg.origin.x + (tile.x * size - halfRoot);
       const minZ = cfg.origin.z + (tile.y * size - halfRoot);
-      const centerX = minX + 0.5 * size;
-      const centerZ = minZ + 0.5 * size;
-      const centerY = cfg.origin.y + (elevationRange ? (elevationRange.min + elevationRange.max) * 0.5 : 0);
-      out.cx = centerX - cameraOrigin.x;
-      out.cy = centerY - cameraOrigin.y;
-      out.cz = centerZ - cameraOrigin.z;
-      const halfDiag = 0.7071067811865476 * size;
-      const vertExtent = elevationRange ? Math.max(Math.abs(elevationRange.min), Math.abs(elevationRange.max)) : 0;
-      out.r = halfDiag + vertExtent;
+      const maxX = minX + size;
+      const maxZ = minZ + size;
+      const yLo = cfg.origin.y + (elevationRange ? elevationRange.min : 0);
+      const yHi = elevationRange ? cfg.origin.y + elevationRange.max : 0;
+      let pointCount = 0;
+      for (let i = 0; i < 4; i++) {
+        const cornerX = (i & 1) === 0 ? minX : maxX;
+        const cornerZ = i < 2 ? minZ : maxZ;
+        px[pointCount] = cornerX;
+        py[pointCount] = yLo;
+        pz[pointCount] = cornerZ;
+        pointCount += 1;
+        if (elevationRange) {
+          px[pointCount] = cornerX;
+          py[pointCount] = yHi;
+          pz[pointCount] = cornerZ;
+          pointCount += 1;
+        }
+      }
+      boundingSphereFromPoints(px, py, pz, pointCount, cameraOrigin, out);
     },
     rootTiles(cameraOrigin, out) {
       const camRootX = Math.floor((cameraOrigin.x - cfg.origin.x + halfRoot) / cfg.rootSize);
@@ -2475,7 +2442,6 @@ function createCubeSphereProjection(config) {
       const nx = dx / len;
       const ny = dy / len;
       const nz = dz / len;
-      const dirSign = invert ? -1 : 1;
       dirScratch[0] = nx;
       dirScratch[1] = ny;
       dirScratch[2] = nz;
@@ -2484,9 +2450,9 @@ function createCubeSphereProjection(config) {
       out.space = face;
       out.u = uvScratch[0];
       out.v = uvScratch[1];
-      out.dirX = nx * dirSign;
-      out.dirY = ny * dirSign;
-      out.dirZ = nz * dirSign;
+      out.dirX = nx;
+      out.dirY = ny;
+      out.dirZ = nz;
       return true;
     },
     surfacePosition(key, elevation, outVec) {
@@ -2519,7 +2485,8 @@ function createCubeSphereProjection(config) {
       let nx = tuy * tvz - tuz * tvy;
       let ny = tuz * tvx - tux * tvz;
       let nz = tux * tvy - tuy * tvx;
-      if (nx * key.dirX + ny * key.dirY + nz * key.dirZ < 0) {
+      const outwardSign = invert ? -1 : 1;
+      if ((nx * key.dirX + ny * key.dirY + nz * key.dirZ) * outwardSign < 0) {
         nx = -nx;
         ny = -ny;
         nz = -nz;
@@ -2573,19 +2540,6 @@ function createCubeSphereProjection(config) {
       augmentSampler: augmentCubeSphereSampler
     },
     cpu: {
-      cameraSurfaceOffset(cam, elevation) {
-        const dx = cam.x - center.x;
-        const dy = cam.y - center.y;
-        const dz = cam.z - center.z;
-        const len = Math.hypot(dx, dy, dz);
-        if (len > 1e-12) {
-          const sign = invert ? 1 : -1;
-          const inv = sign * elevation / len;
-          cam.x += dx * inv;
-          cam.y += dy * inv;
-          cam.z += dz * inv;
-        }
-      },
       createSurfaceOps() {
         return surfaceOps;
       },
@@ -2596,6 +2550,7 @@ function createCubeSphereProjection(config) {
         return { query, surfaceQuery, sphereQuery };
       },
       raycast(ctx) {
+        if (!ctx.sphereQuery) return null;
         const range = ctx.terrainQuery?.getGlobalElevationRange();
         const dispMax = range ? Math.max(0, range.max - center.y) : radius * 0.1;
         const outerPadding = invert ? 0 : dispMax + RAYCAST_PADDING$1;
@@ -2607,11 +2562,7 @@ function createCubeSphereProjection(config) {
           maxRadius: radius + outerPadding,
           invert
         };
-        if (ctx.sphereQuery) {
-          const precise = cubeSphereRaycast(ctx.sphereQuery, ctx.ray, params, ctx.options);
-          if (precise) return precise;
-        }
-        return cubeSphereRaycastBoundsOnly(ctx.ray, params, ctx.options);
+        return cubeSphereRaycast(ctx.sphereQuery, ctx.ray, params, ctx.options);
       }
     }
   };
@@ -2702,8 +2653,6 @@ function createCubeSphereTopology(cfg) {
     spaceCount: 6,
     maxRootCount: 6,
     projection: createCubeSphereProjection({ radius, center, invert: cfg.invert }),
-    radius,
-    center,
     neighborSameLevel(tile, dir, out) {
       const level = tile.level;
       const n = 1 << level;
@@ -2740,48 +2689,29 @@ function createCubeSphereTopology(cfg) {
       const u1 = (tile.x + 1) / n;
       const v0 = tile.y / n;
       const v1 = (tile.y + 1) / n;
-      const cornersU = [u0, u1, u0, u1];
-      const cornersV = [v0, v0, v1, v1];
-      const disps = elevationRange ? [elevationRange.min, elevationRange.max] : [0];
+      const shellLo = radius + (elevationRange ? elevationRange.min : 0);
+      const shellHi = elevationRange ? radius + elevationRange.max : 0;
       let pointCount = 0;
-      let sumX = 0;
-      let sumY = 0;
-      let sumZ = 0;
       for (let i = 0; i < 4; i++) {
-        faceUVToCube(tile.space, cornersU[i], cornersV[i], cube);
+        const u = (i & 1) === 0 ? u0 : u1;
+        const v = i < 2 ? v0 : v1;
+        faceUVToCube(tile.space, u, v, cube);
         const len = Math.hypot(cube[0], cube[1], cube[2]);
         const dirX = cube[0] / len;
         const dirY = cube[1] / len;
         const dirZ = cube[2] / len;
-        for (let di = 0; di < disps.length; di++) {
-          const shellRadius = radius + disps[di];
-          const sx = center.x + dirX * shellRadius;
-          const sy = center.y + dirY * shellRadius;
-          const sz = center.z + dirZ * shellRadius;
-          px[pointCount] = sx;
-          py[pointCount] = sy;
-          pz[pointCount] = sz;
-          sumX += sx;
-          sumY += sy;
-          sumZ += sz;
+        px[pointCount] = center.x + dirX * shellLo;
+        py[pointCount] = center.y + dirY * shellLo;
+        pz[pointCount] = center.z + dirZ * shellLo;
+        pointCount += 1;
+        if (elevationRange) {
+          px[pointCount] = center.x + dirX * shellHi;
+          py[pointCount] = center.y + dirY * shellHi;
+          pz[pointCount] = center.z + dirZ * shellHi;
           pointCount += 1;
         }
       }
-      const cX = sumX / pointCount;
-      const cY = sumY / pointCount;
-      const cZ = sumZ / pointCount;
-      let maxDistSq = 0;
-      for (let i = 0; i < pointCount; i++) {
-        const dx = px[i] - cX;
-        const dy = py[i] - cY;
-        const dz = pz[i] - cZ;
-        const dSq = dx * dx + dy * dy + dz * dz;
-        if (dSq > maxDistSq) maxDistSq = dSq;
-      }
-      out.cx = cX - cameraOrigin.x;
-      out.cy = cY - cameraOrigin.y;
-      out.cz = cZ - cameraOrigin.z;
-      out.r = Math.sqrt(maxDistSq);
+      boundingSphereFromPoints(px, py, pz, pointCount, cameraOrigin, out);
     },
     rootTiles(_cameraOrigin, out) {
       for (let s = 0; s < 6; s++) {
@@ -2952,13 +2882,6 @@ function createTorusProjection(config) {
       }
     },
     cpu: {
-      cameraSurfaceOffset(cam, elevation) {
-        positionToTorusParams(cam.x, cam.y, cam.z, majorRadius, center, params);
-        torusOutwardNormal$1(params.u, params.v, normalScratch, invert);
-        cam.x -= normalScratch[0] * elevation;
-        cam.y -= normalScratch[1] * elevation;
-        cam.z -= normalScratch[2] * elevation;
-      },
       createSurfaceOps() {
         return surfaceOps;
       },
@@ -2968,6 +2891,7 @@ function createTorusProjection(config) {
         return { query, surfaceQuery, sphereQuery: null };
       },
       raycast(ctx) {
+        if (!ctx.surfaceQuery) return null;
         const range = ctx.terrainQuery?.getGlobalElevationRange();
         const dispMax = range ? Math.max(0, range.max - ctx.config.originY) : minorRadius * 0.5;
         const outerPadding = invert ? 0 : dispMax + RAYCAST_PADDING;
@@ -2980,11 +2904,7 @@ function createTorusProjection(config) {
           outerRadius: majorRadius + minorRadius + outerPadding,
           invert
         };
-        if (ctx.surfaceQuery) {
-          const precise = torusRaycast(ctx.surfaceQuery, ctx.ray, raycastParams, ctx.options);
-          if (precise) return precise;
-        }
-        return torusRaycastBoundsOnly(ctx.ray, raycastParams, ctx.options);
+        return torusRaycast(ctx.surfaceQuery, ctx.ray, raycastParams, ctx.options);
       }
     }
   };
@@ -3017,8 +2937,6 @@ function createTorusTopology(cfg) {
       baseU,
       baseV
     }),
-    radius: majorRadius + minorRadius,
-    center,
     neighborSameLevel(tile, dir, out) {
       const { nU, nV } = levelResolution(tile.level);
       let nx = tile.x;
@@ -3049,42 +2967,28 @@ function createTorusTopology(cfg) {
       const v0 = tile.y / nV;
       const stepU = 1 / nU;
       const stepV = 1 / nV;
-      const disps = elevationRange ? [elevationRange.min, elevationRange.max] : [0];
+      const dispLo = elevationRange ? elevationRange.min : 0;
+      const dispHi = elevationRange ? elevationRange.max : 0;
       let pointCount = 0;
-      let sumX = 0;
-      let sumY = 0;
-      let sumZ = 0;
       for (let sj = 0; sj <= 2; sj++) {
         for (let si = 0; si <= 2; si++) {
           const u = u0 + si * stepU / 2;
           const v = v0 + sj * stepV / 2;
-          for (let di = 0; di < disps.length; di++) {
-            torusUVToPoint(u, v, majorRadius, minorRadius, disps[di], center, corner, invert);
+          torusUVToPoint(u, v, majorRadius, minorRadius, dispLo, center, corner, invert);
+          px[pointCount] = corner[0];
+          py[pointCount] = corner[1];
+          pz[pointCount] = corner[2];
+          pointCount += 1;
+          if (elevationRange) {
+            torusUVToPoint(u, v, majorRadius, minorRadius, dispHi, center, corner, invert);
             px[pointCount] = corner[0];
             py[pointCount] = corner[1];
             pz[pointCount] = corner[2];
-            sumX += corner[0];
-            sumY += corner[1];
-            sumZ += corner[2];
             pointCount += 1;
           }
         }
       }
-      const cX = sumX / pointCount;
-      const cY = sumY / pointCount;
-      const cZ = sumZ / pointCount;
-      let maxDistSq = 0;
-      for (let i = 0; i < pointCount; i++) {
-        const dx = px[i] - cX;
-        const dy = py[i] - cY;
-        const dz = pz[i] - cZ;
-        const dSq = dx * dx + dy * dy + dz * dz;
-        if (dSq > maxDistSq) maxDistSq = dSq;
-      }
-      out.cx = cX - cameraOrigin.x;
-      out.cy = cY - cameraOrigin.y;
-      out.cz = cZ - cameraOrigin.z;
-      out.r = Math.sqrt(maxDistSq);
+      boundingSphereFromPoints(px, py, pz, pointCount, cameraOrigin, out);
     },
     rootTiles(_cameraOrigin, out) {
       let count = 0;
@@ -3648,6 +3552,9 @@ function createCpuTerrainCache(maxNodes, initialConfig, surfaceOps) {
     get hasSurface() {
       return surfaceOps !== null;
     },
+    setSurfaceOps(nextSurfaceOps) {
+      surfaceOps = nextSurfaceOps;
+    },
     updateConfig(nextConfig) {
       config = nextConfig;
       shape.edgeVertexCount = config.innerTileSegments + 3;
@@ -3799,7 +3706,7 @@ function createCpuTerrainCache(maxNodes, initialConfig, surfaceOps) {
 }
 
 const WGSIZE = 64;
-function buildReductionKernel(elevationFieldNode, boundsNode, verticesPerNode) {
+function buildReductionKernel(elevationFieldNode, boundsNode, verticesPerNode, edgeVertexCount) {
   const elemsPerThread = Math.ceil(verticesPerNode / WGSIZE);
   return tsl.Fn(() => {
     const sharedMin = tsl.workgroupArray("float", WGSIZE);
@@ -3811,10 +3718,17 @@ function buildReductionKernel(elevationFieldNode, boundsNode, verticesPerNode) {
     const end = tsl.min(start.add(tsl.int(elemsPerThread)), tsl.int(verticesPerNode));
     const localMin = tsl.float(1e10).toVar("localMin");
     const localMax = tsl.float(-1e10).toVar("localMax");
+    const edge = tsl.int(edgeVertexCount);
+    const lastEdge = tsl.int(edgeVertexCount - 1);
     tsl.Loop({ start, end, type: "int", condition: "<" }, ({ i }) => {
-      const h = elevationFieldNode.element(baseOffset.add(i));
-      localMin.assign(tsl.min(localMin, h));
-      localMax.assign(tsl.max(localMax, h));
+      const ix = tsl.int(i).mod(edge);
+      const iy = tsl.int(i).div(edge);
+      const isSkirt = ix.equal(tsl.int(0)).or(ix.equal(lastEdge)).or(iy.equal(tsl.int(0))).or(iy.equal(lastEdge));
+      tsl.If(isSkirt.not(), () => {
+        const h = elevationFieldNode.element(baseOffset.add(i));
+        localMin.assign(tsl.min(localMin, h));
+        localMax.assign(tsl.max(localMax, h));
+      });
     });
     sharedMin.element(tid).assign(localMin);
     sharedMax.element(tid).assign(localMax);
@@ -3844,7 +3758,12 @@ const tileBoundsContextTask = work.task((get, work) => {
       "tileBounds"
     );
     const verticesPerNode = edgeVertexCount * edgeVertexCount;
-    const kernel = buildReductionKernel(elevationFieldContext.node, node, verticesPerNode);
+    const kernel = buildReductionKernel(
+      elevationFieldContext.node,
+      node,
+      verticesPerNode,
+      edgeVertexCount
+    );
     return { data, attribute, node, kernel };
   });
 }).displayName("tileBoundsContextTask");
@@ -3874,6 +3793,7 @@ const terrainQueryTask = work.task((get, work) => {
   const projection = topologyValue.projection;
   return work((prev) => {
     const shapeKey = `${maxNodesValue}:${innerTileSegmentsValue}:${projection.kind}`;
+    const resolvedRadius = projection.radius ?? radiusValue;
     const configValues = {
       rootSize: rootSizeValue,
       originX: originValue.x,
@@ -3882,7 +3802,7 @@ const terrainQueryTask = work.task((get, work) => {
       innerTileSegments: innerTileSegmentsValue,
       elevationScale: elevationScaleValue,
       maxLevel: maxLevelValue,
-      radius: topologyValue.radius ?? radiusValue,
+      radius: resolvedRadius,
       baseU: projection.baseResolution?.u ?? 1,
       baseV: projection.baseResolution?.v ?? 1
     };
@@ -3897,9 +3817,15 @@ const terrainQueryTask = work.task((get, work) => {
       query = runtime.query;
       surfaceQuery = runtime.surfaceQuery;
       sphereQuery = runtime.sphereQuery;
+    } else if (prev?.projection !== projection) {
+      cache.setSurfaceOps(projection.cpu.createSurfaceOps());
+      const runtime = projection.cpu.createRuntimeQueries(cache);
+      query = runtime.query;
+      surfaceQuery = runtime.surfaceQuery;
+      sphereQuery = runtime.sphereQuery;
     }
     cache.updateConfig(configValues);
-    return { cache, query, surfaceQuery, sphereQuery, shapeKey };
+    return { cache, query, surfaceQuery, sphereQuery, shapeKey, projection };
   });
 }).displayName("terrainQueryTask");
 const terrainReadbackTask = work.task(
@@ -3946,27 +3872,19 @@ const quadtreeConfigTask = work.task((get, work) => {
 const quadtreeUpdateTask = work.task((get, work) => {
   const quadtreeConfig = get(quadtreeConfigTask);
   const quadtreeUpdateConfig = get(quadtreeUpdate);
-  const { query: terrainQuery, surfaceQuery, cache } = get(terrainQueryTask);
+  const { cache } = get(terrainQueryTask);
   const elevationScaleValue = get(elevationScale);
   let outLeaves = void 0;
-  const cameraPosition = new three.Vector3();
   const elevationRangeScratch = { min: 0, max: 0 };
-  return work(() => {
-    const cam = quadtreeUpdateConfig.cameraOrigin;
-    if (surfaceQuery) {
-      cameraPosition.set(cam.x, cam.y, cam.z);
-      quadtreeUpdateConfig.elevationAtCameraXZ = surfaceQuery.getElevationByPosition(cameraPosition) ?? 0;
-    } else {
-      quadtreeUpdateConfig.elevationAtCameraXZ = terrainQuery.getElevation(cam.x, cam.z) ?? 0;
+  quadtreeUpdateConfig.tileElevationRange = (tile, out) => {
+    if (!cache.getTileElevationRange(tile.space, tile.level, tile.x, tile.y, elevationRangeScratch)) {
+      return false;
     }
-    quadtreeUpdateConfig.tileElevationRange = (space, level, x, y, out) => {
-      if (!cache.getTileElevationRange(space, level, x, y, elevationRangeScratch)) {
-        return false;
-      }
-      out.min = elevationRangeScratch.min * elevationScaleValue;
-      out.max = elevationRangeScratch.max * elevationScaleValue;
-      return true;
-    };
+    out.min = elevationRangeScratch.min * elevationScaleValue;
+    out.max = elevationRangeScratch.max * elevationScaleValue;
+    return true;
+  };
+  return work(() => {
     outLeaves = update(
       quadtreeConfig.state,
       quadtreeConfig.topology,