@hello-terrain/three 0.0.0-alpha.8 → 0.0.0-alpha.9

package/dist/index.cjs

@@ -647,25 +647,6 @@ const createElevation = (tile, uniforms, elevationFn) => {
     });
   };
 };
-const readElevationFieldAtPositionLocal = (terrainFieldStorage, edgeVertexCount, positionLocal) => tsl.Fn(() => {
-  const nodeIndex = tsl.int(tsl.instanceIndex);
-  const intEdge = tsl.int(edgeVertexCount);
-  const innerSegments = tsl.int(edgeVertexCount).sub(3);
-  const fInnerSegments = tsl.float(innerSegments);
-  const last = intEdge.sub(tsl.int(1));
-  const u = positionLocal.x.add(tsl.float(0.5));
-  const v = positionLocal.z.add(tsl.float(0.5));
-  const x = u.mul(fInnerSegments).round().toInt().add(tsl.int(1));
-  const y = v.mul(fInnerSegments).round().toInt().add(tsl.int(1));
-  const xClamped = tsl.min(tsl.max(x, tsl.int(0)), last);
-  const yClamped = tsl.min(tsl.max(y, tsl.int(0)), last);
-  return loadTerrainFieldElevation(
-    terrainFieldStorage,
-    xClamped,
-    yClamped,
-    nodeIndex
-  );
-});
 
 function createTileCompute(leafStorage, uniforms) {
   const tileLevel = tsl.Fn(([nodeIndex]) => {
@@ -732,6 +713,10 @@ function createTileCompute(leafStorage, uniforms) {
     tileVertexWorldPositionCompute
   };
 }
+function tileLocalToFieldUV(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);
+}
 
 const rootSize = work.param(256).displayName("rootSize");
 const origin = work.param({
@@ -848,12 +833,12 @@ function ensureChildren(store, parentId) {
   return childBase;
 }
 
-function nextPow2(n) {
+function nextPow2$1(n) {
   let x = 1;
   while (x < n) x <<= 1;
   return x;
 }
-function mix32(x) {
+function mix32$1(x) {
   x >>>= 0;
   x ^= x >>> 16;
   x = Math.imul(x, 2146121005) >>> 0;
@@ -862,12 +847,12 @@ function mix32(x) {
   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 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 createSpatialIndex(maxEntries) {
-  const size = nextPow2(Math.max(2, maxEntries * 2));
+  const size = nextPow2$1(Math.max(2, maxEntries * 2));
   return {
     size,
     mask: size - 1,
@@ -892,7 +877,7 @@ function insertSpatialIndexRaw(index, space, level, x, y, value) {
   const l = level & 255;
   const xx = x >>> 0;
   const yy = y >>> 0;
-  let slot = hashKey(s, l, xx, yy) & index.mask;
+  let slot = hashKey$1(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;
@@ -916,7 +901,7 @@ function lookupSpatialIndexRaw(index, space, level, x, y) {
   const l = level & 255;
   const xx = x >>> 0;
   const yy = y >>> 0;
-  let slot = hashKey(s, l, xx, yy) & index.mask;
+  let slot = hashKey$1(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) {
@@ -1677,6 +1662,275 @@ function createComputePipelineTasks(leafStageTask) {
   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(
+      u,
+      params.uniforms.uInnerTileSegments
+    ).toVar();
+    const fieldV = tileLocalToFieldUV(
+      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
+      );
+      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
+  };
+}
+
+const createTerrainSamplerTask = work.task((get, work) => {
+  const terrainFieldStorage = get(createTerrainFieldTextureTask);
+  const spatialIndex = get(gpuSpatialIndexStorageTask);
+  const uniforms = get(createUniformsTask);
+  const elevationCallback = get(elevationFn);
+  return work(
+    () => createTerrainSampler({
+      terrainFieldStorage,
+      spatialIndex,
+      uniforms,
+      elevationCallback
+    })
+  );
+}).displayName("createTerrainSamplerTask");
+
 const isSkirtVertex = tsl.Fn(([segments]) => {
   const segmentsNode = typeof segments === "number" ? tsl.int(segments) : segments;
   const vIndex = tsl.int(tsl.vertexIndex);
@@ -1720,14 +1974,15 @@ function createTileBaseWorldPosition(leafStorage, terrainUniforms) {
 }
 function createTileElevation(terrainUniforms, terrainFieldStorage) {
   if (!terrainFieldStorage) return tsl.float(0);
-  const edgeVertexCount = terrainUniforms.uInnerTileSegments.add(3);
-  return readElevationFieldAtPositionLocal(
+  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,
-    edgeVertexCount,
-    tsl.positionLocal
-  )().mul(
-    terrainUniforms.uElevationScale
-  );
+    u,
+    v,
+    tsl.int(tsl.instanceIndex)
+  ).mul(terrainUniforms.uElevationScale);
 }
 function createNormalAssignment(terrainUniforms, terrainFieldStorage) {
   if (!terrainFieldStorage) return;
@@ -1736,7 +1991,12 @@ function createNormalAssignment(terrainUniforms, terrainFieldStorage) {
   const localVertexIndex = tsl.int(tsl.vertexIndex);
   const ix = localVertexIndex.mod(edgeVertexCount);
   const iy = localVertexIndex.div(edgeVertexCount);
-  const normalXZ = loadTerrainFieldNormal(terrainFieldStorage, ix, iy, nodeIndex);
+  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));
@@ -1744,10 +2004,16 @@ function createNormalAssignment(terrainUniforms, terrainFieldStorage) {
   tsl.normalLocal.assign(tsl.vec3(nx, ny, nz));
 }
 function createTileWorldPosition(leafStorage, terrainUniforms, terrainFieldStorage) {
-  const baseWorldPosition = createTileBaseWorldPosition(leafStorage, terrainUniforms);
+  const baseWorldPosition = createTileBaseWorldPosition(
+    leafStorage,
+    terrainUniforms
+  );
   return tsl.Fn(() => {
     const base = baseWorldPosition();
-    const yElevation = createTileElevation(terrainUniforms, terrainFieldStorage);
+    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));
@@ -1770,7 +2036,7 @@ const positionNodeTask = work.task((get, work) => {
 }).displayName("positionNodeTask");
 
 function terrainGraph() {
-  return work.graph().add(instanceIdTask).add(quadtreeConfigTask).add(quadtreeUpdateTask).add(leafStorageTask).add(surfaceTask).add(leafGpuBufferTask).add(createUniformsTask).add(updateUniformsTask).add(positionNodeTask).add(createElevationFieldContextTask).add(tileNodesTask).add(createTerrainFieldTextureTask).add(elevationFieldStageTask).add(terrainFieldStageTask).add(compileComputeTask).add(executeComputeTask);
+  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);
 }
 const terrainTasks = {
   instanceId: instanceIdTask,
@@ -1779,12 +2045,15 @@ const terrainTasks = {
   leafStorage: leafStorageTask,
   surface: surfaceTask,
   leafGpuBuffer: leafGpuBufferTask,
+  gpuSpatialIndexStorage: gpuSpatialIndexStorageTask,
+  gpuSpatialIndexUpload: gpuSpatialIndexUploadTask,
   createUniforms: createUniformsTask,
   updateUniforms: updateUniformsTask,
   positionNode: positionNodeTask,
   createElevationFieldContext: createElevationFieldContextTask,
   createTileNodes: tileNodesTask,
   createTerrainFieldTexture: createTerrainFieldTextureTask,
+  createTerrainSampler: createTerrainSamplerTask,
   elevationFieldStage: elevationFieldStageTask,
   terrainFieldStage: terrainFieldStageTask,
   compileCompute: compileComputeTask,
@@ -1866,6 +2135,8 @@ exports.createSpatialIndex = createSpatialIndex;
 exports.createState = createState;
 exports.createTerrainFieldStorage = createTerrainFieldStorage;
 exports.createTerrainFieldTextureTask = createTerrainFieldTextureTask;
+exports.createTerrainSampler = createTerrainSampler;
+exports.createTerrainSamplerTask = createTerrainSamplerTask;
 exports.createTerrainUniforms = createTerrainUniforms;
 exports.createUniformsTask = createUniformsTask;
 exports.deriveNormalZ = deriveNormalZ;
@@ -1874,6 +2145,8 @@ exports.elevationFn = elevationFn;
 exports.elevationScale = elevationScale;
 exports.executeComputeTask = executeComputeTask;
 exports.getDeviceComputeLimits = getDeviceComputeLimits;
+exports.gpuSpatialIndexStorageTask = gpuSpatialIndexStorageTask;
+exports.gpuSpatialIndexUploadTask = gpuSpatialIndexUploadTask;
 exports.innerTileSegments = innerTileSegments;
 exports.instanceIdTask = instanceIdTask;
 exports.isSkirtUV = isSkirtUV;

package/dist/index.d.cts

@@ -458,6 +458,41 @@ declare function createTileCompute(leafStorage: LeafStorageState, uniforms: Terr
     tileVertexWorldPositionCompute: three_src_nodes_TSL_js.ShaderNodeFn<[number | Node, number | Node, number | Node]>;
 };
 
+interface ElevationParams {
+    worldPosition: Node$1;
+    rootSize: Node$1;
+    rootUV: Node$1;
+    tileUV: Node$1;
+    tileLevel: Node$1;
+    tileSize: Node$1;
+    tileOriginVec2: Node$1;
+    nodeIndex: Node$1;
+}
+type ElevationCallback = (params: ElevationParams) => Node$1;
+
+interface GpuSpatialIndexContext {
+    data: Uint32Array<ArrayBuffer>;
+    size: number;
+    mask: number;
+    stampGen: UniformNode<number>;
+    attribute: StorageBufferAttribute;
+    node: StorageBufferNode;
+}
+interface TerrainSampler {
+    sampleElevation: (worldX: Node, worldZ: Node) => Node;
+    sampleNormal: (worldX: Node, worldZ: Node) => Node;
+    sampleTerrain: (worldX: Node, worldZ: Node) => Node;
+    sampleValidity: (worldX: Node, worldZ: Node) => Node;
+    evaluateElevation: (worldX: Node, worldZ: Node) => Node;
+    evaluateNormal: (worldX: Node, worldZ: Node, epsilon?: Node) => Node;
+}
+interface CreateTerrainSamplerParams {
+    terrainFieldStorage: TerrainFieldStorage;
+    spatialIndex: GpuSpatialIndexContext;
+    uniforms: TerrainUniformsContext;
+    elevationCallback: ElevationCallback;
+}
+
 interface QuadtreeConfigState {
     state: QuadtreeState;
     surface: Surface;
@@ -478,12 +513,15 @@ interface TerrainTasks {
     surface: TaskRef<Surface>;
     leafStorage: TaskRef<LeafStorageState>;
     leafGpuBuffer: TaskRef<LeafGpuBufferState>;
+    gpuSpatialIndexStorage: TaskRef<GpuSpatialIndexContext>;
+    gpuSpatialIndexUpload: TaskRef<GpuSpatialIndexContext>;
     createUniforms: TaskRef<TerrainUniformsContext>;
     updateUniforms: TaskRef<TerrainUniformsContext>;
     positionNode: TaskRef<ShaderCallNodeInternal>;
     createElevationFieldContext: TaskRef<ElevationFieldContext>;
     createTileNodes: TaskRef<ReturnType<typeof createTileCompute>>;
     createTerrainFieldTexture: TaskRef<TerrainFieldStorage>;
+    createTerrainSampler: TaskRef<TerrainSampler>;
     elevationFieldStage: TaskRef<ComputePipeline>;
     terrainFieldStage: TaskRef<ComputePipeline>;
     compileCompute: TaskRef<{
@@ -513,6 +551,9 @@ declare const tileNodesTask: _hello_terrain_work.Task<{
  */
 declare const elevationFieldStageTask: _hello_terrain_work.Task<ComputePipeline, string, unknown>;
 
+declare const gpuSpatialIndexStorageTask: _hello_terrain_work.Task<GpuSpatialIndexContext, string, unknown>;
+declare const gpuSpatialIndexUploadTask: _hello_terrain_work.Task<GpuSpatialIndexContext, string, unknown>;
+
 /** Generates a unique instance ID per graph (cached once). */
 declare const instanceIdTask: _hello_terrain_work.Task<`${string}-${string}-${string}-${string}-${string}`, string, unknown>;
 
@@ -529,17 +570,7 @@ declare const createTerrainFieldTextureTask: _hello_terrain_work.Task<any, strin
  */
 declare const terrainFieldStageTask: _hello_terrain_work.Task<ComputePipeline, string, unknown>;
 
-interface ElevationParams {
-    worldPosition: Node$1;
-    rootSize: Node$1;
-    rootUV: Node$1;
-    tileUV: Node$1;
-    tileLevel: Node$1;
-    tileSize: Node$1;
-    tileOriginVec2: Node$1;
-    nodeIndex: Node$1;
-}
-type ElevationCallback = (params: ElevationParams) => Node$1;
+declare const createTerrainSamplerTask: _hello_terrain_work.Task<TerrainSampler, string, unknown>;
 
 /** Root tile size in world units. */
 declare const rootSize: _hello_terrain_work.ParamRef<number>;
@@ -644,6 +675,8 @@ declare const terrainTasks: {
         attribute: three_webgpu.StorageBufferAttribute;
         node: three_webgpu.StorageBufferNode;
     }, string, unknown>;
+    readonly gpuSpatialIndexStorage: _hello_terrain_work.Task<GpuSpatialIndexContext, string, unknown>;
+    readonly gpuSpatialIndexUpload: _hello_terrain_work.Task<GpuSpatialIndexContext, string, unknown>;
     readonly createUniforms: _hello_terrain_work.Task<TerrainUniformsContext, string, unknown>;
     readonly updateUniforms: _hello_terrain_work.Task<TerrainUniformsContext, string, unknown>;
     readonly positionNode: _hello_terrain_work.Task<three_src_nodes_TSL_js.ShaderCallNodeInternal, string, unknown>;
@@ -662,6 +695,7 @@ declare const terrainTasks: {
     readonly createTerrainFieldTexture: _hello_terrain_work.Task<any, string, {
         renderer: WebGPURenderer;
     }>;
+    readonly createTerrainSampler: _hello_terrain_work.Task<TerrainSampler, string, unknown>;
     readonly elevationFieldStage: _hello_terrain_work.Task<ComputePipeline, string, unknown>;
     readonly terrainFieldStage: _hello_terrain_work.Task<ComputePipeline, string, unknown>;
     readonly compileCompute: _hello_terrain_work.Task<{
@@ -679,6 +713,8 @@ type ComputeDeviceLimits = {
 };
 declare function getDeviceComputeLimits(renderer: WebGPURenderer): ComputeDeviceLimits;
 
+declare function createTerrainSampler(params: CreateTerrainSamplerParams): TerrainSampler;
+
 /**
  * Maps a value or node from texture space [0, 1] to vector space [-1, 1].
  *
@@ -751,5 +787,5 @@ declare const voronoiCells: three_src_nodes_TSL_js.ShaderNodeFn<[three_tsl.Proxi
     uv: Node;
 }>]>;
 
-export { ArrayTextureBackend, AtlasBackend, Dir, TerrainGeometry, TerrainMesh, Texture3DBackend, U32_EMPTY, allocLeafSet, allocSeamTable, beginUpdate, blendAngleCorrectedNormals, buildLeafIndex, buildSeams2to1, compileComputeTask, createComputePipelineTasks, createCubeSphereSurface, createElevationFieldContextTask, createFlatSurface, createInfiniteFlatSurface, createSpatialIndex, createState, createTerrainFieldStorage, createTerrainFieldTextureTask, createTerrainUniforms, createUniformsTask, deriveNormalZ, elevationFieldStageTask, elevationFn, elevationScale, executeComputeTask, getDeviceComputeLimits, innerTileSegments, instanceIdTask, isSkirtUV, isSkirtVertex, leafGpuBufferTask, leafStorageTask, loadTerrainField, loadTerrainFieldElevation, loadTerrainFieldNormal, maxLevel, maxNodes, origin, packTerrainFieldSample, positionNodeTask, quadtreeConfigTask, quadtreeUpdate, quadtreeUpdateTask, resetLeafSet, resetSeamTable, rootSize, sampleTerrainField, sampleTerrainFieldElevation, sampleTerrainFieldNormal, skirtScale, storeTerrainField, surface, surfaceTask, terrainFieldFilter, terrainFieldStageTask, terrainGraph, terrainTasks, textureSpaceToVectorSpace, tileNodesTask, update, updateUniformsTask, vElevation, vGlobalVertexIndex, vectorSpaceToTextureSpace, voronoiCells };
-export type { ComputePipeline, ComputeStageCallback, CubeSphereSurfaceConfig, ElevationCallback, ElevationFieldContext, ElevationParams, FlatSurfaceConfig, InfiniteFlatSurfaceConfig, IntNodeInput, LeafGpuBufferState, LeafSet, LeafStorageState, LodMode, QuadtreeConfig, QuadtreeConfigState, QuadtreeState, SeamTable, SpatialIndex, Surface, TerrainFieldStorage, TerrainFieldStorageBackendType, TerrainFieldStorageFormat, TerrainFieldStorageOptions, TerrainGraph, TerrainTasks, TerrainUniformsContext, TerrainUniformsParams, TileBounds, TileId, UpdateParams };
+export { ArrayTextureBackend, AtlasBackend, Dir, TerrainGeometry, TerrainMesh, Texture3DBackend, U32_EMPTY, allocLeafSet, allocSeamTable, beginUpdate, blendAngleCorrectedNormals, buildLeafIndex, buildSeams2to1, compileComputeTask, createComputePipelineTasks, createCubeSphereSurface, createElevationFieldContextTask, createFlatSurface, createInfiniteFlatSurface, createSpatialIndex, createState, createTerrainFieldStorage, createTerrainFieldTextureTask, createTerrainSampler, createTerrainSamplerTask, createTerrainUniforms, createUniformsTask, deriveNormalZ, elevationFieldStageTask, elevationFn, elevationScale, executeComputeTask, getDeviceComputeLimits, gpuSpatialIndexStorageTask, gpuSpatialIndexUploadTask, innerTileSegments, instanceIdTask, isSkirtUV, isSkirtVertex, leafGpuBufferTask, leafStorageTask, loadTerrainField, loadTerrainFieldElevation, loadTerrainFieldNormal, maxLevel, maxNodes, origin, packTerrainFieldSample, positionNodeTask, quadtreeConfigTask, quadtreeUpdate, quadtreeUpdateTask, resetLeafSet, resetSeamTable, rootSize, sampleTerrainField, sampleTerrainFieldElevation, sampleTerrainFieldNormal, skirtScale, storeTerrainField, surface, surfaceTask, terrainFieldFilter, terrainFieldStageTask, terrainGraph, terrainTasks, textureSpaceToVectorSpace, tileNodesTask, update, updateUniformsTask, vElevation, vGlobalVertexIndex, vectorSpaceToTextureSpace, voronoiCells };
+export type { ComputePipeline, ComputeStageCallback, CreateTerrainSamplerParams, CubeSphereSurfaceConfig, ElevationCallback, ElevationFieldContext, ElevationParams, FlatSurfaceConfig, GpuSpatialIndexContext, InfiniteFlatSurfaceConfig, IntNodeInput, LeafGpuBufferState, LeafSet, LeafStorageState, LodMode, QuadtreeConfig, QuadtreeConfigState, QuadtreeState, SeamTable, SpatialIndex, Surface, TerrainFieldStorage, TerrainFieldStorageBackendType, TerrainFieldStorageFormat, TerrainFieldStorageOptions, TerrainGraph, TerrainSampler, TerrainTasks, TerrainUniformsContext, TerrainUniformsParams, TileBounds, TileId, UpdateParams };

package/dist/index.d.mts

@@ -458,6 +458,41 @@ declare function createTileCompute(leafStorage: LeafStorageState, uniforms: Terr
     tileVertexWorldPositionCompute: three_src_nodes_TSL_js.ShaderNodeFn<[number | Node, number | Node, number | Node]>;
 };
 
+interface ElevationParams {
+    worldPosition: Node$1;
+    rootSize: Node$1;
+    rootUV: Node$1;
+    tileUV: Node$1;
+    tileLevel: Node$1;
+    tileSize: Node$1;
+    tileOriginVec2: Node$1;
+    nodeIndex: Node$1;
+}
+type ElevationCallback = (params: ElevationParams) => Node$1;
+
+interface GpuSpatialIndexContext {
+    data: Uint32Array<ArrayBuffer>;
+    size: number;
+    mask: number;
+    stampGen: UniformNode<number>;
+    attribute: StorageBufferAttribute;
+    node: StorageBufferNode;
+}
+interface TerrainSampler {
+    sampleElevation: (worldX: Node, worldZ: Node) => Node;
+    sampleNormal: (worldX: Node, worldZ: Node) => Node;
+    sampleTerrain: (worldX: Node, worldZ: Node) => Node;
+    sampleValidity: (worldX: Node, worldZ: Node) => Node;
+    evaluateElevation: (worldX: Node, worldZ: Node) => Node;
+    evaluateNormal: (worldX: Node, worldZ: Node, epsilon?: Node) => Node;
+}
+interface CreateTerrainSamplerParams {
+    terrainFieldStorage: TerrainFieldStorage;
+    spatialIndex: GpuSpatialIndexContext;
+    uniforms: TerrainUniformsContext;
+    elevationCallback: ElevationCallback;
+}
+
 interface QuadtreeConfigState {
     state: QuadtreeState;
     surface: Surface;
@@ -478,12 +513,15 @@ interface TerrainTasks {
     surface: TaskRef<Surface>;
     leafStorage: TaskRef<LeafStorageState>;
     leafGpuBuffer: TaskRef<LeafGpuBufferState>;
+    gpuSpatialIndexStorage: TaskRef<GpuSpatialIndexContext>;
+    gpuSpatialIndexUpload: TaskRef<GpuSpatialIndexContext>;
     createUniforms: TaskRef<TerrainUniformsContext>;
     updateUniforms: TaskRef<TerrainUniformsContext>;
     positionNode: TaskRef<ShaderCallNodeInternal>;
     createElevationFieldContext: TaskRef<ElevationFieldContext>;
     createTileNodes: TaskRef<ReturnType<typeof createTileCompute>>;
     createTerrainFieldTexture: TaskRef<TerrainFieldStorage>;
+    createTerrainSampler: TaskRef<TerrainSampler>;
     elevationFieldStage: TaskRef<ComputePipeline>;
     terrainFieldStage: TaskRef<ComputePipeline>;
     compileCompute: TaskRef<{
@@ -513,6 +551,9 @@ declare const tileNodesTask: _hello_terrain_work.Task<{
  */
 declare const elevationFieldStageTask: _hello_terrain_work.Task<ComputePipeline, string, unknown>;
 
+declare const gpuSpatialIndexStorageTask: _hello_terrain_work.Task<GpuSpatialIndexContext, string, unknown>;
+declare const gpuSpatialIndexUploadTask: _hello_terrain_work.Task<GpuSpatialIndexContext, string, unknown>;
+
 /** Generates a unique instance ID per graph (cached once). */
 declare const instanceIdTask: _hello_terrain_work.Task<`${string}-${string}-${string}-${string}-${string}`, string, unknown>;
 
@@ -529,17 +570,7 @@ declare const createTerrainFieldTextureTask: _hello_terrain_work.Task<any, strin
  */
 declare const terrainFieldStageTask: _hello_terrain_work.Task<ComputePipeline, string, unknown>;
 
-interface ElevationParams {
-    worldPosition: Node$1;
-    rootSize: Node$1;
-    rootUV: Node$1;
-    tileUV: Node$1;
-    tileLevel: Node$1;
-    tileSize: Node$1;
-    tileOriginVec2: Node$1;
-    nodeIndex: Node$1;
-}
-type ElevationCallback = (params: ElevationParams) => Node$1;
+declare const createTerrainSamplerTask: _hello_terrain_work.Task<TerrainSampler, string, unknown>;
 
 /** Root tile size in world units. */
 declare const rootSize: _hello_terrain_work.ParamRef<number>;
@@ -644,6 +675,8 @@ declare const terrainTasks: {
         attribute: three_webgpu.StorageBufferAttribute;
         node: three_webgpu.StorageBufferNode;
     }, string, unknown>;
+    readonly gpuSpatialIndexStorage: _hello_terrain_work.Task<GpuSpatialIndexContext, string, unknown>;
+    readonly gpuSpatialIndexUpload: _hello_terrain_work.Task<GpuSpatialIndexContext, string, unknown>;
     readonly createUniforms: _hello_terrain_work.Task<TerrainUniformsContext, string, unknown>;
     readonly updateUniforms: _hello_terrain_work.Task<TerrainUniformsContext, string, unknown>;
     readonly positionNode: _hello_terrain_work.Task<three_src_nodes_TSL_js.ShaderCallNodeInternal, string, unknown>;
@@ -662,6 +695,7 @@ declare const terrainTasks: {
     readonly createTerrainFieldTexture: _hello_terrain_work.Task<any, string, {
         renderer: WebGPURenderer;
     }>;
+    readonly createTerrainSampler: _hello_terrain_work.Task<TerrainSampler, string, unknown>;
     readonly elevationFieldStage: _hello_terrain_work.Task<ComputePipeline, string, unknown>;
     readonly terrainFieldStage: _hello_terrain_work.Task<ComputePipeline, string, unknown>;
     readonly compileCompute: _hello_terrain_work.Task<{
@@ -679,6 +713,8 @@ type ComputeDeviceLimits = {
 };
 declare function getDeviceComputeLimits(renderer: WebGPURenderer): ComputeDeviceLimits;
 
+declare function createTerrainSampler(params: CreateTerrainSamplerParams): TerrainSampler;
+
 /**
  * Maps a value or node from texture space [0, 1] to vector space [-1, 1].
  *
@@ -751,5 +787,5 @@ declare const voronoiCells: three_src_nodes_TSL_js.ShaderNodeFn<[three_tsl.Proxi
     uv: Node;
 }>]>;
 
-export { ArrayTextureBackend, AtlasBackend, Dir, TerrainGeometry, TerrainMesh, Texture3DBackend, U32_EMPTY, allocLeafSet, allocSeamTable, beginUpdate, blendAngleCorrectedNormals, buildLeafIndex, buildSeams2to1, compileComputeTask, createComputePipelineTasks, createCubeSphereSurface, createElevationFieldContextTask, createFlatSurface, createInfiniteFlatSurface, createSpatialIndex, createState, createTerrainFieldStorage, createTerrainFieldTextureTask, createTerrainUniforms, createUniformsTask, deriveNormalZ, elevationFieldStageTask, elevationFn, elevationScale, executeComputeTask, getDeviceComputeLimits, innerTileSegments, instanceIdTask, isSkirtUV, isSkirtVertex, leafGpuBufferTask, leafStorageTask, loadTerrainField, loadTerrainFieldElevation, loadTerrainFieldNormal, maxLevel, maxNodes, origin, packTerrainFieldSample, positionNodeTask, quadtreeConfigTask, quadtreeUpdate, quadtreeUpdateTask, resetLeafSet, resetSeamTable, rootSize, sampleTerrainField, sampleTerrainFieldElevation, sampleTerrainFieldNormal, skirtScale, storeTerrainField, surface, surfaceTask, terrainFieldFilter, terrainFieldStageTask, terrainGraph, terrainTasks, textureSpaceToVectorSpace, tileNodesTask, update, updateUniformsTask, vElevation, vGlobalVertexIndex, vectorSpaceToTextureSpace, voronoiCells };
-export type { ComputePipeline, ComputeStageCallback, CubeSphereSurfaceConfig, ElevationCallback, ElevationFieldContext, ElevationParams, FlatSurfaceConfig, InfiniteFlatSurfaceConfig, IntNodeInput, LeafGpuBufferState, LeafSet, LeafStorageState, LodMode, QuadtreeConfig, QuadtreeConfigState, QuadtreeState, SeamTable, SpatialIndex, Surface, TerrainFieldStorage, TerrainFieldStorageBackendType, TerrainFieldStorageFormat, TerrainFieldStorageOptions, TerrainGraph, TerrainTasks, TerrainUniformsContext, TerrainUniformsParams, TileBounds, TileId, UpdateParams };
+export { ArrayTextureBackend, AtlasBackend, Dir, TerrainGeometry, TerrainMesh, Texture3DBackend, U32_EMPTY, allocLeafSet, allocSeamTable, beginUpdate, blendAngleCorrectedNormals, buildLeafIndex, buildSeams2to1, compileComputeTask, createComputePipelineTasks, createCubeSphereSurface, createElevationFieldContextTask, createFlatSurface, createInfiniteFlatSurface, createSpatialIndex, createState, createTerrainFieldStorage, createTerrainFieldTextureTask, createTerrainSampler, createTerrainSamplerTask, createTerrainUniforms, createUniformsTask, deriveNormalZ, elevationFieldStageTask, elevationFn, elevationScale, executeComputeTask, getDeviceComputeLimits, gpuSpatialIndexStorageTask, gpuSpatialIndexUploadTask, innerTileSegments, instanceIdTask, isSkirtUV, isSkirtVertex, leafGpuBufferTask, leafStorageTask, loadTerrainField, loadTerrainFieldElevation, loadTerrainFieldNormal, maxLevel, maxNodes, origin, packTerrainFieldSample, positionNodeTask, quadtreeConfigTask, quadtreeUpdate, quadtreeUpdateTask, resetLeafSet, resetSeamTable, rootSize, sampleTerrainField, sampleTerrainFieldElevation, sampleTerrainFieldNormal, skirtScale, storeTerrainField, surface, surfaceTask, terrainFieldFilter, terrainFieldStageTask, terrainGraph, terrainTasks, textureSpaceToVectorSpace, tileNodesTask, update, updateUniformsTask, vElevation, vGlobalVertexIndex, vectorSpaceToTextureSpace, voronoiCells };
+export type { ComputePipeline, ComputeStageCallback, CreateTerrainSamplerParams, CubeSphereSurfaceConfig, ElevationCallback, ElevationFieldContext, ElevationParams, FlatSurfaceConfig, GpuSpatialIndexContext, InfiniteFlatSurfaceConfig, IntNodeInput, LeafGpuBufferState, LeafSet, LeafStorageState, LodMode, QuadtreeConfig, QuadtreeConfigState, QuadtreeState, SeamTable, SpatialIndex, Surface, TerrainFieldStorage, TerrainFieldStorageBackendType, TerrainFieldStorageFormat, TerrainFieldStorageOptions, TerrainGraph, TerrainSampler, TerrainTasks, TerrainUniformsContext, TerrainUniformsParams, TileBounds, TileId, UpdateParams };

package/dist/index.d.ts

@@ -458,6 +458,41 @@ declare function createTileCompute(leafStorage: LeafStorageState, uniforms: Terr
     tileVertexWorldPositionCompute: three_src_nodes_TSL_js.ShaderNodeFn<[number | Node, number | Node, number | Node]>;
 };
 
+interface ElevationParams {
+    worldPosition: Node$1;
+    rootSize: Node$1;
+    rootUV: Node$1;
+    tileUV: Node$1;
+    tileLevel: Node$1;
+    tileSize: Node$1;
+    tileOriginVec2: Node$1;
+    nodeIndex: Node$1;
+}
+type ElevationCallback = (params: ElevationParams) => Node$1;
+
+interface GpuSpatialIndexContext {
+    data: Uint32Array<ArrayBuffer>;
+    size: number;
+    mask: number;
+    stampGen: UniformNode<number>;
+    attribute: StorageBufferAttribute;
+    node: StorageBufferNode;
+}
+interface TerrainSampler {
+    sampleElevation: (worldX: Node, worldZ: Node) => Node;
+    sampleNormal: (worldX: Node, worldZ: Node) => Node;
+    sampleTerrain: (worldX: Node, worldZ: Node) => Node;
+    sampleValidity: (worldX: Node, worldZ: Node) => Node;
+    evaluateElevation: (worldX: Node, worldZ: Node) => Node;
+    evaluateNormal: (worldX: Node, worldZ: Node, epsilon?: Node) => Node;
+}
+interface CreateTerrainSamplerParams {
+    terrainFieldStorage: TerrainFieldStorage;
+    spatialIndex: GpuSpatialIndexContext;
+    uniforms: TerrainUniformsContext;
+    elevationCallback: ElevationCallback;
+}
+
 interface QuadtreeConfigState {
     state: QuadtreeState;
     surface: Surface;
@@ -478,12 +513,15 @@ interface TerrainTasks {
     surface: TaskRef<Surface>;
     leafStorage: TaskRef<LeafStorageState>;
     leafGpuBuffer: TaskRef<LeafGpuBufferState>;
+    gpuSpatialIndexStorage: TaskRef<GpuSpatialIndexContext>;
+    gpuSpatialIndexUpload: TaskRef<GpuSpatialIndexContext>;
     createUniforms: TaskRef<TerrainUniformsContext>;
     updateUniforms: TaskRef<TerrainUniformsContext>;
     positionNode: TaskRef<ShaderCallNodeInternal>;
     createElevationFieldContext: TaskRef<ElevationFieldContext>;
     createTileNodes: TaskRef<ReturnType<typeof createTileCompute>>;
     createTerrainFieldTexture: TaskRef<TerrainFieldStorage>;
+    createTerrainSampler: TaskRef<TerrainSampler>;
     elevationFieldStage: TaskRef<ComputePipeline>;
     terrainFieldStage: TaskRef<ComputePipeline>;
     compileCompute: TaskRef<{
@@ -513,6 +551,9 @@ declare const tileNodesTask: _hello_terrain_work.Task<{
  */
 declare const elevationFieldStageTask: _hello_terrain_work.Task<ComputePipeline, string, unknown>;
 
+declare const gpuSpatialIndexStorageTask: _hello_terrain_work.Task<GpuSpatialIndexContext, string, unknown>;
+declare const gpuSpatialIndexUploadTask: _hello_terrain_work.Task<GpuSpatialIndexContext, string, unknown>;
+
 /** Generates a unique instance ID per graph (cached once). */
 declare const instanceIdTask: _hello_terrain_work.Task<`${string}-${string}-${string}-${string}-${string}`, string, unknown>;
 
@@ -529,17 +570,7 @@ declare const createTerrainFieldTextureTask: _hello_terrain_work.Task<any, strin
  */
 declare const terrainFieldStageTask: _hello_terrain_work.Task<ComputePipeline, string, unknown>;
 
-interface ElevationParams {
-    worldPosition: Node$1;
-    rootSize: Node$1;
-    rootUV: Node$1;
-    tileUV: Node$1;
-    tileLevel: Node$1;
-    tileSize: Node$1;
-    tileOriginVec2: Node$1;
-    nodeIndex: Node$1;
-}
-type ElevationCallback = (params: ElevationParams) => Node$1;
+declare const createTerrainSamplerTask: _hello_terrain_work.Task<TerrainSampler, string, unknown>;
 
 /** Root tile size in world units. */
 declare const rootSize: _hello_terrain_work.ParamRef<number>;
@@ -644,6 +675,8 @@ declare const terrainTasks: {
         attribute: three_webgpu.StorageBufferAttribute;
         node: three_webgpu.StorageBufferNode;
     }, string, unknown>;
+    readonly gpuSpatialIndexStorage: _hello_terrain_work.Task<GpuSpatialIndexContext, string, unknown>;
+    readonly gpuSpatialIndexUpload: _hello_terrain_work.Task<GpuSpatialIndexContext, string, unknown>;
     readonly createUniforms: _hello_terrain_work.Task<TerrainUniformsContext, string, unknown>;
     readonly updateUniforms: _hello_terrain_work.Task<TerrainUniformsContext, string, unknown>;
     readonly positionNode: _hello_terrain_work.Task<three_src_nodes_TSL_js.ShaderCallNodeInternal, string, unknown>;
@@ -662,6 +695,7 @@ declare const terrainTasks: {
     readonly createTerrainFieldTexture: _hello_terrain_work.Task<any, string, {
         renderer: WebGPURenderer;
     }>;
+    readonly createTerrainSampler: _hello_terrain_work.Task<TerrainSampler, string, unknown>;
     readonly elevationFieldStage: _hello_terrain_work.Task<ComputePipeline, string, unknown>;
     readonly terrainFieldStage: _hello_terrain_work.Task<ComputePipeline, string, unknown>;
     readonly compileCompute: _hello_terrain_work.Task<{
@@ -679,6 +713,8 @@ type ComputeDeviceLimits = {
 };
 declare function getDeviceComputeLimits(renderer: WebGPURenderer): ComputeDeviceLimits;
 
+declare function createTerrainSampler(params: CreateTerrainSamplerParams): TerrainSampler;
+
 /**
  * Maps a value or node from texture space [0, 1] to vector space [-1, 1].
  *
@@ -751,5 +787,5 @@ declare const voronoiCells: three_src_nodes_TSL_js.ShaderNodeFn<[three_tsl.Proxi
     uv: Node;
 }>]>;
 
-export { ArrayTextureBackend, AtlasBackend, Dir, TerrainGeometry, TerrainMesh, Texture3DBackend, U32_EMPTY, allocLeafSet, allocSeamTable, beginUpdate, blendAngleCorrectedNormals, buildLeafIndex, buildSeams2to1, compileComputeTask, createComputePipelineTasks, createCubeSphereSurface, createElevationFieldContextTask, createFlatSurface, createInfiniteFlatSurface, createSpatialIndex, createState, createTerrainFieldStorage, createTerrainFieldTextureTask, createTerrainUniforms, createUniformsTask, deriveNormalZ, elevationFieldStageTask, elevationFn, elevationScale, executeComputeTask, getDeviceComputeLimits, innerTileSegments, instanceIdTask, isSkirtUV, isSkirtVertex, leafGpuBufferTask, leafStorageTask, loadTerrainField, loadTerrainFieldElevation, loadTerrainFieldNormal, maxLevel, maxNodes, origin, packTerrainFieldSample, positionNodeTask, quadtreeConfigTask, quadtreeUpdate, quadtreeUpdateTask, resetLeafSet, resetSeamTable, rootSize, sampleTerrainField, sampleTerrainFieldElevation, sampleTerrainFieldNormal, skirtScale, storeTerrainField, surface, surfaceTask, terrainFieldFilter, terrainFieldStageTask, terrainGraph, terrainTasks, textureSpaceToVectorSpace, tileNodesTask, update, updateUniformsTask, vElevation, vGlobalVertexIndex, vectorSpaceToTextureSpace, voronoiCells };
-export type { ComputePipeline, ComputeStageCallback, CubeSphereSurfaceConfig, ElevationCallback, ElevationFieldContext, ElevationParams, FlatSurfaceConfig, InfiniteFlatSurfaceConfig, IntNodeInput, LeafGpuBufferState, LeafSet, LeafStorageState, LodMode, QuadtreeConfig, QuadtreeConfigState, QuadtreeState, SeamTable, SpatialIndex, Surface, TerrainFieldStorage, TerrainFieldStorageBackendType, TerrainFieldStorageFormat, TerrainFieldStorageOptions, TerrainGraph, TerrainTasks, TerrainUniformsContext, TerrainUniformsParams, TileBounds, TileId, UpdateParams };
+export { ArrayTextureBackend, AtlasBackend, Dir, TerrainGeometry, TerrainMesh, Texture3DBackend, U32_EMPTY, allocLeafSet, allocSeamTable, beginUpdate, blendAngleCorrectedNormals, buildLeafIndex, buildSeams2to1, compileComputeTask, createComputePipelineTasks, createCubeSphereSurface, createElevationFieldContextTask, createFlatSurface, createInfiniteFlatSurface, createSpatialIndex, createState, createTerrainFieldStorage, createTerrainFieldTextureTask, createTerrainSampler, createTerrainSamplerTask, createTerrainUniforms, createUniformsTask, deriveNormalZ, elevationFieldStageTask, elevationFn, elevationScale, executeComputeTask, getDeviceComputeLimits, gpuSpatialIndexStorageTask, gpuSpatialIndexUploadTask, innerTileSegments, instanceIdTask, isSkirtUV, isSkirtVertex, leafGpuBufferTask, leafStorageTask, loadTerrainField, loadTerrainFieldElevation, loadTerrainFieldNormal, maxLevel, maxNodes, origin, packTerrainFieldSample, positionNodeTask, quadtreeConfigTask, quadtreeUpdate, quadtreeUpdateTask, resetLeafSet, resetSeamTable, rootSize, sampleTerrainField, sampleTerrainFieldElevation, sampleTerrainFieldNormal, skirtScale, storeTerrainField, surface, surfaceTask, terrainFieldFilter, terrainFieldStageTask, terrainGraph, terrainTasks, textureSpaceToVectorSpace, tileNodesTask, update, updateUniformsTask, vElevation, vGlobalVertexIndex, vectorSpaceToTextureSpace, voronoiCells };
+export type { ComputePipeline, ComputeStageCallback, CreateTerrainSamplerParams, CubeSphereSurfaceConfig, ElevationCallback, ElevationFieldContext, ElevationParams, FlatSurfaceConfig, GpuSpatialIndexContext, InfiniteFlatSurfaceConfig, IntNodeInput, LeafGpuBufferState, LeafSet, LeafStorageState, LodMode, QuadtreeConfig, QuadtreeConfigState, QuadtreeState, SeamTable, SpatialIndex, Surface, TerrainFieldStorage, TerrainFieldStorageBackendType, TerrainFieldStorageFormat, TerrainFieldStorageOptions, TerrainGraph, TerrainSampler, TerrainTasks, TerrainUniformsContext, TerrainUniformsParams, TileBounds, TileId, UpdateParams };

package/dist/index.mjs

@@ -1,7 +1,7 @@
 import { BufferGeometry, BufferAttribute, RGBAFormat, ClampToEdgeWrapping, HalfFloatType, FloatType, LinearFilter, NearestFilter, Vector3 as Vector3$1 } from 'three';
 import { MeshStandardNodeMaterial, InstancedMesh, InstancedBufferAttribute, StorageTexture, StorageArrayTexture, StorageBufferAttribute, Vector3 } from 'three/webgpu';
 import { param, task, graph } from '@hello-terrain/work';
-import { uniform, Fn, float, globalId, int, vec2, uint, If, workgroupBarrier, textureStore, uvec3, vec4, texture, ivec2, ivec3, textureLoad, instanceIndex, min, max, pow, vec3, storage, vertexIndex, uv, select, positionLocal, normalLocal, remap, dot, varyingProperty, mx_noise_float, Loop, mix } from 'three/tsl';
+import { uniform, Fn, float, globalId, int, vec2, uint, If, workgroupBarrier, textureStore, uvec3, vec4, texture, ivec2, ivec3, textureLoad, pow, vec3, storage, Loop, Break, vertexIndex, uv, select, instanceIndex, positionLocal, normalLocal, remap, dot, varyingProperty, mx_noise_float, mix } from 'three/tsl';
 import { Fn as Fn$1 } from 'three/src/nodes/TSL.js';
 
 class TerrainGeometry extends BufferGeometry {
@@ -645,25 +645,6 @@ const createElevation = (tile, uniforms, elevationFn) => {
     });
   };
 };
-const readElevationFieldAtPositionLocal = (terrainFieldStorage, edgeVertexCount, positionLocal) => Fn(() => {
-  const nodeIndex = int(instanceIndex);
-  const intEdge = int(edgeVertexCount);
-  const innerSegments = int(edgeVertexCount).sub(3);
-  const fInnerSegments = float(innerSegments);
-  const last = intEdge.sub(int(1));
-  const u = positionLocal.x.add(float(0.5));
-  const v = positionLocal.z.add(float(0.5));
-  const x = u.mul(fInnerSegments).round().toInt().add(int(1));
-  const y = v.mul(fInnerSegments).round().toInt().add(int(1));
-  const xClamped = min(max(x, int(0)), last);
-  const yClamped = min(max(y, int(0)), last);
-  return loadTerrainFieldElevation(
-    terrainFieldStorage,
-    xClamped,
-    yClamped,
-    nodeIndex
-  );
-});
 
 function createTileCompute(leafStorage, uniforms) {
   const tileLevel = Fn(([nodeIndex]) => {
@@ -730,6 +711,10 @@ function createTileCompute(leafStorage, uniforms) {
     tileVertexWorldPositionCompute
   };
 }
+function tileLocalToFieldUV(localCoord, innerSegments) {
+  const edge = float(innerSegments).add(float(3));
+  return float(localCoord).mul(float(innerSegments)).add(float(1.5)).div(edge);
+}
 
 const rootSize = param(256).displayName("rootSize");
 const origin = param({
@@ -846,12 +831,12 @@ function ensureChildren(store, parentId) {
   return childBase;
 }
 
-function nextPow2(n) {
+function nextPow2$1(n) {
   let x = 1;
   while (x < n) x <<= 1;
   return x;
 }
-function mix32(x) {
+function mix32$1(x) {
   x >>>= 0;
   x ^= x >>> 16;
   x = Math.imul(x, 2146121005) >>> 0;
@@ -860,12 +845,12 @@ function mix32(x) {
   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 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 createSpatialIndex(maxEntries) {
-  const size = nextPow2(Math.max(2, maxEntries * 2));
+  const size = nextPow2$1(Math.max(2, maxEntries * 2));
   return {
     size,
     mask: size - 1,
@@ -890,7 +875,7 @@ function insertSpatialIndexRaw(index, space, level, x, y, value) {
   const l = level & 255;
   const xx = x >>> 0;
   const yy = y >>> 0;
-  let slot = hashKey(s, l, xx, yy) & index.mask;
+  let slot = hashKey$1(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;
@@ -914,7 +899,7 @@ function lookupSpatialIndexRaw(index, space, level, x, y) {
   const l = level & 255;
   const xx = x >>> 0;
   const yy = y >>> 0;
-  let slot = hashKey(s, l, xx, yy) & index.mask;
+  let slot = hashKey$1(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) {
@@ -1675,6 +1660,275 @@ function createComputePipelineTasks(leafStageTask) {
   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 StorageBufferAttribute(data, SLOT_STRIDE);
+  const node = storage(attribute, "u32", 1).toReadOnly().setName("gpuSpatialIndex");
+  const stampGen = uniform(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 = int(slot).mul(int(SLOT_STRIDE)).add(int(fieldOffset));
+  return spatialIndex.node.element(offset).toUint();
+}
+const mix32 = Fn(([x]) => {
+  const v = uint(x).toVar();
+  v.assign(v.bitXor(v.shiftRight(uint(16))));
+  v.assign(v.mul(uint(2146121005)));
+  v.assign(v.bitXor(v.shiftRight(uint(15))));
+  v.assign(v.mul(uint(2221713035)));
+  v.assign(v.bitXor(v.shiftRight(uint(16))));
+  return v;
+});
+const hashKey = Fn(([space, level, x, y]) => {
+  const s = uint(space).bitAnd(uint(255));
+  const l = uint(level).bitAnd(uint(255));
+  const h = s.bitXor(l.shiftLeft(uint(8))).bitXor(mix32(uint(x))).bitXor(mix32(uint(y)));
+  return mix32(h);
+});
+const createGpuSpatialLookup = (spatialIndex) => {
+  const slotCount = spatialIndex.size;
+  const mask = uint(spatialIndex.mask);
+  const stampGen = spatialIndex.stampGen.toUint();
+  const emptyValue = int(-1);
+  return Fn(([space, level, x, y]) => {
+    const s = uint(space).bitAnd(uint(255));
+    const l = uint(level).bitAnd(uint(255));
+    const xx = uint(x);
+    const yy = uint(y);
+    const result = emptyValue.toVar();
+    const slot = hashKey(s, l, xx, yy).bitAnd(mask).toVar();
+    const probes = int(0).toVar();
+    Loop(slotCount, () => {
+      const stamp = readGpuSpatialIndexValue(spatialIndex, slot, 0);
+      If(stamp.notEqual(stampGen), () => {
+        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);
+      If(
+        ks.equal(s).and(kl.equal(l)).and(kx.equal(xx)).and(ky.equal(yy)),
+        () => {
+          result.assign(int(readGpuSpatialIndexValue(spatialIndex, slot, 5)));
+          Break();
+        }
+      );
+      slot.assign(slot.add(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 Fn(([worldX, worldZ]) => {
+    const rootOrigin = uniforms.uRootOrigin.toVar();
+    const rootSize = uniforms.uRootSize.toVar();
+    const halfRoot = rootSize.mul(float(0.5));
+    const tileIndex = int(-1).toVar();
+    const tileU = float(0).toVar();
+    const tileV = float(0).toVar();
+    const i = int(0).toVar();
+    Loop(levelCount, () => {
+      const level = int(maxLevel).sub(i).toVar();
+      const scale = pow(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(int(0), level, tileX, tileY).toVar();
+      If(maybeIndex.greaterThanEqual(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));
+        Break();
+      });
+      i.addAssign(1);
+    });
+    return vec3(tileIndex.toFloat(), tileU, tileV);
+  });
+};
+
+const gpuSpatialIndexStorageTask = task((get, work) => {
+  const maxNodesValue = get(maxNodes);
+  return work(() => createGpuSpatialIndex(maxNodesValue));
+}).displayName("gpuSpatialIndexStorageTask");
+const gpuSpatialIndexUploadTask = 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 Fn(([worldX, worldZ]) => {
+    const tileResult = tileLookup(worldX, worldZ).toVar();
+    const tileIndex = int(tileResult.x).toVar();
+    const safeTileIndex = tileIndex.max(int(0)).toVar();
+    const u = tileResult.y.toVar();
+    const v = tileResult.z.toVar();
+    const fieldU = tileLocalToFieldUV(
+      u,
+      params.uniforms.uInnerTileSegments
+    ).toVar();
+    const fieldV = tileLocalToFieldUV(
+      v,
+      params.uniforms.uInnerTileSegments
+    ).toVar();
+    const found = tileIndex.greaterThanEqual(int(0)).toVar();
+    const sampled = sampleTerrainField(
+      params.terrainFieldStorage,
+      fieldU,
+      fieldV,
+      safeTileIndex
+    ).toVar();
+    const nx = sampled.g.toVar();
+    const nz = sampled.b.toVar();
+    const ny = float(1).sub(nx.mul(nx)).sub(nz.mul(nz)).max(0).sqrt();
+    const valid = found.select(float(1), float(0)).toVar();
+    return 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 = 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 = vec2(
+      centeredX.div(rootSize).add(0.5),
+      centeredZ.div(rootSize).mul(float(-1)).add(0.5)
+    ).toVar();
+    return elevationNode({
+      worldPosition: vec3(worldX, rootOrigin.y, worldZ),
+      rootSize,
+      rootUV,
+      tileUV: rootUV,
+      tileLevel: int(0),
+      tileSize: rootSize,
+      tileOriginVec2: vec2(0, 0),
+      nodeIndex: int(0)
+    });
+  });
+  const sampleTerrain = Fn(
+    ([worldX, worldZ]) => terrainSampleAt(worldX, worldZ)
+  );
+  const sampleElevation = Fn(
+    ([worldX, worldZ]) => terrainSampleAt(worldX, worldZ).x
+  );
+  const sampleNormal = Fn(
+    ([worldX, worldZ]) => vec3(
+      terrainSampleAt(worldX, worldZ).y,
+      terrainSampleAt(worldX, worldZ).z,
+      terrainSampleAt(worldX, worldZ).w
+    )
+  );
+  const sampleValidity = Fn(
+    ([worldX, worldZ]) => terrainSampleAt(worldX, worldZ).y.abs().add(terrainSampleAt(worldX, worldZ).z.abs()).add(terrainSampleAt(worldX, worldZ).w.abs()).greaterThan(float(0)).select(float(1), float(0))
+  );
+  const evaluateElevation = Fn(
+    ([worldX, worldZ]) => evaluateElevationAt(worldX, worldZ)
+  );
+  const evaluateNormalNode = Fn(
+    ([worldX, worldZ, epsilon]) => {
+      const eps = epsilon ?? 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 = float(0.5).div(eps);
+      const dhdx = hR.sub(hL).mul(inv2eps);
+      const dhdz = hU.sub(hD).mul(inv2eps);
+      return vec3(dhdx.negate(), float(1), dhdz.negate()).normalize();
+    }
+  );
+  const evaluateNormal = (worldX, worldZ, epsilon) => evaluateNormalNode(worldX, worldZ, epsilon ?? float(0.1));
+  return {
+    sampleElevation,
+    sampleNormal,
+    sampleTerrain,
+    sampleValidity,
+    evaluateElevation,
+    evaluateNormal
+  };
+}
+
+const createTerrainSamplerTask = task((get, work) => {
+  const terrainFieldStorage = get(createTerrainFieldTextureTask);
+  const spatialIndex = get(gpuSpatialIndexStorageTask);
+  const uniforms = get(createUniformsTask);
+  const elevationCallback = get(elevationFn);
+  return work(
+    () => createTerrainSampler({
+      terrainFieldStorage,
+      spatialIndex,
+      uniforms,
+      elevationCallback
+    })
+  );
+}).displayName("createTerrainSamplerTask");
+
 const isSkirtVertex = Fn(([segments]) => {
   const segmentsNode = typeof segments === "number" ? int(segments) : segments;
   const vIndex = int(vertexIndex);
@@ -1718,14 +1972,15 @@ function createTileBaseWorldPosition(leafStorage, terrainUniforms) {
 }
 function createTileElevation(terrainUniforms, terrainFieldStorage) {
   if (!terrainFieldStorage) return float(0);
-  const edgeVertexCount = terrainUniforms.uInnerTileSegments.add(3);
-  return readElevationFieldAtPositionLocal(
+  const innerSegs = terrainUniforms.uInnerTileSegments;
+  const u = tileLocalToFieldUV(positionLocal.x.add(float(0.5)), innerSegs);
+  const v = tileLocalToFieldUV(positionLocal.z.add(float(0.5)), innerSegs);
+  return sampleTerrainFieldElevation(
     terrainFieldStorage,
-    edgeVertexCount,
-    positionLocal
-  )().mul(
-    terrainUniforms.uElevationScale
-  );
+    u,
+    v,
+    int(instanceIndex)
+  ).mul(terrainUniforms.uElevationScale);
 }
 function createNormalAssignment(terrainUniforms, terrainFieldStorage) {
   if (!terrainFieldStorage) return;
@@ -1734,7 +1989,12 @@ function createNormalAssignment(terrainUniforms, terrainFieldStorage) {
   const localVertexIndex = int(vertexIndex);
   const ix = localVertexIndex.mod(edgeVertexCount);
   const iy = localVertexIndex.div(edgeVertexCount);
-  const normalXZ = loadTerrainFieldNormal(terrainFieldStorage, ix, iy, nodeIndex);
+  const normalXZ = loadTerrainFieldNormal(
+    terrainFieldStorage,
+    ix,
+    iy,
+    nodeIndex
+  );
   const nx = normalXZ.x;
   const nz = normalXZ.y;
   const nySq = float(1).sub(nx.mul(nx)).sub(nz.mul(nz)).max(float(0));
@@ -1742,10 +2002,16 @@ function createNormalAssignment(terrainUniforms, terrainFieldStorage) {
   normalLocal.assign(vec3(nx, ny, nz));
 }
 function createTileWorldPosition(leafStorage, terrainUniforms, terrainFieldStorage) {
-  const baseWorldPosition = createTileBaseWorldPosition(leafStorage, terrainUniforms);
+  const baseWorldPosition = createTileBaseWorldPosition(
+    leafStorage,
+    terrainUniforms
+  );
   return Fn(() => {
     const base = baseWorldPosition();
-    const yElevation = createTileElevation(terrainUniforms, terrainFieldStorage);
+    const yElevation = createTileElevation(
+      terrainUniforms,
+      terrainFieldStorage
+    );
     const skirtVertex = isSkirtVertex(terrainUniforms.uInnerTileSegments);
     const skirtY = base.y.add(yElevation).sub(terrainUniforms.uSkirtScale.toVar());
     const worldY = select(skirtVertex, skirtY, base.y.add(yElevation));
@@ -1768,7 +2034,7 @@ const positionNodeTask = task((get, work) => {
 }).displayName("positionNodeTask");
 
 function terrainGraph() {
-  return graph().add(instanceIdTask).add(quadtreeConfigTask).add(quadtreeUpdateTask).add(leafStorageTask).add(surfaceTask).add(leafGpuBufferTask).add(createUniformsTask).add(updateUniformsTask).add(positionNodeTask).add(createElevationFieldContextTask).add(tileNodesTask).add(createTerrainFieldTextureTask).add(elevationFieldStageTask).add(terrainFieldStageTask).add(compileComputeTask).add(executeComputeTask);
+  return 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);
 }
 const terrainTasks = {
   instanceId: instanceIdTask,
@@ -1777,12 +2043,15 @@ const terrainTasks = {
   leafStorage: leafStorageTask,
   surface: surfaceTask,
   leafGpuBuffer: leafGpuBufferTask,
+  gpuSpatialIndexStorage: gpuSpatialIndexStorageTask,
+  gpuSpatialIndexUpload: gpuSpatialIndexUploadTask,
   createUniforms: createUniformsTask,
   updateUniforms: updateUniformsTask,
   positionNode: positionNodeTask,
   createElevationFieldContext: createElevationFieldContextTask,
   createTileNodes: tileNodesTask,
   createTerrainFieldTexture: createTerrainFieldTextureTask,
+  createTerrainSampler: createTerrainSamplerTask,
   elevationFieldStage: elevationFieldStageTask,
   terrainFieldStage: terrainFieldStageTask,
   compileCompute: compileComputeTask,
@@ -1841,4 +2110,4 @@ const voronoiCells = Fn((params) => {
   return k;
 });
 
-export { ArrayTextureBackend, AtlasBackend, Dir, TerrainGeometry, TerrainMesh, Texture3DBackend, U32_EMPTY, allocLeafSet, allocSeamTable, beginUpdate, blendAngleCorrectedNormals, buildLeafIndex, buildSeams2to1, compileComputeTask, createComputePipelineTasks, createCubeSphereSurface, createElevationFieldContextTask, createFlatSurface, createInfiniteFlatSurface, createSpatialIndex, createState, createTerrainFieldStorage, createTerrainFieldTextureTask, createTerrainUniforms, createUniformsTask, deriveNormalZ, elevationFieldStageTask, elevationFn, elevationScale, executeComputeTask, getDeviceComputeLimits, innerTileSegments, instanceIdTask, isSkirtUV, isSkirtVertex, leafGpuBufferTask, leafStorageTask, loadTerrainField, loadTerrainFieldElevation, loadTerrainFieldNormal, maxLevel, maxNodes, origin, packTerrainFieldSample, positionNodeTask, quadtreeConfigTask, quadtreeUpdate, quadtreeUpdateTask, resetLeafSet, resetSeamTable, rootSize, sampleTerrainField, sampleTerrainFieldElevation, sampleTerrainFieldNormal, skirtScale, storeTerrainField, surface, surfaceTask, terrainFieldFilter, terrainFieldStageTask, terrainGraph, terrainTasks, textureSpaceToVectorSpace, tileNodesTask, update, updateUniformsTask, vElevation, vGlobalVertexIndex, vectorSpaceToTextureSpace, voronoiCells };
+export { ArrayTextureBackend, AtlasBackend, Dir, TerrainGeometry, TerrainMesh, Texture3DBackend, U32_EMPTY, allocLeafSet, allocSeamTable, beginUpdate, blendAngleCorrectedNormals, buildLeafIndex, buildSeams2to1, compileComputeTask, createComputePipelineTasks, createCubeSphereSurface, createElevationFieldContextTask, createFlatSurface, createInfiniteFlatSurface, createSpatialIndex, createState, createTerrainFieldStorage, createTerrainFieldTextureTask, createTerrainSampler, createTerrainSamplerTask, createTerrainUniforms, createUniformsTask, deriveNormalZ, elevationFieldStageTask, elevationFn, elevationScale, executeComputeTask, getDeviceComputeLimits, gpuSpatialIndexStorageTask, gpuSpatialIndexUploadTask, innerTileSegments, instanceIdTask, isSkirtUV, isSkirtVertex, leafGpuBufferTask, leafStorageTask, loadTerrainField, loadTerrainFieldElevation, loadTerrainFieldNormal, maxLevel, maxNodes, origin, packTerrainFieldSample, positionNodeTask, quadtreeConfigTask, quadtreeUpdate, quadtreeUpdateTask, resetLeafSet, resetSeamTable, rootSize, sampleTerrainField, sampleTerrainFieldElevation, sampleTerrainFieldNormal, skirtScale, storeTerrainField, surface, surfaceTask, terrainFieldFilter, terrainFieldStageTask, terrainGraph, terrainTasks, textureSpaceToVectorSpace, tileNodesTask, update, updateUniformsTask, vElevation, vGlobalVertexIndex, vectorSpaceToTextureSpace, voronoiCells };

package/package.json

@@ -6,7 +6,7 @@
     "type": "git",
     "url": "https://github.com/kenjinp/hello-terrain.git"
   },
-  "version": "0.0.0-alpha.8",
+  "version": "0.0.0-alpha.9",
   "type": "module",
   "main": "./dist/index.mjs",
   "module": "./dist/index.mjs",
@@ -29,12 +29,12 @@
     "mitata": "^1.0.34",
     "unbuild": "^3.5.0",
     "vitest": "^4.0.16",
-    "@config/oxlint": "0.1.0",
+    "@config/typescript": "0.1.0",
     "@config/oxfmt": "0.1.0",
-    "@config/typescript": "0.1.0"
+    "@config/oxlint": "0.1.0"
   },
   "dependencies": {
-    "@hello-terrain/work": "0.2.1"
+    "@hello-terrain/work": "0.3.0"
   },
   "scripts": {
     "build": "unbuild",