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

package/dist/index.cjs

@@ -276,42 +276,356 @@ class TerrainMesh extends webgpu.InstancedMesh {
   }
 }
 
+function getDeviceComputeLimits(renderer) {
+  const backend = renderer.backend;
+  const limits = backend?.device?.limits;
+  return {
+    maxWorkgroupSizeX: limits?.maxComputeWorkgroupSizeX ?? 256,
+    maxWorkgroupSizeY: limits?.maxComputeWorkgroupSizeY ?? 256,
+    maxWorkgroupInvocations: limits?.maxComputeWorkgroupInvocations ?? 256
+  };
+}
+
 const WORKGROUP_X = 16;
 const WORKGROUP_Y = 16;
-function compileComputePipeline(stages, width, bindings) {
-  const workgroupSize = [WORKGROUP_X, WORKGROUP_Y, 1];
-  const dispatchX = Math.ceil(width / WORKGROUP_X);
-  const dispatchY = Math.ceil(width / WORKGROUP_Y);
+function compileComputePipeline(stages, width, options) {
+  const bindings = options?.bindings;
+  const preferredWorkgroup = options?.workgroupSize ?? [
+    WORKGROUP_X,
+    WORKGROUP_Y
+  ];
+  const preferSingleKernelWhenPossible = options?.preferSingleKernelWhenPossible ?? true;
   const uInstanceCount = tsl.uniform(0, "uint");
-  const computeShader = tsl.Fn(() => {
-    const fWidth = tsl.float(width);
-    const activeIndex = tsl.globalId.z;
-    const nodeIndex = tsl.int(activeIndex).toVar();
-    const iWidth = tsl.int(width);
-    const ix = tsl.int(tsl.globalId.x);
-    const iy = tsl.int(tsl.globalId.y);
-    const texelSize = tsl.vec2(1, 1).div(fWidth);
-    const localCoordinates = tsl.vec2(tsl.globalId.x, tsl.globalId.y);
-    const localUVCoords = localCoordinates.div(fWidth);
-    const verticesPerNode = iWidth.mul(iWidth);
-    const globalIndex = tsl.int(nodeIndex).mul(verticesPerNode).add(iy.mul(iWidth).add(ix));
-    const inBounds = ix.lessThan(iWidth).and(iy.lessThan(iWidth)).and(tsl.uint(activeIndex).lessThan(uInstanceCount)).toVar();
-    for (let i = 0; i < stages.length; i++) {
-      if (i > 0) {
-        tsl.workgroupBarrier();
+  let singleKernel;
+  const stagedKernelCache = /* @__PURE__ */ new Map();
+  function canRunSingleKernel(widthValue, limits) {
+    return widthValue <= limits.maxWorkgroupSizeX && widthValue <= limits.maxWorkgroupSizeY && widthValue * widthValue <= limits.maxWorkgroupInvocations;
+  }
+  function clampWorkgroupToLimits(requested, limits) {
+    let x = Math.max(1, Math.floor(requested[0]));
+    let y = Math.max(1, Math.floor(requested[1]));
+    x = Math.min(x, limits.maxWorkgroupSizeX);
+    y = Math.min(y, limits.maxWorkgroupSizeY);
+    y = Math.min(
+      y,
+      Math.max(1, Math.floor(limits.maxWorkgroupInvocations / x))
+    );
+    x = Math.min(
+      x,
+      Math.max(1, Math.floor(limits.maxWorkgroupInvocations / y))
+    );
+    return [x, y];
+  }
+  function buildSingleKernel(workgroupSize) {
+    return tsl.Fn(() => {
+      bindings?.forEach((b) => b.toVar());
+      const fWidth = tsl.float(width);
+      const activeIndex = tsl.globalId.z;
+      const nodeIndex = tsl.int(activeIndex).toVar();
+      const iWidth = tsl.int(width);
+      const ix = tsl.int(tsl.globalId.x);
+      const iy = tsl.int(tsl.globalId.y);
+      const texelSize = tsl.vec2(1, 1).div(fWidth);
+      const localCoordinates = tsl.vec2(tsl.globalId.x, tsl.globalId.y);
+      const localUVCoords = localCoordinates.div(fWidth);
+      const verticesPerNode = iWidth.mul(iWidth);
+      const globalIndex = tsl.int(nodeIndex).mul(verticesPerNode).add(iy.mul(iWidth).add(ix));
+      const inBounds = ix.lessThan(iWidth).and(iy.lessThan(iWidth)).and(tsl.uint(activeIndex).lessThan(uInstanceCount)).toVar();
+      for (let i = 0; i < stages.length; i++) {
+        if (i > 0) {
+          tsl.workgroupBarrier();
+        }
+        tsl.If(inBounds, () => {
+          stages[i](
+            nodeIndex,
+            globalIndex,
+            localUVCoords,
+            localCoordinates,
+            texelSize
+          );
+        });
       }
-      tsl.If(inBounds, () => {
-        stages[i](nodeIndex, globalIndex, localUVCoords, localCoordinates, texelSize);
-      });
-    }
-  })().computeKernel(workgroupSize);
+    })().computeKernel(workgroupSize);
+  }
+  function buildStagedKernels(workgroupSize) {
+    return stages.map(
+      (stage) => tsl.Fn(() => {
+        bindings?.forEach((b) => b.toVar());
+        const fWidth = tsl.float(width);
+        const activeIndex = tsl.globalId.z;
+        const nodeIndex = tsl.int(activeIndex).toVar();
+        const iWidth = tsl.int(width);
+        const ix = tsl.int(tsl.globalId.x);
+        const iy = tsl.int(tsl.globalId.y);
+        const texelSize = tsl.vec2(1, 1).div(fWidth);
+        const localCoordinates = tsl.vec2(tsl.globalId.x, tsl.globalId.y);
+        const localUVCoords = localCoordinates.div(fWidth);
+        const verticesPerNode = iWidth.mul(iWidth);
+        const globalIndex = tsl.int(nodeIndex).mul(verticesPerNode).add(iy.mul(iWidth).add(ix));
+        const inBounds = ix.lessThan(iWidth).and(iy.lessThan(iWidth)).and(tsl.uint(activeIndex).lessThan(uInstanceCount)).toVar();
+        tsl.If(inBounds, () => {
+          stage(
+            nodeIndex,
+            globalIndex,
+            localUVCoords,
+            localCoordinates,
+            texelSize
+          );
+        });
+      })().computeKernel(workgroupSize)
+    );
+  }
   function execute(renderer, instanceCount) {
+    const limits = getDeviceComputeLimits(renderer);
+    const canUseSingleKernel = preferSingleKernelWhenPossible && canRunSingleKernel(width, limits);
     uInstanceCount.value = instanceCount;
-    renderer.compute(computeShader, [dispatchX, dispatchY, instanceCount]);
+    if (canUseSingleKernel) {
+      if (!singleKernel) {
+        singleKernel = buildSingleKernel([width, width, 1]);
+      }
+      renderer.compute(singleKernel, [1, 1, instanceCount]);
+      return;
+    }
+    const [workgroupX, workgroupY] = clampWorkgroupToLimits(
+      preferredWorkgroup,
+      limits
+    );
+    const cacheKey = `${workgroupX}x${workgroupY}`;
+    let stagedKernels = stagedKernelCache.get(cacheKey);
+    if (!stagedKernels) {
+      stagedKernels = buildStagedKernels([workgroupX, workgroupY, 1]);
+      stagedKernelCache.set(cacheKey, stagedKernels);
+    }
+    const dispatchX = Math.ceil(width / workgroupX);
+    const dispatchY = Math.ceil(width / workgroupY);
+    for (const kernel of stagedKernels) {
+      renderer.compute(kernel, [dispatchX, dispatchY, instanceCount]);
+    }
   }
   return { execute };
 }
 
+function resolveType(format) {
+  return format === "rgba16float" ? three.HalfFloatType : three.FloatType;
+}
+function resolveFilter(mode) {
+  return mode === "linear" ? three.LinearFilter : three.NearestFilter;
+}
+function configureStorageTexture(texture2, format, filter) {
+  texture2.format = three.RGBAFormat;
+  texture2.type = resolveType(format);
+  texture2.magFilter = resolveFilter(filter);
+  texture2.minFilter = resolveFilter(filter);
+  texture2.wrapS = three.ClampToEdgeWrapping;
+  texture2.wrapT = three.ClampToEdgeWrapping;
+  texture2.generateMipmaps = false;
+  texture2.needsUpdate = true;
+}
+function ArrayTextureBackend(edgeVertexCount, tileCount, options) {
+  let currentEdgeVertexCount = edgeVertexCount;
+  let currentTileCount = tileCount;
+  const tex = new webgpu.StorageArrayTexture(
+    edgeVertexCount,
+    edgeVertexCount,
+    tileCount
+  );
+  configureStorageTexture(tex, options.format, options.filter);
+  return {
+    backendType: "array-texture",
+    get edgeVertexCount() {
+      return currentEdgeVertexCount;
+    },
+    get tileCount() {
+      return currentTileCount;
+    },
+    texture: tex,
+    uv(ix, iy, _tileIndex) {
+      return tsl.vec2(ix.toFloat(), iy.toFloat());
+    },
+    texel(ix, iy, tileIndex) {
+      return tsl.ivec3(ix, iy, tileIndex);
+    },
+    sample(u, v, tileIndex) {
+      return tsl.texture(tex, tsl.vec2(u, v)).depth(tsl.int(tileIndex));
+    },
+    resize(width, height, nextTileCount) {
+      currentEdgeVertexCount = width;
+      currentTileCount = nextTileCount;
+      tex.setSize(width, height, nextTileCount);
+      tex.needsUpdate = true;
+    }
+  };
+}
+function atlasCoord(tilesPerRow, edgeVertexCount, ix, iy, tileIndex) {
+  const tilesPerRowNode = tsl.int(tilesPerRow);
+  const edge = tsl.int(edgeVertexCount);
+  const tile = tsl.int(tileIndex);
+  const col = tile.mod(tilesPerRowNode);
+  const row = tile.div(tilesPerRowNode);
+  const atlasX = col.mul(edge).add(tsl.int(ix));
+  const atlasY = row.mul(edge).add(tsl.int(iy));
+  return { atlasX, atlasY };
+}
+function AtlasBackend(edgeVertexCount, tileCount, options) {
+  let currentEdgeVertexCount = edgeVertexCount;
+  let currentTileCount = tileCount;
+  let tilesPerRow = Math.max(1, Math.ceil(Math.sqrt(tileCount)));
+  const atlasSize = tilesPerRow * edgeVertexCount;
+  const tex = new webgpu.StorageTexture(atlasSize, atlasSize);
+  configureStorageTexture(tex, options.format, options.filter);
+  return {
+    backendType: "atlas",
+    get edgeVertexCount() {
+      return currentEdgeVertexCount;
+    },
+    get tileCount() {
+      return currentTileCount;
+    },
+    texture: tex,
+    uv(ix, iy, tileIndex) {
+      const { atlasX, atlasY } = atlasCoord(
+        tilesPerRow,
+        currentEdgeVertexCount,
+        ix,
+        iy,
+        tileIndex
+      );
+      const currentAtlasSize = tsl.float(tilesPerRow * currentEdgeVertexCount);
+      return tsl.vec2(
+        atlasX.toFloat().add(0.5).div(currentAtlasSize),
+        atlasY.toFloat().add(0.5).div(currentAtlasSize)
+      );
+    },
+    texel(ix, iy, tileIndex) {
+      const { atlasX, atlasY } = atlasCoord(
+        tilesPerRow,
+        currentEdgeVertexCount,
+        ix,
+        iy,
+        tileIndex
+      );
+      return tsl.ivec2(atlasX, atlasY);
+    },
+    sample(u, v, tileIndex) {
+      const tile = tsl.int(tileIndex);
+      const tilesPerRowNode = tsl.int(tilesPerRow);
+      const col = tile.mod(tilesPerRowNode);
+      const row = tile.div(tilesPerRowNode);
+      const invTilesPerRow = tsl.float(1 / tilesPerRow);
+      const atlasU = col.toFloat().add(u).mul(invTilesPerRow);
+      const atlasV = row.toFloat().add(v).mul(invTilesPerRow);
+      return tsl.texture(tex, tsl.vec2(atlasU, atlasV));
+    },
+    resize(width, height, nextTileCount) {
+      currentEdgeVertexCount = width;
+      currentTileCount = nextTileCount;
+      tilesPerRow = Math.max(1, Math.ceil(Math.sqrt(nextTileCount)));
+      const nextAtlasSize = tilesPerRow * width;
+      const image = tex.image;
+      image.width = nextAtlasSize;
+      image.height = nextAtlasSize;
+      tex.needsUpdate = true;
+    }
+  };
+}
+function Texture3DBackend(edgeVertexCount, tileCount, options) {
+  let currentEdgeVertexCount = edgeVertexCount;
+  let currentTileCount = tileCount;
+  const tex = new webgpu.StorageArrayTexture(
+    edgeVertexCount,
+    edgeVertexCount,
+    tileCount
+  );
+  configureStorageTexture(tex, options.format, options.filter);
+  return {
+    backendType: "texture-3d",
+    get edgeVertexCount() {
+      return currentEdgeVertexCount;
+    },
+    get tileCount() {
+      return currentTileCount;
+    },
+    texture: tex,
+    uv(ix, iy, _tileIndex) {
+      return tsl.vec2(ix.toFloat(), iy.toFloat());
+    },
+    texel(ix, iy, tileIndex) {
+      return tsl.ivec3(ix, iy, tileIndex);
+    },
+    sample(u, v, tileIndex) {
+      return tsl.texture(tex, tsl.vec2(u, v)).depth(tsl.int(tileIndex));
+    },
+    resize(width, height, nextTileCount) {
+      currentEdgeVertexCount = width;
+      currentTileCount = nextTileCount;
+      tex.setSize(width, height, nextTileCount);
+      tex.needsUpdate = true;
+    }
+  };
+}
+function tryGetDeviceLimits(renderer) {
+  const backend = renderer;
+  return backend.backend?.device?.limits ?? {};
+}
+function createTerrainFieldStorage(edgeVertexCount, tileCount, renderer, options = {}) {
+  const filter = options.filter ?? "linear";
+  const format = options.format ?? "rgba16float";
+  const forcedBackend = options.backend;
+  if (forcedBackend === "atlas") {
+    return AtlasBackend(edgeVertexCount, tileCount, { filter, format });
+  }
+  if (forcedBackend === "texture-3d") {
+    return Texture3DBackend(edgeVertexCount, tileCount, { filter, format });
+  }
+  if (forcedBackend === "array-texture") {
+    return ArrayTextureBackend(edgeVertexCount, tileCount, { filter, format });
+  }
+  const DEFAULT_MAX_TEXTURE_ARRAY_LAYERS = 256;
+  const maxLayers = renderer ? tryGetDeviceLimits(renderer).maxTextureArrayLayers ?? DEFAULT_MAX_TEXTURE_ARRAY_LAYERS : DEFAULT_MAX_TEXTURE_ARRAY_LAYERS;
+  if (tileCount > maxLayers) {
+    return AtlasBackend(edgeVertexCount, tileCount, { filter, format });
+  }
+  return ArrayTextureBackend(edgeVertexCount, tileCount, { filter, format });
+}
+function storeTerrainField(storage, ix, iy, tileIndex, value) {
+  if (storage.backendType === "array-texture" || storage.backendType === "texture-3d") {
+    return tsl.textureStore(
+      storage.texture,
+      tsl.uvec3(tsl.int(ix), tsl.int(iy), tsl.int(tileIndex)),
+      value
+    );
+  }
+  return tsl.textureStore(storage.texture, storage.texel(ix, iy, tileIndex), value);
+}
+function loadTerrainField(storage, ix, iy, tileIndex) {
+  if (storage.backendType === "array-texture" || storage.backendType === "texture-3d") {
+    return tsl.textureLoad(storage.texture, tsl.ivec2(tsl.int(ix), tsl.int(iy)), tsl.int(0)).depth(
+      tsl.int(tileIndex)
+    );
+  }
+  return tsl.textureLoad(storage.texture, storage.texel(ix, iy, tileIndex), tsl.int(0));
+}
+function loadTerrainFieldElevation(storage, ix, iy, tileIndex) {
+  return loadTerrainField(storage, ix, iy, tileIndex).r;
+}
+function loadTerrainFieldNormal(storage, ix, iy, tileIndex) {
+  const raw = loadTerrainField(storage, ix, iy, tileIndex);
+  return tsl.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 tsl.vec2(raw.g, raw.b);
+}
+function packTerrainFieldSample(height, normalXZ, extra = tsl.float(0)) {
+  return tsl.vec4(height, normalXZ.x, normalXZ.y, extra);
+}
+
 const createElevation = (tile, uniforms, elevationFn) => {
   return function perVertexElevation(nodeIndex, localCoordinates) {
     const ix = tsl.int(localCoordinates.x);
@@ -333,7 +647,7 @@ const createElevation = (tile, uniforms, elevationFn) => {
     });
   };
 };
-const readElevationFieldAtPositionLocal = (elevationFieldBuffer, edgeVertexCount, positionLocal) => tsl.Fn(() => {
+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);
@@ -345,10 +659,12 @@ const readElevationFieldAtPositionLocal = (elevationFieldBuffer, edgeVertexCount
   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);
-  const verticesPerNode = intEdge.mul(intEdge);
-  const perNodeVertexIndex = yClamped.mul(intEdge).add(xClamped);
-  const globalVertexIndex = nodeIndex.mul(verticesPerNode).add(perNodeVertexIndex);
-  return elevationFieldBuffer.element(globalVertexIndex);
+  return loadTerrainFieldElevation(
+    terrainFieldStorage,
+    xClamped,
+    yClamped,
+    nodeIndex
+  );
 });
 
 function createTileCompute(leafStorage, uniforms) {
@@ -434,6 +750,7 @@ const quadtreeUpdate = work.param({
   distanceFactor: 1.5
 }).displayName("quadtreeUpdate");
 const surface = work.param(null).displayName("surface");
+const terrainFieldFilter = work.param("linear").displayName("terrainFieldFilter");
 const elevationFn = work.param(() => tsl.float(0));
 
 function createLeafStorage(maxNodes) {
@@ -1241,21 +1558,21 @@ const elevationFieldStageTask = work.task((get, work) => {
   });
 }).displayName("elevationFieldStageTask");
 
