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

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, 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 {
@@ -409,25 +409,25 @@ function resolveType(format) {
 function resolveFilter(mode) {
   return mode === "linear" ? LinearFilter : NearestFilter;
 }
-function configureStorageTexture(texture, format, filter) {
-  texture.format = RGBAFormat;
-  texture.type = resolveType(format);
-  texture.magFilter = resolveFilter(filter);
-  texture.minFilter = resolveFilter(filter);
-  texture.wrapS = ClampToEdgeWrapping;
-  texture.wrapT = ClampToEdgeWrapping;
-  texture.generateMipmaps = false;
-  texture.needsUpdate = true;
+function configureStorageTexture(texture2, format, filter) {
+  texture2.format = RGBAFormat;
+  texture2.type = resolveType(format);
+  texture2.magFilter = resolveFilter(filter);
+  texture2.minFilter = resolveFilter(filter);
+  texture2.wrapS = ClampToEdgeWrapping;
+  texture2.wrapT = ClampToEdgeWrapping;
+  texture2.generateMipmaps = false;
+  texture2.needsUpdate = true;
 }
 function ArrayTextureBackend(edgeVertexCount, tileCount, options) {
   let currentEdgeVertexCount = edgeVertexCount;
   let currentTileCount = tileCount;
-  const texture = new StorageArrayTexture(
+  const tex = new StorageArrayTexture(
     edgeVertexCount,
     edgeVertexCount,
     tileCount
   );
-  configureStorageTexture(texture, options.format, options.filter);
+  configureStorageTexture(tex, options.format, options.filter);
   return {
     backendType: "array-texture",
     get edgeVertexCount() {
@@ -436,18 +436,21 @@ function ArrayTextureBackend(edgeVertexCount, tileCount, options) {
     get tileCount() {
       return currentTileCount;
     },
-    texture,
+    texture: tex,
     uv(ix, iy, _tileIndex) {
       return vec2(ix.toFloat(), iy.toFloat());
     },
     texel(ix, iy, tileIndex) {
       return ivec3(ix, iy, tileIndex);
     },
+    sample(u, v, tileIndex) {
+      return texture(tex, vec2(u, v)).depth(int(tileIndex));
+    },
     resize(width, height, nextTileCount) {
       currentEdgeVertexCount = width;
       currentTileCount = nextTileCount;
-      texture.setSize(width, height, nextTileCount);
-      texture.needsUpdate = true;
+      tex.setSize(width, height, nextTileCount);
+      tex.needsUpdate = true;
     }
   };
 }
@@ -466,8 +469,8 @@ function AtlasBackend(edgeVertexCount, tileCount, options) {
   let currentTileCount = tileCount;
   let tilesPerRow = Math.max(1, Math.ceil(Math.sqrt(tileCount)));
   const atlasSize = tilesPerRow * edgeVertexCount;
-  const texture = new StorageTexture(atlasSize, atlasSize);
-  configureStorageTexture(texture, options.format, options.filter);
+  const tex = new StorageTexture(atlasSize, atlasSize);
+  configureStorageTexture(tex, options.format, options.filter);
   return {
     backendType: "atlas",
     get edgeVertexCount() {
@@ -476,7 +479,7 @@ function AtlasBackend(edgeVertexCount, tileCount, options) {
     get tileCount() {
       return currentTileCount;
     },
-    texture,
+    texture: tex,
     uv(ix, iy, tileIndex) {
       const { atlasX, atlasY } = atlasCoord(
         tilesPerRow,
@@ -501,27 +504,37 @@ function AtlasBackend(edgeVertexCount, tileCount, options) {
       );
       return ivec2(atlasX, atlasY);
     },
+    sample(u, v, tileIndex) {
+      const tile = int(tileIndex);
+      const tilesPerRowNode = int(tilesPerRow);
+      const col = tile.mod(tilesPerRowNode);
+      const row = tile.div(tilesPerRowNode);
+      const invTilesPerRow = float(1 / tilesPerRow);
+      const atlasU = col.toFloat().add(u).mul(invTilesPerRow);
+      const atlasV = row.toFloat().add(v).mul(invTilesPerRow);
+      return texture(tex, vec2(atlasU, atlasV));
+    },
     resize(width, height, nextTileCount) {
       currentEdgeVertexCount = width;
       currentTileCount = nextTileCount;
       tilesPerRow = Math.max(1, Math.ceil(Math.sqrt(nextTileCount)));
       const nextAtlasSize = tilesPerRow * width;
-      const image = texture.image;
+      const image = tex.image;
       image.width = nextAtlasSize;
       image.height = nextAtlasSize;
-      texture.needsUpdate = true;
+      tex.needsUpdate = true;
     }
   };
 }
 function Texture3DBackend(edgeVertexCount, tileCount, options) {
   let currentEdgeVertexCount = edgeVertexCount;
   let currentTileCount = tileCount;
-  const texture = new StorageArrayTexture(
+  const tex = new StorageArrayTexture(
     edgeVertexCount,
     edgeVertexCount,
     tileCount
   );
-  configureStorageTexture(texture, options.format, options.filter);
+  configureStorageTexture(tex, options.format, options.filter);
   return {
     backendType: "texture-3d",
     get edgeVertexCount() {
@@ -530,18 +543,21 @@ function Texture3DBackend(edgeVertexCount, tileCount, options) {
     get tileCount() {
       return currentTileCount;
     },
-    texture,
+    texture: tex,
     uv(ix, iy, _tileIndex) {
       return vec2(ix.toFloat(), iy.toFloat());
     },
     texel(ix, iy, tileIndex) {
       return ivec3(ix, iy, tileIndex);
     },
+    sample(u, v, tileIndex) {
+      return texture(tex, vec2(u, v)).depth(int(tileIndex));
+    },
     resize(width, height, nextTileCount) {
       currentEdgeVertexCount = width;
       currentTileCount = nextTileCount;
-      texture.setSize(width, height, nextTileCount);
-      texture.needsUpdate = true;
+      tex.setSize(width, height, nextTileCount);
+      tex.needsUpdate = true;
     }
   };
 }
@@ -550,7 +566,7 @@ function tryGetDeviceLimits(renderer) {
   return backend.backend?.device?.limits ?? {};
 }
 function createTerrainFieldStorage(edgeVertexCount, tileCount, renderer, options = {}) {
-  const filter = options.filter ?? "nearest";
+  const filter = options.filter ?? "linear";
   const format = options.format ?? "rgba16float";
   const forcedBackend = options.backend;
   if (forcedBackend === "atlas") {
@@ -591,8 +607,18 @@ function loadTerrainFieldElevation(storage, ix, iy, tileIndex) {
   return loadTerrainField(storage, ix, iy, tileIndex).r;
 }
 function loadTerrainFieldNormal(storage, ix, iy, tileIndex) {
-  const sample = loadTerrainField(storage, ix, iy, tileIndex);
-  return vec2(sample.g, sample.b);
+  const raw = loadTerrainField(storage, ix, iy, tileIndex);
+  return vec2(raw.g, raw.b);
+}
+function sampleTerrainField(storage, u, v, tileIndex) {
+  return storage.sample(u, v, tileIndex);
+}
+function sampleTerrainFieldElevation(storage, u, v, tileIndex) {
+  return sampleTerrainField(storage, u, v, tileIndex).r;
+}
+function sampleTerrainFieldNormal(storage, u, v, tileIndex) {
+  const raw = sampleTerrainField(storage, u, v, tileIndex);
+  return vec2(raw.g, raw.b);
 }
 function packTerrainFieldSample(height, normalXZ, extra = float(0)) {
   return vec4(height, normalXZ.x, normalXZ.y, extra);
@@ -619,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]) => {
@@ -704,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({
@@ -722,6 +733,7 @@ const quadtreeUpdate = param({
   distanceFactor: 1.5
 }).displayName("quadtreeUpdate");
 const surface = param(null).displayName("surface");
+const terrainFieldFilter = param("linear").displayName("terrainFieldFilter");
 const elevationFn = param(() => float(0));
 
 function createLeafStorage(maxNodes) {
@@ -819,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;
@@ -833,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,
@@ -863,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;
@@ -887,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) {
@@ -1533,11 +1545,13 @@ const createTerrainFieldTextureTask = task(
   (get, work, { resources }) => {
     const edgeVertexCount = get(innerTileSegments) + 3;
     const maxNodesValue = get(maxNodes);
+    const filter = get(terrainFieldFilter);
     return work(
       () => createTerrainFieldStorage(
         edgeVertexCount,
         maxNodesValue,
-        resources?.renderer
+        resources?.renderer,
+        { filter }
       )
     );
   }
@@ -1646,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);
@@ -1689,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;
@@ -1705,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));
@@ -1713,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));
@@ -1739,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,
@@ -1748,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,
@@ -1812,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, skirtScale, storeTerrainField, surface, surfaceTask, 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.7",
+  "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",