-const createNormalFieldContextTask = work.task((get, work) => {
-  const edgeVertexCount = get(innerTileSegments) + 3;
-  const verticesPerNode = edgeVertexCount * edgeVertexCount;
-  const totalElements = get(maxNodes) * verticesPerNode;
-  return work(() => {
-    const data = new Uint32Array(totalElements);
-    const attribute = new webgpu.StorageBufferAttribute(data, 1);
-    const node = tsl.storage(attribute, "uint", totalElements);
-    return {
-      data,
-      attribute,
-      node
-    };
-  });
-}).displayName("createNormalFieldContextTask");
+const createTerrainFieldTextureTask = work.task(
+  (get, work, { resources }) => {
+    const edgeVertexCount = get(innerTileSegments) + 3;
+    const maxNodesValue = get(maxNodes);
+    const filter = get(terrainFieldFilter);
+    return work(
+      () => createTerrainFieldStorage(
+        edgeVertexCount,
+        maxNodesValue,
+        resources?.renderer,
+        { filter }
+      )
+    );
+  }
+).displayName("createTerrainFieldTextureTask");
 function createNormalFromElevationField(elevationFieldNode, edgeVertexCount) {
   return tsl.Fn(
     ([nodeIndex, tileSize, ix, iy, elevationScale]) => {
@@ -1280,10 +1597,10 @@ function createNormalFromElevationField(elevationFieldNode, edgeVertexCount) {
     }
   );
 }
-const normalFieldStageTask = work.task((get, work) => {
+const terrainFieldStageTask = work.task((get, work) => {
   const upstream = get(elevationFieldStageTask);
   const elevationFieldContext = get(createElevationFieldContextTask);
-  const normalFieldContext = get(createNormalFieldContextTask);
+  const terrainFieldStorage = get(createTerrainFieldTextureTask);
   const tileEdgeVertexCount = get(innerTileSegments) + 3;
   const tile = get(tileNodesTask);
   const uniforms = get(createUniformsTask);
@@ -1298,6 +1615,7 @@ const normalFieldStageTask = work.task((get, work) => {
         const ix = tsl.int(localCoordinates.x);
         const iy = tsl.int(localCoordinates.y);
         const tileSize = tile.tileSize(nodeIndex);
+        const height = elevationFieldContext.node.element(globalVertexIndex);
         const normalXZ = computeNormal(
           nodeIndex,
           tileSize,
@@ -1305,58 +1623,60 @@ const normalFieldStageTask = work.task((get, work) => {
           iy,
           uniforms.uElevationScale
         );
-        normalFieldContext.node.element(globalVertexIndex).assign(tsl.packHalf2x16(normalXZ));
+        storeTerrainField(
+          terrainFieldStorage,
+          ix,
+          iy,
+          nodeIndex,
+          packTerrainFieldSample(height, normalXZ)
+        );
       }
     ];
   });
-}).displayName("normalFieldStageTask");
+}).displayName("terrainFieldStageTask");
 
 const compileComputeTask = work.task((get, work) => {
-  const pipeline = get(normalFieldStageTask);
+  const pipeline = get(terrainFieldStageTask);
   const edgeVertexCount = get(innerTileSegments) + 3;
-  return work(() => compileComputePipeline(pipeline, edgeVertexCount));
-}).displayName("compileComputeTask");
-const executeComputeTask = work.task((get, work, { resources }) => {
-  const { execute } = get(compileComputeTask);
-  const leafState = get(leafGpuBufferTask);
   return work(
-    () => resources?.renderer ? execute(resources.renderer, leafState.count) : () => {
-    }
+    () => compileComputePipeline(pipeline, edgeVertexCount, {
+      preferSingleKernelWhenPossible: false
+    })
   );
-}).displayName("executeComputeTask").lane("gpu");
+}).displayName("compileComputeTask");
+const executeComputeTask = work.task(
+  (get, work, { resources }) => {
+    const { execute } = get(compileComputeTask);
+    const leafState = get(leafGpuBufferTask);
+    return work(
+      () => resources?.renderer ? execute(resources.renderer, leafState.count) : () => {
+      }
+    );
+  }
+).displayName("executeComputeTask").lane("gpu");
 function createComputePipelineTasks(leafStageTask) {
   const compile = work.task((get, work) => {
     const pipeline = get(leafStageTask);
     const edgeVertexCount = get(innerTileSegments) + 3;
-    return work(() => compileComputePipeline(pipeline, edgeVertexCount));
+    return work(
+      () => compileComputePipeline(pipeline, edgeVertexCount, {
+        preferSingleKernelWhenPossible: false
+      })
+    );
   }).displayName("compileComputeTask");
-  const execute = work.task((get, work, { resources }) => {
-    const { execute: run } = get(compile);
-    const leafState = get(leafGpuBufferTask);
-    return work(() => resources?.renderer ? run(resources.renderer, leafState.count) : () => {
-    });
-  }).displayName("executeComputeTask").lane("gpu");
+  const execute = work.task(
+    (get, work, { resources }) => {
+      const { execute: run } = get(compile);
+      const leafState = get(leafGpuBufferTask);
+      return work(
+        () => resources?.renderer ? run(resources.renderer, leafState.count) : () => {
+        }
+      );
+    }
+  ).displayName("executeComputeTask").lane("gpu");
   return { compile, execute };
 }
 
-const textureSpaceToVectorSpace = tsl.Fn(([value]) => {
-  return tsl.remap(value, tsl.float(0), tsl.float(1), tsl.float(-1), tsl.float(1));
-});
-const vectorSpaceToTextureSpace = tsl.Fn(([value]) => {
-  return tsl.remap(value, tsl.float(-1), tsl.float(1), tsl.float(0), tsl.float(1));
-});
-const blendAngleCorrectedNormals = tsl.Fn(([n1, n2]) => {
-  const t = tsl.vec3(n1.x, n1.y, n1.z.add(1));
-  const u = tsl.vec3(n2.x.negate(), n2.y.negate(), n2.z);
-  const r = t.mul(tsl.dot(t, u)).sub(u.mul(t.z)).normalize();
-  return r;
-});
-const deriveNormalZ = tsl.Fn(([normalXY]) => {
-  const xy = normalXY.toVar();
-  const z = xy.x.mul(xy.x).add(xy.y.mul(xy.y)).oneMinus().max(0).sqrt();
-  return tsl.vec3(xy.x, xy.y, z);
-});
-
 const isSkirtVertex = tsl.Fn(([segments]) => {
   const segmentsNode = typeof segments === "number" ? tsl.int(segments) : segments;
   const vIndex = tsl.int(tsl.vertexIndex);
@@ -1398,37 +1718,40 @@ function createTileBaseWorldPosition(leafStorage, terrainUniforms) {
     return tsl.vec3(worldX, rootOrigin.y, worldZ);
   });
 }
-function createTileElevation(terrainUniforms, elevationFieldBufferNode) {
-  if (!elevationFieldBufferNode) return tsl.float(0);
+function createTileElevation(terrainUniforms, terrainFieldStorage) {
+  if (!terrainFieldStorage) return tsl.float(0);
   const edgeVertexCount = terrainUniforms.uInnerTileSegments.add(3);
   return readElevationFieldAtPositionLocal(
-    elevationFieldBufferNode,
+    terrainFieldStorage,
     edgeVertexCount,
     tsl.positionLocal
   )().mul(
     terrainUniforms.uElevationScale
   );
 }
-function createNormalAssignment(terrainUniforms, normalFieldBufferNode) {
-  if (!normalFieldBufferNode) return;
+function createNormalAssignment(terrainUniforms, terrainFieldStorage) {
+  if (!terrainFieldStorage) return;
   const nodeIndex = tsl.int(tsl.instanceIndex);
-  const intEdge = tsl.int(terrainUniforms.uInnerTileSegments.add(3));
-  const verticesPerNode = intEdge.mul(intEdge);
-  const globalVertexIndex = nodeIndex.mul(verticesPerNode).add(tsl.int(tsl.vertexIndex));
-  const packed = normalFieldBufferNode.element(globalVertexIndex);
-  const normalXZ = tsl.unpackHalf2x16(packed);
-  const reconstructed = deriveNormalZ(normalXZ);
-  tsl.normalLocal.assign(tsl.vec3(reconstructed.x, reconstructed.z, reconstructed.y));
+  const edgeVertexCount = tsl.int(terrainUniforms.uInnerTileSegments.add(3));
+  const localVertexIndex = tsl.int(tsl.vertexIndex);
+  const ix = localVertexIndex.mod(edgeVertexCount);
+  const iy = localVertexIndex.div(edgeVertexCount);
+  const normalXZ = loadTerrainFieldNormal(terrainFieldStorage, ix, iy, nodeIndex);
+  const nx = normalXZ.x;
+  const nz = normalXZ.y;
+  const nySq = tsl.float(1).sub(nx.mul(nx)).sub(nz.mul(nz)).max(tsl.float(0));
+  const ny = nySq.sqrt();
+  tsl.normalLocal.assign(tsl.vec3(nx, ny, nz));
 }
-function createTileWorldPosition(leafStorage, terrainUniforms, elevationFieldBufferNode, normalFieldBufferNode) {
+function createTileWorldPosition(leafStorage, terrainUniforms, terrainFieldStorage) {
   const baseWorldPosition = createTileBaseWorldPosition(leafStorage, terrainUniforms);
   return tsl.Fn(() => {
     const base = baseWorldPosition();
-    const yElevation = createTileElevation(terrainUniforms, elevationFieldBufferNode);
+    const yElevation = createTileElevation(terrainUniforms, terrainFieldStorage);
     const skirtVertex = isSkirtVertex(terrainUniforms.uInnerTileSegments);
     const skirtY = base.y.add(yElevation).sub(terrainUniforms.uSkirtScale.toVar());
     const worldY = tsl.select(skirtVertex, skirtY, base.y.add(yElevation));
-    createNormalAssignment(terrainUniforms, normalFieldBufferNode);
+    createNormalAssignment(terrainUniforms, terrainFieldStorage);
     return tsl.vec3(base.x, worldY, base.z);
   })();
 }
@@ -1436,20 +1759,18 @@ function createTileWorldPosition(leafStorage, terrainUniforms, elevationFieldBuf
 const positionNodeTask = work.task((get, work) => {
   const leafStorage = get(leafStorageTask);
   const terrainUniforms = get(createUniformsTask);
-  const elevationFieldContext = get(createElevationFieldContextTask);
-  const normalFieldContext = get(createNormalFieldContextTask);
+  const terrainFieldStorage = get(createTerrainFieldTextureTask);
   return work(
     () => createTileWorldPosition(
       leafStorage,
       terrainUniforms,
-      elevationFieldContext.node,
-      normalFieldContext.node
+      terrainFieldStorage
     )
   );
 }).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(createNormalFieldContextTask).add(elevationFieldStageTask).add(normalFieldStageTask).add(compileComputeTask).add(executeComputeTask);
+  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);
 }
 const terrainTasks = {
   instanceId: instanceIdTask,
@@ -1463,13 +1784,31 @@ const terrainTasks = {
   positionNode: positionNodeTask,
   createElevationFieldContext: createElevationFieldContextTask,
   createTileNodes: tileNodesTask,
-  createNormalFieldContext: createNormalFieldContextTask,
+  createTerrainFieldTexture: createTerrainFieldTextureTask,
   elevationFieldStage: elevationFieldStageTask,
-  normalFieldStage: normalFieldStageTask,
+  terrainFieldStage: terrainFieldStageTask,
   compileCompute: compileComputeTask,
   executeCompute: executeComputeTask
 };
 
+const textureSpaceToVectorSpace = tsl.Fn(([value]) => {
+  return tsl.remap(value, tsl.float(0), tsl.float(1), tsl.float(-1), tsl.float(1));
+});
+const vectorSpaceToTextureSpace = tsl.Fn(([value]) => {
+  return tsl.remap(value, tsl.float(-1), tsl.float(1), tsl.float(0), tsl.float(1));
+});
+const blendAngleCorrectedNormals = tsl.Fn(([n1, n2]) => {
+  const t = tsl.vec3(n1.x, n1.y, n1.z.add(1));
+  const u = tsl.vec3(n2.x.negate(), n2.y.negate(), n2.z);
+  const r = t.mul(tsl.dot(t, u)).sub(u.mul(t.z)).normalize();
+  return r;
+});
+const deriveNormalZ = tsl.Fn(([normalXY]) => {
+  const xy = normalXY.toVar();
+  const z = xy.x.mul(xy.x).add(xy.y.mul(xy.y)).oneMinus().max(0).sqrt();
+  return tsl.vec3(xy.x, xy.y, z);
+});
+
 const vGlobalVertexIndex = /* @__PURE__ */ tsl.varyingProperty("int", "vGlobalVertexIndex");
 const vElevation = /* @__PURE__ */ tsl.varyingProperty("f32", "vElevation");
 
@@ -1504,9 +1843,12 @@ const voronoiCells = tsl.Fn((params) => {
   return k;
 });
 
+exports.ArrayTextureBackend = ArrayTextureBackend;
+exports.AtlasBackend = AtlasBackend;
 exports.Dir = Dir;
 exports.TerrainGeometry = TerrainGeometry;
 exports.TerrainMesh = TerrainMesh;
+exports.Texture3DBackend = Texture3DBackend;
 exports.U32_EMPTY = U32_EMPTY;
 exports.allocLeafSet = allocLeafSet;
 exports.allocSeamTable = allocSeamTable;
@@ -1520,9 +1862,10 @@ exports.createCubeSphereSurface = createCubeSphereSurface;
 exports.createElevationFieldContextTask = createElevationFieldContextTask;
 exports.createFlatSurface = createFlatSurface;
 exports.createInfiniteFlatSurface = createInfiniteFlatSurface;
-exports.createNormalFieldContextTask = createNormalFieldContextTask;
 exports.createSpatialIndex = createSpatialIndex;
 exports.createState = createState;
+exports.createTerrainFieldStorage = createTerrainFieldStorage;
+exports.createTerrainFieldTextureTask = createTerrainFieldTextureTask;
 exports.createTerrainUniforms = createTerrainUniforms;
 exports.createUniformsTask = createUniformsTask;
 exports.deriveNormalZ = deriveNormalZ;
@@ -1530,16 +1873,20 @@ exports.elevationFieldStageTask = elevationFieldStageTask;
 exports.elevationFn = elevationFn;
 exports.elevationScale = elevationScale;
 exports.executeComputeTask = executeComputeTask;
+exports.getDeviceComputeLimits = getDeviceComputeLimits;
 exports.innerTileSegments = innerTileSegments;
 exports.instanceIdTask = instanceIdTask;
 exports.isSkirtUV = isSkirtUV;
 exports.isSkirtVertex = isSkirtVertex;
 exports.leafGpuBufferTask = leafGpuBufferTask;
 exports.leafStorageTask = leafStorageTask;
+exports.loadTerrainField = loadTerrainField;
+exports.loadTerrainFieldElevation = loadTerrainFieldElevation;
+exports.loadTerrainFieldNormal = loadTerrainFieldNormal;
 exports.maxLevel = maxLevel;
 exports.maxNodes = maxNodes;
-exports.normalFieldStageTask = normalFieldStageTask;
 exports.origin = origin;
+exports.packTerrainFieldSample = packTerrainFieldSample;
 exports.positionNodeTask = positionNodeTask;
 exports.quadtreeConfigTask = quadtreeConfigTask;
 exports.quadtreeUpdate = quadtreeUpdate;
@@ -1547,9 +1894,15 @@ exports.quadtreeUpdateTask = quadtreeUpdateTask;
 exports.resetLeafSet = resetLeafSet;
 exports.resetSeamTable = resetSeamTable;
 exports.rootSize = rootSize;
+exports.sampleTerrainField = sampleTerrainField;
+exports.sampleTerrainFieldElevation = sampleTerrainFieldElevation;
+exports.sampleTerrainFieldNormal = sampleTerrainFieldNormal;
 exports.skirtScale = skirtScale;
+exports.storeTerrainField = storeTerrainField;
 exports.surface = surface;
 exports.surfaceTask = surfaceTask;
+exports.terrainFieldFilter = terrainFieldFilter;
+exports.terrainFieldStageTask = terrainFieldStageTask;
 exports.terrainGraph = terrainGraph;
 exports.terrainTasks = terrainTasks;
 exports.textureSpaceToVectorSpace = textureSpaceToVectorSpace;