@hello-terrain/three 0.0.0-alpha.3 → 0.0.0-alpha.5

package/dist/index.cjs

@@ -1,49 +1,30 @@
 'use strict';
 
-const THREE = require('three');
+const three = require('three');
+const webgpu = require('three/webgpu');
+const work = require('@hello-terrain/work');
 const tsl = require('three/tsl');
+const TSL_js = require('three/src/nodes/TSL.js');
 
-function _interopNamespaceCompat(e) {
-  if (e && typeof e === 'object' && 'default' in e) return e;
-  const n = Object.create(null);
-  if (e) {
-    for (const k in e) {
-      n[k] = e[k];
-    }
-  }
-  n.default = e;
-  return n;
-}
-
-const THREE__namespace = /*#__PURE__*/_interopNamespaceCompat(THREE);
-
-class TerrainGeometry extends THREE.BufferGeometry {
+class TerrainGeometry extends three.BufferGeometry {
   constructor(innerSegments = 14, extendUV = false) {
     super();
     if (innerSegments < 1 || !Number.isFinite(innerSegments) || !Number.isInteger(innerSegments)) {
-      throw new Error(
-        `Invalid innerSegments: ${innerSegments}. Must be a positive integer.`
-      );
+      throw new Error(`Invalid innerSegments: ${innerSegments}. Must be a positive integer.`);
     }
     try {
       this.setIndex(this.generateIndices(innerSegments));
       this.setAttribute(
         "position",
-        new THREE.BufferAttribute(
-          new Float32Array(this.generatePositions(innerSegments)),
-          3
-        )
+        new three.BufferAttribute(new Float32Array(this.generatePositions(innerSegments)), 3)
       );
       this.setAttribute(
         "normal",
-        new THREE.BufferAttribute(
-          new Float32Array(this.generateNormals(innerSegments)),
-          3
-        )
+        new three.BufferAttribute(new Float32Array(this.generateNormals(innerSegments)), 3)
       );
       this.setAttribute(
         "uv",
-        new THREE.BufferAttribute(
+        new three.BufferAttribute(
           new Float32Array(
             extendUV ? this.generateUvsExtended(innerSegments) : this.generateUvsOnlyInner(innerSegments)
           ),
@@ -229,507 +210,1343 @@ class TerrainGeometry extends THREE.BufferGeometry {
   }
 }
 
-const isSkirtVertex = tsl.Fn(([segments]) => {
-  const segmentsNode = typeof segments === "number" ? tsl.int(segments) : segments;
-  const vIndex = tsl.int(tsl.vertexIndex);
-  const segmentEdges = tsl.int(segmentsNode.add(3));
-  const vx = vIndex.mod(segmentEdges);
-  const vy = vIndex.div(segmentEdges);
-  const last = segmentEdges.sub(tsl.int(1));
-  return vx.equal(tsl.int(0)).or(vx.equal(last)).or(vy.equal(tsl.int(0))).or(vy.equal(last));
-});
-const isSkirtUV = tsl.Fn(([segments]) => {
-  const segmentsNode = typeof segments === "number" ? tsl.int(segments) : segments;
-  const ux = tsl.uv().x;
-  const uy = tsl.uv().y;
-  const segmentCount = segmentsNode.add(2);
-  const segmentStep = tsl.float(1).div(segmentCount);
-  const innerX = ux.greaterThan(segmentStep).and(ux.lessThan(segmentStep.oneMinus()));
-  const innerY = uy.greaterThan(segmentStep).and(uy.lessThan(segmentStep.oneMinus()));
-  return innerX.and(innerY).not();
-});
-
-const CHILDREN_STRIDE = 4;
-const NEIGHBORS_STRIDE = 4;
-const NODE_STRIDE = 4;
-const U_INT_16_MAX_VALUE = 65535;
-const EMPTY_SENTINEL_VALUE = U_INT_16_MAX_VALUE;
-class QuadtreeNodeView {
-  maxNodeCount;
-  childrenIndicesBuffer;
-  neighborsIndicesBuffer;
-  nodeBuffer;
-  leafNodeMask;
-  leafNodeCountBuffer;
-  activeLeafIndices;
-  activeLeafCount = 0;
-  constructor(maxNodeCount, childrenIndicesBuffer, neighborsIndicesBuffer, nodeBuffer, leafNodeMask, leafNodeCountBuffer) {
-    this.maxNodeCount = maxNodeCount;
-    this.childrenIndicesBuffer = childrenIndicesBuffer ?? new Uint16Array(CHILDREN_STRIDE * maxNodeCount);
-    this.neighborsIndicesBuffer = neighborsIndicesBuffer ?? new Uint16Array(NEIGHBORS_STRIDE * maxNodeCount);
-    this.nodeBuffer = nodeBuffer ?? new Int32Array(NODE_STRIDE * maxNodeCount);
-    this.leafNodeMask = leafNodeMask ?? new Uint8Array(maxNodeCount);
-    this.leafNodeCountBuffer = leafNodeCountBuffer ?? new Uint16Array(1);
-    this.activeLeafIndices = new Uint16Array(maxNodeCount);
-    this.clear();
+const defaultTerrainMeshParams = {
+  innerTileSegments: 14,
+  maxNodes: 1024,
+  material: new webgpu.MeshStandardNodeMaterial()
+};
+class TerrainMesh extends webgpu.InstancedMesh {
+  _innerTileSegments;
+  _maxNodes;
+  constructor(params = defaultTerrainMeshParams) {
+    const mergedParams = { ...defaultTerrainMeshParams, ...params };
+    const { innerTileSegments, maxNodes, material } = mergedParams;
+    const geometry = new TerrainGeometry(innerTileSegments, true);
+    super(geometry, material, maxNodes);
+    this.frustumCulled = false;
+    this._innerTileSegments = innerTileSegments;
+    this._maxNodes = maxNodes;
   }
-  /**
-   * Clear all buffers
-   */
-  clear() {
-    this.nodeBuffer.fill(0);
-    this.childrenIndicesBuffer.fill(EMPTY_SENTINEL_VALUE);
-    this.neighborsIndicesBuffer.fill(EMPTY_SENTINEL_VALUE);
-    this.leafNodeMask.fill(0);
-    this.leafNodeCountBuffer[0] = 0;
-    this.activeLeafCount = 0;
+  get innerTileSegments() {
+    return this._innerTileSegments;
   }
-  /**
-   * Get buffer references for direct access (useful for GPU operations)
-   */
-  getBuffers() {
-    return {
-      childrenIndicesBuffer: this.childrenIndicesBuffer,
-      neighborsIndicesBuffer: this.neighborsIndicesBuffer,
-      nodeBuffer: this.nodeBuffer,
-      leafNodeMask: this.leafNodeMask
-    };
+  set innerTileSegments(tileSegments) {
+    const oldGeometry = this.geometry;
+    this.geometry = new TerrainGeometry(tileSegments, true);
+    this._innerTileSegments = tileSegments;
+    setTimeout(oldGeometry.dispose);
   }
-  /**
-   * Get the maximum node count
-   */
-  getMaxNodeCount() {
-    return this.maxNodeCount;
-  }
-  // Getters for individual buffer values
-  getLevel(index) {
-    return this.nodeBuffer[index * NODE_STRIDE];
-  }
-  getX(index) {
-    return this.nodeBuffer[index * NODE_STRIDE + 1];
-  }
-  getY(index) {
-    return this.nodeBuffer[index * NODE_STRIDE + 2];
-  }
-  getLeafNodeCount() {
-    return this.leafNodeCountBuffer[0];
-  }
-  getLeaf(index) {
-    return this.leafNodeMask[index] === 1;
-  }
-  getChildren(index) {
-    const offset = index * CHILDREN_STRIDE;
-    return [
-      this.childrenIndicesBuffer[offset],
-      this.childrenIndicesBuffer[offset + 1],
-      this.childrenIndicesBuffer[offset + 2],
-      this.childrenIndicesBuffer[offset + 3]
-    ];
+  get maxNodes() {
+    return this._maxNodes;
   }
-  getNeighbors(index) {
-    const offset = index * NEIGHBORS_STRIDE;
-    return [
-      this.neighborsIndicesBuffer[offset],
-      this.neighborsIndicesBuffer[offset + 1],
-      this.neighborsIndicesBuffer[offset + 2],
-      this.neighborsIndicesBuffer[offset + 3]
-    ];
-  }
-  // Setters for individual buffer values
-  setLevel(index, level) {
-    this.nodeBuffer[index * NODE_STRIDE] = level;
-  }
-  setX(index, x) {
-    this.nodeBuffer[index * NODE_STRIDE + 1] = x;
-  }
-  setY(index, y) {
-    this.nodeBuffer[index * NODE_STRIDE + 2] = y;
-  }
-  setLeaf(index, leaf) {
-    const wasLeaf = this.leafNodeMask[index] === 1;
-    const newValue = leaf ? 1 : 0;
-    if (leaf && !wasLeaf) {
-      this.leafNodeCountBuffer[0]++;
-      this.leafNodeMask[index] = 1;
-      this.activeLeafIndices[this.activeLeafCount] = index;
-      this.activeLeafCount++;
-      this.setChildren(index, [
-        EMPTY_SENTINEL_VALUE,
-        EMPTY_SENTINEL_VALUE,
-        EMPTY_SENTINEL_VALUE,
-        EMPTY_SENTINEL_VALUE
-      ]);
-    } else if (!leaf && wasLeaf) {
-      this.leafNodeCountBuffer[0]--;
-      this.leafNodeMask[index] = 0;
+  set maxNodes(maxNodes) {
+    if (!Number.isInteger(maxNodes) || maxNodes < 1) {
+      throw new Error(`Invalid maxNodes: ${maxNodes}. Must be a positive integer.`);
+    }
+    if (maxNodes === this._maxNodes) return;
+    const oldMax = this._maxNodes;
+    const nextMatrix = new Float32Array(maxNodes * 16);
+    const oldMatrixArray = this.instanceMatrix.array;
+    nextMatrix.set(oldMatrixArray.subarray(0, Math.min(oldMatrixArray.length, nextMatrix.length)));
+    this.instanceMatrix = new webgpu.InstancedBufferAttribute(nextMatrix, 16);
+    if (this.instanceColor) {
+      const itemSize = this.instanceColor.itemSize;
+      const nextColor = new Float32Array(maxNodes * itemSize);
+      const oldColorArray = this.instanceColor.array;
+      nextColor.set(oldColorArray.subarray(0, Math.min(oldColorArray.length, nextColor.length)));
+      this.instanceColor = new webgpu.InstancedBufferAttribute(nextColor, itemSize);
+    }
+    this._maxNodes = maxNodes;
+    this.count = Math.min(this.count, maxNodes);
+    this.instanceMatrix.needsUpdate = true;
+    if (this.instanceColor) this.instanceColor.needsUpdate = true;
+    if (maxNodes < oldMax && this.count >= maxNodes) {
+      this.count = maxNodes;
     }
-    this.nodeBuffer[index * NODE_STRIDE + 3] = newValue;
-  }
-  setChildren(index, children) {
-    const offset = index * CHILDREN_STRIDE;
-    this.childrenIndicesBuffer[offset] = children[0];
-    this.childrenIndicesBuffer[offset + 1] = children[1];
-    this.childrenIndicesBuffer[offset + 2] = children[2];
-    this.childrenIndicesBuffer[offset + 3] = children[3];
-  }
-  setNeighbors(index, neighbors) {
-    const offset = index * NEIGHBORS_STRIDE;
-    this.neighborsIndicesBuffer[offset] = neighbors[0];
-    this.neighborsIndicesBuffer[offset + 1] = neighbors[1];
-    this.neighborsIndicesBuffer[offset + 2] = neighbors[2];
-    this.neighborsIndicesBuffer[offset + 3] = neighbors[3];
-  }
-  /**
-   * Get array of active leaf node indices with count (zero-copy, no allocation)
-   */
-  getActiveLeafNodeIndices() {
-    return {
-      indices: this.activeLeafIndices,
-      count: this.activeLeafCount
-    };
   }
-  /**
-   * Release internal buffers and mark this view as destroyed
-   */
-  destroy() {
-    this.childrenIndicesBuffer = new Uint16Array(0);
-    this.neighborsIndicesBuffer = new Uint16Array(0);
-    this.nodeBuffer = new Int32Array(0);
-    this.leafNodeMask = new Uint8Array(0);
-    this.leafNodeCountBuffer = new Uint16Array(0);
-    this.maxNodeCount = 0;
+}
+
+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);
+  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();
+      }
+      tsl.If(inBounds, () => {
+        stages[i](nodeIndex, globalIndex, localUVCoords, localCoordinates, texelSize);
+      });
+    }
+  })().computeKernel(workgroupSize);
+  function execute(renderer, instanceCount) {
+    uInstanceCount.value = instanceCount;
+    renderer.compute(computeShader, [dispatchX, dispatchY, instanceCount]);
   }
-  clone() {
-    return new QuadtreeNodeView(
-      this.maxNodeCount,
-      this.childrenIndicesBuffer,
-      this.neighborsIndicesBuffer,
-      this.nodeBuffer,
-      this.leafNodeMask,
-      this.leafNodeCountBuffer
+  return { execute };
+}
+
+const createElevation = (tile, uniforms, elevationFn) => {
+  return function perVertexElevation(nodeIndex, localCoordinates) {
+    const ix = tsl.int(localCoordinates.x);
+    const iy = tsl.int(localCoordinates.y);
+    const edgeVertexCount = uniforms.uInnerTileSegments.toVar().add(tsl.int(3));
+    const tileUV = localCoordinates.toFloat().div(edgeVertexCount.toFloat());
+    const rootUV = tile.rootUVCompute(nodeIndex, ix, iy);
+    const worldPosition = tile.tileVertexWorldPositionCompute(nodeIndex, ix, iy).setName("worldPositionWithSkirt");
+    const rootSize = uniforms.uRootSize.toVar();
+    return elevationFn({
+      worldPosition,
+      rootSize,
+      rootUV,
+      tileOriginVec2: tile.tileOriginVec2(nodeIndex),
+      tileSize: tile.tileSize(nodeIndex),
+      tileLevel: tile.tileLevel(nodeIndex),
+      nodeIndex: tsl.int(nodeIndex),
+      tileUV
+    });
+  };
+};
+const readElevationFieldAtPositionLocal = (elevationFieldBuffer, 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);
+  const verticesPerNode = intEdge.mul(intEdge);
+  const perNodeVertexIndex = yClamped.mul(intEdge).add(xClamped);
+  const globalVertexIndex = nodeIndex.mul(verticesPerNode).add(perNodeVertexIndex);
+  return elevationFieldBuffer.element(globalVertexIndex);
+});
+
+function createTileCompute(leafStorage, uniforms) {
+  const tileLevel = tsl.Fn(([nodeIndex]) => {
+    const nodeOffset = nodeIndex.mul(tsl.int(4));
+    return leafStorage.node.element(nodeOffset).toInt();
+  });
+  const tileOriginVec2 = tsl.Fn(([nodeIndex]) => {
+    const nodeOffset = nodeIndex.mul(tsl.int(4));
+    const nodeX = leafStorage.node.element(nodeOffset.add(tsl.int(1))).toFloat();
+    const nodeY = leafStorage.node.element(nodeOffset.add(tsl.int(2))).toFloat();
+    return tsl.vec2(nodeX, nodeY);
+  });
+  const tileSize = tsl.Fn(([nodeIndex]) => {
+    const rootSize = uniforms.uRootSize.toVar();
+    const level = tileLevel(nodeIndex);
+    return tsl.float(rootSize).div(tsl.pow(tsl.float(2), level.toFloat()));
+  });
+  const rootUVCompute = tsl.Fn(([nodeIndex, ix, iy]) => {
+    const nodeVec2 = tileOriginVec2(nodeIndex);
+    const nodeX = nodeVec2.x;
+    const nodeY = nodeVec2.y;
+    const rootSize = uniforms.uRootSize.toVar();
+    const rootOrigin = uniforms.uRootOrigin.toVar();
+    const size = tileSize(nodeIndex);
+    const half = tsl.float(0.5);
+    const halfRoot = tsl.float(rootSize).mul(half);
+    const fInnerSegments = uniforms.uInnerTileSegments.toVar().toFloat();
+    const texelSpacing = size.div(fInnerSegments);
+    const absX = nodeX.mul(fInnerSegments).add(tsl.int(ix).toFloat().sub(tsl.float(1)));
+    const absY = nodeY.mul(fInnerSegments).add(tsl.int(iy).toFloat().sub(tsl.float(1)));
+    const worldX = rootOrigin.x.add(absX.mul(texelSpacing)).sub(halfRoot);
+    const worldZ = rootOrigin.z.add(absY.mul(texelSpacing)).sub(halfRoot);
+    const centeredX = worldX.sub(rootOrigin.x);
+    const centeredZ = worldZ.sub(rootOrigin.z);
+    return tsl.vec2(
+      centeredX.div(rootSize).add(half),
+      centeredZ.div(rootSize).mul(tsl.float(-1)).add(half)
     );
+  });
+  const tileVertexWorldPositionCompute = tsl.Fn(
+    ([nodeIndex, ix, iy]) => {
+      const rootOrigin = uniforms.uRootOrigin.toVar();
+      const nodeVec2 = tileOriginVec2(nodeIndex);
+      const nodeX = nodeVec2.x;
+      const nodeY = nodeVec2.y;
+      const rootSize = uniforms.uRootSize.toVar();
+      const size = tileSize(nodeIndex);
+      const half = tsl.float(0.5);
+      const halfRoot = tsl.float(rootSize).mul(half);
+      const fInnerSegments = uniforms.uInnerTileSegments.toVar().toFloat();
+      const texelSpacing = size.div(fInnerSegments);
+      const absX = nodeX.mul(fInnerSegments).add(tsl.int(ix).toFloat().sub(tsl.float(1)));
+      const absY = nodeY.mul(fInnerSegments).add(tsl.int(iy).toFloat().sub(tsl.float(1)));
+      const worldX = rootOrigin.x.add(absX.mul(texelSpacing)).sub(halfRoot);
+      const worldZ = rootOrigin.z.add(absY.mul(texelSpacing)).sub(halfRoot);
+      return tsl.vec3(worldX, rootOrigin.y, worldZ);
+    }
+  );
+  return {
+    tileLevel,
+    tileOriginVec2,
+    tileSize,
+    rootUVCompute,
+    tileVertexWorldPositionCompute
+  };
+}
+
+const rootSize = work.param(256).displayName("rootSize");
+const origin = work.param({
+  x: 0,
+  y: 0,
+  z: 0
+}).displayName("origin");
+const innerTileSegments = work.param(13).displayName("innerTileSegments");
+const skirtScale = work.param(100).displayName("skirtScale");
+const elevationScale = work.param(1).displayName("elevationScale");
+const maxNodes = work.param(1024).displayName("maxNodes");
+const maxLevel = work.param(16).displayName("maxLevel");
+const quadtreeUpdate = work.param({
+  cameraOrigin: { x: 0, y: 0, z: 0 },
+  mode: "distance",
+  distanceFactor: 1.5
+}).displayName("quadtreeUpdate");
+const surface = work.param(null).displayName("surface");
+const elevationFn = work.param(() => tsl.float(0));
+
+function createLeafStorage(maxNodes) {
+  const data = new Int32Array(maxNodes * 4);
+  const attribute = new webgpu.StorageBufferAttribute(data, 4);
+  const node = tsl.storage(attribute, "i32", 1).toReadOnly().setName("leafStorage");
+  return { data, attribute, node };
+}
+
+const Dir = {
+  LEFT: 0,
+  RIGHT: 1,
+  TOP: 2,
+  BOTTOM: 3
+};
+const U32_EMPTY = 4294967295;
+function allocLeafSet(capacity) {
+  return {
+    capacity,
+    count: 0,
+    space: new Uint8Array(capacity),
+    level: new Uint8Array(capacity),
+    x: new Int32Array(capacity),
+    y: new Int32Array(capacity)
+  };
+}
+function resetLeafSet(leaves) {
+  leaves.count = 0;
+}
+function allocSeamTable(capacity) {
+  return {
+    capacity,
+    count: 0,
+    stride: 8,
+    neighbors: new Uint32Array(capacity * 8)
+  };
+}
+function resetSeamTable(seams) {
+  seams.count = 0;
+}
+
+function createNodeStore(maxNodes, spaceCount) {
+  return {
+    maxNodes,
+    nodesUsed: 0,
+    currentGen: 1,
+    gen: new Uint16Array(maxNodes),
+    space: new Uint8Array(maxNodes),
+    level: new Uint8Array(maxNodes),
+    x: new Int32Array(maxNodes),
+    y: new Int32Array(maxNodes),
+    firstChild: new Uint32Array(maxNodes),
+    flags: new Uint8Array(maxNodes),
+    roots: new Uint32Array(spaceCount)
+  };
+}
+function beginFrame(store) {
+  store.nodesUsed = 0;
+  store.currentGen = store.currentGen + 1 & 65535;
+  if (store.currentGen === 0) {
+    store.gen.fill(0);
+    store.currentGen = 1;
   }
 }
+function allocNode(store, tile) {
+  const id = store.nodesUsed;
+  if (id >= store.maxNodes) return U32_EMPTY;
+  store.nodesUsed = id + 1;
+  store.gen[id] = store.currentGen;
+  store.space[id] = tile.space;
+  store.level[id] = tile.level;
+  store.x[id] = tile.x;
+  store.y[id] = tile.y;
+  store.firstChild[id] = U32_EMPTY;
+  store.flags[id] = 0;
+  return id;
+}
+function hasChildren(store, nodeId) {
+  return store.firstChild[nodeId] !== U32_EMPTY;
+}
+function ensureChildren(store, parentId) {
+  const existing = store.firstChild[parentId];
+  if (existing !== U32_EMPTY) return existing;
+  const childBase = store.nodesUsed;
+  if (childBase + 4 > store.maxNodes) return U32_EMPTY;
+  const space = store.space[parentId];
+  const level = store.level[parentId] + 1;
+  const px = store.x[parentId] << 1;
+  const py = store.y[parentId] << 1;
+  allocNode(store, { space, level, x: px, y: py });
+  allocNode(store, { space, level, x: px + 1, y: py });
+  allocNode(store, { space, level, x: px, y: py + 1 });
+  allocNode(store, { space, level, x: px + 1, y: py + 1 });
+  store.firstChild[parentId] = childBase;
+  return childBase;
+}
 
-function distanceBasedSubdivision(factor = 2) {
-  return (ctx) => {
-    if (ctx.nodeSize <= ctx.minNodeSize) {
-      return false;
-    }
-    return ctx.distance < ctx.nodeSize * factor;
+function nextPow2(n) {
+  let x = 1;
+  while (x < n) x <<= 1;
+  return x;
+}
+function mix32(x) {
+  x >>>= 0;
+  x ^= x >>> 16;
+  x = Math.imul(x, 2146121005) >>> 0;
+  x ^= x >>> 15;
+  x = Math.imul(x, 2221713035) >>> 0;
+  x ^= x >>> 16;
+  return x >>> 0;
+}
+function hashKey(space, level, x, y) {
+  const h = space & 255 ^ (level & 255) << 8 ^ mix32(x) >>> 0 ^ mix32(y) >>> 0;
+  return mix32(h);
+}
+function createSpatialIndex(maxEntries) {
+  const size = nextPow2(Math.max(2, maxEntries * 2));
+  return {
+    size,
+    mask: size - 1,
+    stampGen: 1,
+    stamp: new Uint16Array(size),
+    keysSpace: new Uint8Array(size),
+    keysLevel: new Uint8Array(size),
+    keysX: new Uint32Array(size),
+    keysY: new Uint32Array(size),
+    values: new Uint32Array(size)
   };
 }
-function screenSpaceSubdivision(options) {
-  const targetTrianglePixels = options.targetTrianglePixels ?? 6;
-  const tileSegments = options.tileSegments ?? 13;
-  return (ctx) => {
-    if (ctx.nodeSize <= ctx.minNodeSize) {
-      return false;
+function resetSpatialIndex(index) {
+  index.stampGen = index.stampGen + 1 & 65535;
+  if (index.stampGen === 0) {
+    index.stamp.fill(0);
+    index.stampGen = 1;
+  }
+}
+function insertSpatialIndexRaw(index, space, level, x, y, value) {
+  const s = space & 255;
+  const l = level & 255;
+  const xx = x >>> 0;
+  const yy = y >>> 0;
+  let slot = hashKey(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;
+      index.keysSpace[slot] = s;
+      index.keysLevel[slot] = l;
+      index.keysX[slot] = xx;
+      index.keysY[slot] = yy;
+      index.values[slot] = value >>> 0;
+      return;
+    }
+    if (index.keysSpace[slot] === s && index.keysLevel[slot] === l && index.keysX[slot] === xx && index.keysY[slot] === yy) {
+      index.values[slot] = value >>> 0;
+      return;
     }
-    const screenInfo = options.getScreenSpaceInfo();
-    if (!screenInfo) {
-      return ctx.distance < ctx.nodeSize * 2;
+    slot = slot + 1 & index.mask;
+  }
+  throw new Error("SpatialIndex is full (no empty slot found).");
+}
+function lookupSpatialIndexRaw(index, space, level, x, y) {
+  const s = space & 255;
+  const l = level & 255;
+  const xx = x >>> 0;
+  const yy = y >>> 0;
+  let slot = hashKey(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) {
+      return index.values[slot];
     }
-    const safeDistance = Math.max(ctx.distance, 1e-3);
-    const tileScreenSize = ctx.nodeSize / safeDistance * screenInfo.projectionFactor;
-    const triangleScreenSize = tileScreenSize / tileSegments;
-    return triangleScreenSize > targetTrianglePixels;
+    slot = slot + 1 & index.mask;
+  }
+  return U32_EMPTY;
+}
+
+function buildLeafIndex(leaves, out) {
+  const index = out ?? createSpatialIndex(leaves.count);
+  resetSpatialIndex(index);
+  for (let i = 0; i < leaves.count; i++) {
+    insertSpatialIndexRaw(index, leaves.space[i], leaves.level[i], leaves.x[i], leaves.y[i], i);
+  }
+  return index;
+}
+
+function createState(cfg, surface) {
+  const store = createNodeStore(cfg.maxNodes, surface.spaceCount);
+  const scratchRootTiles = [];
+  for (let i = 0; i < surface.maxRootCount; i++) {
+    scratchRootTiles.push({ space: 0, level: 0, x: 0, y: 0 });
+  }
+  return {
+    cfg,
+    store,
+    leaves: allocLeafSet(cfg.maxNodes),
+    leafNodeIds: new Uint32Array(cfg.maxNodes),
+    leafIndex: createSpatialIndex(cfg.maxNodes),
+    stack: new Uint32Array(cfg.maxNodes),
+    rootNodeIds: new Uint32Array(surface.maxRootCount),
+    rootCount: 0,
+    splitQueue: new Uint32Array(cfg.maxNodes),
+    splitStamp: new Uint16Array(cfg.maxNodes),
+    splitGen: 1,
+    scratchTile: { space: 0, level: 0, x: 0, y: 0 },
+    scratchNeighbor: { space: 0, level: 0, x: 0, y: 0 },
+    scratchBounds: { cx: 0, cy: 0, cz: 0, r: 0 },
+    scratchRootTiles,
+    spaceCount: surface.spaceCount
   };
 }
-function computeScreenSpaceInfo(fovY, screenHeight) {
-  const projectionFactor = screenHeight / (2 * Math.tan(fovY / 2));
-  return { projectionFactor, screenHeight };
-}
-
-const tempVector3 = new THREE__namespace.Vector3();
-const tempBox3 = new THREE__namespace.Box3();
-const tempMin = new THREE__namespace.Vector3();
-const tempMax = new THREE__namespace.Vector3();
-class Quadtree {
-  nodeCount = 0;
-  deepestLevel = 0;
-  config;
-  nodeView;
-  subdivisionStrategy;
-  // Pre-allocated buffers to avoid object creation
-  tempChildIndices = [-1, -1, -1, -1];
-  tempNeighborIndices = [-1, -1, -1, -1];
-  /**
-   * Create a new Quadtree.
-   *
-   * @param config Quadtree configuration parameters
-   * @param subdivisionStrategy Strategy function for subdivision decisions.
-   *        Defaults to distanceBasedSubdivision(2).
-   * @param nodeView Optional pre-allocated NodeView for buffer reuse
-   */
-  constructor(config, subdivisionStrategy, nodeView) {
-    this.config = config;
-    this.subdivisionStrategy = subdivisionStrategy ?? distanceBasedSubdivision(2);
-    this.nodeView = nodeView ?? new QuadtreeNodeView(config.maxNodes);
-    this.initialize();
+function beginUpdate(state, surface, params) {
+  if (surface.spaceCount !== state.spaceCount) {
+    throw new Error(
+      `Surface spaceCount changed (${state.spaceCount} -> ${surface.spaceCount}). Create a new quadtree state.`
+    );
   }
-  /**
-   * Set the subdivision strategy.
-   * Use this to change LOD behavior at runtime.
-   *
-   * @param strategy The subdivision strategy function
-   */
-  setSubdivisionStrategy(strategy) {
-    this.subdivisionStrategy = strategy;
+  if (surface.maxRootCount !== state.rootNodeIds.length) {
+    throw new Error(
+      `Surface maxRootCount changed (${state.rootNodeIds.length} -> ${surface.maxRootCount}). Create a new quadtree state.`
+    );
   }
-  /**
-   * Get the current subdivision strategy
-   */
-  getSubdivisionStrategy() {
-    return this.subdivisionStrategy;
+  beginFrame(state.store);
+  state.rootCount = 0;
+  const rootCount = surface.rootTiles(params.cameraOrigin, state.scratchRootTiles);
+  if (rootCount < 0 || rootCount > surface.maxRootCount) {
+    throw new Error(`Surface returned invalid root count (${rootCount}).`);
   }
-  initialize() {
-    this.nodeView.clear();
-    this.nodeCount = 0;
-    this.deepestLevel = 0;
-    this.createNode(0, 0, 0);
+  for (let i = 0; i < rootCount; i++) {
+    const rootId = allocNode(state.store, state.scratchRootTiles[i]);
+    if (rootId === U32_EMPTY) {
+      throw new Error("Failed to allocate root node (maxNodes too small).");
+    }
+    state.rootNodeIds[i] = rootId;
+    state.rootCount = i + 1;
   }
-  /**
-   * Update the quadtree based on the given position and return the index
-   * of the leaf node that best corresponds to the position (closest leaf).
-   */
-  update(position, frustum) {
-    this.reset();
-    const closestLeafIndex = this.updateNode(0, position, frustum);
-    return closestLeafIndex;
+}
+
+function shouldSplit(bounds, level, maxLevel, params) {
+  if (level >= maxLevel) return false;
+  const mode = params.mode ?? "distance";
+  const cx = bounds.cx;
+  const cy = bounds.cy;
+  const cz = bounds.cz;
+  const distSq = cx * cx + cy * cy + cz * cz;
+  const safeDistSq = distSq > 1e-12 ? distSq : 1e-12;
+  if (mode === "screen") {
+    const proj = params.projectionFactor ?? 0;
+    const target = params.targetPixels ?? 0;
+    if (proj <= 0 || target <= 0) {
+      const f2 = params.distanceFactor ?? 2;
+      const threshold2 = bounds.r * f2;
+      return safeDistSq < threshold2 * threshold2;
+    }
+    const left = bounds.r * bounds.r * proj * proj;
+    const right = safeDistSq * target * target;
+    return left > right;
   }
-  /**
-   * Recursively update a node and its children based on distance and size criteria
-   * and return the closest leaf node index to the provided position.
-   */
-  updateNode(nodeIndex, position, frustum) {
-    const level = this.nodeView.getLevel(nodeIndex);
-    const nodeSize = this.config.rootSize / (1 << level);
-    const nodeX = this.nodeView.getX(nodeIndex);
-    const nodeY = this.nodeView.getY(nodeIndex);
-    const minX = this.config.origin.x + (nodeX * nodeSize - 0.5 * this.config.rootSize);
-    const minZ = this.config.origin.z + (nodeY * nodeSize - 0.5 * this.config.rootSize);
-    const worldX = minX + 0.5 * nodeSize;
-    const worldZ = minZ + 0.5 * nodeSize;
-    if (frustum) {
-      const altitude = Math.abs(position.y - this.config.origin.y);
-      const verticalHalfExtent = this.config.rootSize + altitude;
-      const minY = this.config.origin.y - verticalHalfExtent;
-      const maxY = this.config.origin.y + verticalHalfExtent;
-      tempMin.set(minX, minY, minZ);
-      tempMax.set(minX + nodeSize, maxY, minZ + nodeSize);
-      tempBox3.set(tempMin, tempMax);
-      if (!frustum.intersectsBox(tempBox3)) {
-        this.nodeView.setLeaf(nodeIndex, false);
-        return -1;
-      }
+  const f = params.distanceFactor ?? 2;
+  const threshold = bounds.r * f;
+  return safeDistSq < threshold * threshold;
+}
+
+function refineLeaves(state, surface, params, outLeaves) {
+  const leaves = outLeaves ?? state.leaves;
+  resetLeafSet(leaves);
+  const store = state.store;
+  const stack = state.stack;
+  let sp = 0;
+  for (let i = 0; i < state.rootCount; i++) {
+    stack[sp++] = state.rootNodeIds[i];
+  }
+  while (sp > 0) {
+    const nodeId = stack[--sp];
+    const level = store.level[nodeId];
+    const space = store.space[nodeId];
+    const x = store.x[nodeId];
+    const y = store.y[nodeId];
+    const tile = state.scratchTile;
+    tile.space = space;
+    tile.level = level;
+    tile.x = x;
+    tile.y = y;
+    const bounds = state.scratchBounds;
+    surface.tileBounds(tile, params.cameraOrigin, bounds);
+    if (hasChildren(store, nodeId)) {
+      const base = store.firstChild[nodeId];
+      stack[sp++] = base + 3;
+      stack[sp++] = base + 2;
+      stack[sp++] = base + 1;
+      stack[sp++] = base + 0;
+      continue;
     }
-    tempVector3.set(worldX, this.config.origin.y, worldZ);
-    const distance = position.distanceTo(tempVector3);
-    const shouldSubdivide = this.shouldSubdivide(level, distance, nodeSize);
-    if (shouldSubdivide && level < this.config.maxLevel) {
-      if (this.nodeCount + 4 > this.config.maxNodes) {
-        this.nodeView.setLeaf(nodeIndex, true);
-        return nodeIndex;
+    const split = shouldSplit(bounds, level, state.cfg.maxLevel, params);
+    if (split) {
+      const base = ensureChildren(store, nodeId);
+      if (base !== U32_EMPTY) {
+        stack[sp++] = base + 3;
+        stack[sp++] = base + 2;
+        stack[sp++] = base + 1;
+        stack[sp++] = base + 0;
+        continue;
       }
-      this.subdivideNode(nodeIndex);
-      const children = this.nodeView.getChildren(nodeIndex);
-      let bestLeafIndex = -1;
-      let bestDistSq = Number.POSITIVE_INFINITY;
-      for (let i = 0; i < 4; i++) {
-        if (children[i] !== -1) {
-          const leafIdx = this.updateNode(children[i], position, frustum);
-          if (leafIdx !== -1) {
-            const leafLevel = this.nodeView.getLevel(leafIdx);
-            const size = this.config.rootSize / (1 << leafLevel);
-            const x = this.nodeView.getX(leafIdx);
-            const y = this.nodeView.getY(leafIdx);
-            const cx = this.config.origin.x + ((x + 0.5) * size - 0.5 * this.config.rootSize);
-            const cz = this.config.origin.z + ((y + 0.5) * size - 0.5 * this.config.rootSize);
-            const dx = position.x - cx;
-            const dz = position.z - cz;
-            const d2 = dx * dx + dz * dz;
-            if (d2 < bestDistSq) {
-              bestDistSq = d2;
-              bestLeafIndex = leafIdx;
-            }
+    }
+    const i = leaves.count;
+    if (i >= leaves.capacity) {
+      throw new Error("LeafSet capacity exceeded.");
+    }
+    leaves.space[i] = space;
+    leaves.level[i] = level;
+    leaves.x[i] = x;
+    leaves.y[i] = y;
+    state.leafNodeIds[i] = nodeId;
+    leaves.count = i + 1;
+  }
+  return leaves;
+}
+
+function resetSplitMarks(state) {
+  state.splitGen = state.splitGen + 1 & 65535;
+  if (state.splitGen === 0) {
+    state.splitStamp.fill(0);
+    state.splitGen = 1;
+  }
+}
+function scheduleSplit(state, nodeId, count) {
+  if (nodeId === U32_EMPTY) return count;
+  if (state.splitStamp[nodeId] === state.splitGen) return count;
+  state.splitStamp[nodeId] = state.splitGen;
+  state.splitQueue[count] = nodeId;
+  return count + 1;
+}
+function balance2to1(state, surface, params, leaves) {
+  const maxIters = state.cfg.maxLevel + 1;
+  for (let iter = 0; iter < maxIters; iter++) {
+    const index = buildLeafIndex(leaves, state.leafIndex);
+    resetSplitMarks(state);
+    let splitCount = 0;
+    for (let i = 0; i < leaves.count; i++) {
+      const leafLevel = leaves.level[i];
+      if (leafLevel < 2) continue;
+      const leafSpace = leaves.space[i];
+      const leafX = leaves.x[i];
+      const leafY = leaves.y[i];
+      for (let dir = 0; dir < 4; dir++) {
+        for (let candidateLevel = leafLevel - 2; candidateLevel >= 0; candidateLevel--) {
+          const shift = leafLevel - candidateLevel;
+          const tile = state.scratchTile;
+          tile.space = leafSpace;
+          tile.level = candidateLevel;
+          tile.x = leafX >>> shift;
+          tile.y = leafY >>> shift;
+          const neighbor = state.scratchNeighbor;
+          if (!surface.neighborSameLevel(tile, dir, neighbor)) break;
+          const j = lookupSpatialIndexRaw(
+            index,
+            neighbor.space,
+            neighbor.level,
+            neighbor.x,
+            neighbor.y
+          );
+          if (j !== U32_EMPTY) {
+            splitCount = scheduleSplit(state, state.leafNodeIds[j], splitCount);
+            break;
           }
         }
       }
-      this.nodeView.setLeaf(nodeIndex, false);
-      return bestLeafIndex;
     }
-    this.nodeView.setLeaf(nodeIndex, true);
-    return nodeIndex;
+    if (splitCount === 0) return leaves;
+    let anySplit = false;
+    for (let k = 0; k < splitCount; k++) {
+      const nodeId = state.splitQueue[k];
+      if (state.store.level[nodeId] >= state.cfg.maxLevel) continue;
+      const base = ensureChildren(state.store, nodeId);
+      if (base !== U32_EMPTY) anySplit = true;
+    }
+    if (!anySplit) return leaves;
+    refineLeaves(state, surface, params, leaves);
   }
-  /**
-   * Determine if a node should be subdivided using the configured strategy
-   */
-  shouldSubdivide(level, distance, nodeSize) {
-    const context = {
-      level,
-      distance,
-      nodeSize,
-      minNodeSize: this.config.minNodeSize,
-      rootSize: this.config.rootSize
-    };
-    return this.subdivisionStrategy(context);
+  return leaves;
+}
+
+function update(state, surface, params, outLeaves) {
+  beginUpdate(state, surface, params);
+  const leaves = refineLeaves(state, surface, params, outLeaves);
+  return balance2to1(state, surface, params, leaves);
+}
+
+const scratchTile = { space: 0, level: 0, x: 0, y: 0 };
+const scratchNbr = { space: 0, level: 0, x: 0, y: 0 };
+const scratchParentTile = { space: 0, level: 0, x: 0, y: 0 };
+const scratchParentNbr = { space: 0, level: 0, x: 0, y: 0 };
+function buildSeams2to1(surface, leaves, outSeams, outIndex) {
+  if (outSeams.capacity < leaves.count) {
+    throw new Error("SeamTable capacity is smaller than LeafSet.count.");
   }
-  /**
-   * Create a new node and return its index
-   */
-  createNode(level, x, y) {
-    if (this.nodeCount >= this.config.maxNodes) {
-      console.warn("Maximum node count reached, skipping node creation");
-      return -1;
-    }
-    if (level > this.deepestLevel) {
-      this.deepestLevel = level;
+  const index = buildLeafIndex(leaves, outIndex);
+  outSeams.count = leaves.count;
+  const neighbors = outSeams.neighbors;
+  for (let i = 0; i < leaves.count; i++) {
+    const base = i * 8;
+    const space = leaves.space[i];
+    const level = leaves.level[i];
+    const x = leaves.x[i];
+    const y = leaves.y[i];
+    for (let dir = 0; dir < 4; dir++) {
+      const outOffset = base + dir * 2;
+      neighbors[outOffset + 0] = U32_EMPTY;
+      neighbors[outOffset + 1] = U32_EMPTY;
+      scratchTile.space = space;
+      scratchTile.level = level;
+      scratchTile.x = x;
+      scratchTile.y = y;
+      if (!surface.neighborSameLevel(scratchTile, dir, scratchNbr)) continue;
+      let j = lookupSpatialIndexRaw(index, scratchNbr.space, scratchNbr.level, scratchNbr.x, scratchNbr.y);
+      if (j !== U32_EMPTY) {
+        neighbors[outOffset + 0] = j;
+        continue;
+      }
+      if (level > 0) {
+        const px = x >>> 1;
+        const py = y >>> 1;
+        scratchParentTile.space = space;
+        scratchParentTile.level = level - 1;
+        scratchParentTile.x = px;
+        scratchParentTile.y = py;
+        if (surface.neighborSameLevel(scratchParentTile, dir, scratchParentNbr)) {
+          j = lookupSpatialIndexRaw(
+            index,
+            scratchParentNbr.space,
+            scratchParentNbr.level,
+            scratchParentNbr.x,
+            scratchParentNbr.y
+          );
+          if (j !== U32_EMPTY) {
+            neighbors[outOffset + 0] = j;
+            continue;
+          }
+        }
+      }
+      const childLevel = scratchNbr.level + 1;
+      const x2 = scratchNbr.x << 1 >>> 0;
+      const y2 = scratchNbr.y << 1 >>> 0;
+      let ax = 0;
+      let ay = 0;
+      let bx = 0;
+      let by = 0;
+      switch (dir) {
+        case Dir.LEFT:
+          ax = x2 + 1;
+          ay = y2;
+          bx = x2 + 1;
+          by = y2 + 1;
+          break;
+        case Dir.RIGHT:
+          ax = x2;
+          ay = y2;
+          bx = x2;
+          by = y2 + 1;
+          break;
+        case Dir.TOP:
+          ax = x2;
+          ay = y2 + 1;
+          bx = x2 + 1;
+          by = y2 + 1;
+          break;
+        case Dir.BOTTOM:
+          ax = x2;
+          ay = y2;
+          bx = x2 + 1;
+          by = y2;
+          break;
+      }
+      j = lookupSpatialIndexRaw(index, scratchNbr.space, childLevel, ax, ay);
+      if (j !== U32_EMPTY) neighbors[outOffset + 0] = j;
+      j = lookupSpatialIndexRaw(index, scratchNbr.space, childLevel, bx, by);
+      if (j !== U32_EMPTY) neighbors[outOffset + 1] = j;
     }
-    this.tempChildIndices[0] = EMPTY_SENTINEL_VALUE;
-    this.tempChildIndices[1] = EMPTY_SENTINEL_VALUE;
-    this.tempChildIndices[2] = EMPTY_SENTINEL_VALUE;
-    this.tempChildIndices[3] = EMPTY_SENTINEL_VALUE;
-    this.tempNeighborIndices[0] = EMPTY_SENTINEL_VALUE;
-    this.tempNeighborIndices[1] = EMPTY_SENTINEL_VALUE;
-    this.tempNeighborIndices[2] = EMPTY_SENTINEL_VALUE;
-    this.tempNeighborIndices[3] = EMPTY_SENTINEL_VALUE;
-    const nodeIndex = this.nodeCount++;
-    this.nodeView.setLevel(nodeIndex, level);
-    this.nodeView.setX(nodeIndex, x);
-    this.nodeView.setY(nodeIndex, y);
-    this.nodeView.setChildren(nodeIndex, this.tempChildIndices);
-    this.nodeView.setNeighbors(nodeIndex, this.tempNeighborIndices);
-    this.nodeView.setLeaf(nodeIndex, false);
-    return nodeIndex;
   }
-  /**
-   * Subdivide a node by creating its four children
-   */
-  subdivideNode(nodeIndex) {
-    const childLevel = this.nodeView.getLevel(nodeIndex) + 1;
-    const childX = this.nodeView.getX(nodeIndex) * 2;
-    const childY = this.nodeView.getY(nodeIndex) * 2;
-    const childIndices = [
-      this.createNode(childLevel, childX, childY),
-      // top-left
-      this.createNode(childLevel, childX + 1, childY),
-      // top-right
-      this.createNode(childLevel, childX, childY + 1),
-      // bottom-left
-      this.createNode(childLevel, childX + 1, childY + 1)
-      // bottom-right
-    ];
-    if (childIndices.some((index) => index === -1)) {
-      console.warn("Failed to create all children, skipping subdivision");
-      return;
+  return outSeams;
+}
+
+function createFlatSurface(cfg) {
+  const halfRoot = 0.5 * cfg.rootSize;
+  const maxHeight = cfg.maxHeight ?? 0;
+  const surface = {
+    spaceCount: 1,
+    maxRootCount: 1,
+    neighborSameLevel(tile, dir, out) {
+      const level = tile.level;
+      const x = tile.x;
+      const y = tile.y;
+      let nx = x;
+      let ny = y;
+      switch (dir) {
+        case Dir.LEFT:
+          nx = x - 1;
+          break;
+        case Dir.RIGHT:
+          nx = x + 1;
+          break;
+        case Dir.TOP:
+          ny = y - 1;
+          break;
+        case Dir.BOTTOM:
+          ny = y + 1;
+          break;
+      }
+      if (nx < 0 || ny < 0) return false;
+      const maxCoord = (1 << level) - 1;
+      if (nx > maxCoord || ny > maxCoord) return false;
+      out.space = 0;
+      out.level = level;
+      out.x = nx;
+      out.y = ny;
+      return true;
+    },
+    tileBounds(tile, cameraOrigin, out) {
+      const level = tile.level;
+      const scale = 1 / (1 << level);
+      const size = cfg.rootSize * scale;
+      const minX = cfg.origin.x + (tile.x * size - halfRoot);
+      const minZ = cfg.origin.z + (tile.y * size - halfRoot);
+      const centerX = minX + 0.5 * size;
+      const centerY = cfg.origin.y;
+      const centerZ = minZ + 0.5 * size;
+      out.cx = centerX - cameraOrigin.x;
+      out.cy = centerY - cameraOrigin.y;
+      out.cz = centerZ - cameraOrigin.z;
+      out.r = 0.7071067811865476 * size + maxHeight;
+    },
+    rootTiles(_cameraOrigin, out) {
+      const root = out[0];
+      root.space = 0;
+      root.level = 0;
+      root.x = 0;
+      root.y = 0;
+      return 1;
     }
-    this.nodeView.setChildren(nodeIndex, childIndices);
-    this.updateChildNeighbors(nodeIndex, childIndices);
-  }
-  /**
-   * Update neighbor relationships for child nodes
-   */
-  updateChildNeighbors(_parentIndex, childIndices) {
-    for (let i = 0; i < 4; i++) {
-      const childIndex = childIndices[i];
-      this.tempNeighborIndices[0] = EMPTY_SENTINEL_VALUE;
-      this.tempNeighborIndices[1] = EMPTY_SENTINEL_VALUE;
-      this.tempNeighborIndices[2] = EMPTY_SENTINEL_VALUE;
-      this.tempNeighborIndices[3] = EMPTY_SENTINEL_VALUE;
-      const childX = i % 2;
-      const childY = Math.floor(i / 2);
-      if (childX === 0 && i + 1 < 4) {
-        this.tempNeighborIndices[1] = childIndices[i + 1];
-      } else if (childX === 1 && i - 1 >= 0) {
-        this.tempNeighborIndices[0] = childIndices[i - 1];
+  };
+  return surface;
+}
+
+function createInfiniteFlatSurface(cfg) {
+  const halfRoot = 0.5 * cfg.rootSize;
+  const maxHeight = cfg.maxHeight ?? 0;
+  const rootGridRadius = Math.max(0, Math.floor(cfg.rootGridRadius ?? 1));
+  const rootWidth = rootGridRadius * 2 + 1;
+  return {
+    spaceCount: 1,
+    maxRootCount: rootWidth * rootWidth,
+    neighborSameLevel(tile, dir, out) {
+      let nx = tile.x;
+      let ny = tile.y;
+      switch (dir) {
+        case Dir.LEFT:
+          nx = tile.x - 1;
+          break;
+        case Dir.RIGHT:
+          nx = tile.x + 1;
+          break;
+        case Dir.TOP:
+          ny = tile.y - 1;
+          break;
+        case Dir.BOTTOM:
+          ny = tile.y + 1;
+          break;
       }
-      if (childY === 0 && i + 2 < 4) {
-        this.tempNeighborIndices[3] = childIndices[i + 2];
-      } else if (childY === 1 && i - 2 >= 0) {
-        this.tempNeighborIndices[2] = childIndices[i - 2];
+      out.space = tile.space;
+      out.level = tile.level;
+      out.x = nx;
+      out.y = ny;
+      return true;
+    },
+    tileBounds(tile, cameraOrigin, out) {
+      const level = tile.level;
+      const scale = 1 / (1 << level);
+      const size = cfg.rootSize * scale;
+      const minX = cfg.origin.x + (tile.x * size - halfRoot);
+      const minZ = cfg.origin.z + (tile.y * size - halfRoot);
+      const centerX = minX + 0.5 * size;
+      const centerY = cfg.origin.y;
+      const centerZ = minZ + 0.5 * size;
+      out.cx = centerX - cameraOrigin.x;
+      out.cy = centerY - cameraOrigin.y;
+      out.cz = centerZ - cameraOrigin.z;
+      out.r = 0.7071067811865476 * size + maxHeight;
+    },
+    rootTiles(cameraOrigin, out) {
+      const camRootX = Math.floor((cameraOrigin.x - cfg.origin.x + halfRoot) / cfg.rootSize);
+      const camRootY = Math.floor((cameraOrigin.z - cfg.origin.z + halfRoot) / cfg.rootSize);
+      let index = 0;
+      for (let dy = -rootGridRadius; dy <= rootGridRadius; dy++) {
+        for (let dx = -rootGridRadius; dx <= rootGridRadius; dx++) {
+          const root = out[index];
+          root.space = 0;
+          root.level = 0;
+          root.x = camRootX + dx;
+          root.y = camRootY + dy;
+          index++;
+        }
       }
-      this.nodeView.setNeighbors(childIndex, this.tempNeighborIndices);
+      return index;
     }
-  }
-  /**
-   * Get the deepest subdivision level currently in the quadtree
-   */
-  getDeepestLevel() {
-    return this.deepestLevel;
-  }
-  /**
-   * Get the total number of nodes
-   */
-  getNodeCount() {
-    return this.nodeCount;
-  }
-  getLeafNodeCount() {
-    return this.nodeView.getLeafNodeCount();
-  }
-  /**
-   * Get active leaf node indices for efficient GPU processing
-   */
-  getActiveLeafNodeIndices() {
-    return this.nodeView.getActiveLeafNodeIndices();
-  }
-  /**
-   * Get the configuration
-   */
-  getConfig() {
-    return this.config;
-  }
-  /**
-   * Get all leaf nodes as an array of node objects
-   */
-  getLeafNodes() {
-    const leafNodes = [];
-    for (let i = 0; i < this.nodeCount; i++) {
-      if (this.nodeView.getLeaf(i)) {
-        leafNodes.push({
-          level: this.nodeView.getLevel(i),
-          x: this.nodeView.getX(i),
-          y: this.nodeView.getY(i)
-        });
+  };
+}
+
+function createCubeSphereSurface(_cfg) {
+  return {
+    spaceCount: 6,
+    maxRootCount: 6,
+    neighborSameLevel(_tile, _dir, _out) {
+      return false;
+    },
+    tileBounds(_tile, _cameraOrigin, out) {
+      out.cx = 0;
+      out.cy = 0;
+      out.cz = 0;
+      out.r = Number.MAX_VALUE;
+    },
+    rootTiles(_cameraOrigin, out) {
+      for (let s = 0; s < 6; s++) {
+        const root = out[s];
+        root.space = s;
+        root.level = 0;
+        root.x = 0;
+        root.y = 0;
       }
+      return 6;
     }
-    return leafNodes;
-  }
-  /**
-   * Reset the quadtree
-   */
-  reset() {
-    this.initialize();
-  }
-  /**
-   * Get the NodeView instance for direct access
-   */
-  getNodeView() {
-    return this.nodeView;
-  }
-  /**
-   * Release internal resources associated with this quadtree
-   */
-  destroy() {
-    this.nodeView.destroy();
-    this.nodeCount = 0;
-    this.deepestLevel = 0;
-  }
-  /**
-   * Set the configuration
-   */
-  setConfig(config, reset = false) {
-    this.config = config;
-    if (reset) {
-      this.initialize();
+  };
+}
+
+const surfaceTask = work.task((get, work) => {
+  const customSurface = get(surface);
+  const rootSizeVal = get(rootSize);
+  const originVal = get(origin);
+  return work(() => {
+    if (customSurface) return customSurface;
+    return createFlatSurface({ rootSize: rootSizeVal, origin: originVal });
+  });
+}).displayName("surfaceTask");
+const quadtreeConfigTask = work.task((get, work) => {
+  const surfaceVal = get(surfaceTask);
+  const maxNodesVal = get(maxNodes);
+  const maxLevelVal = get(maxLevel);
+  return work(() => {
+    const state = createState({ maxNodes: maxNodesVal, maxLevel: maxLevelVal }, surfaceVal);
+    return {
+      state,
+      surface: surfaceVal
+    };
+  });
+}).displayName("quadtreeConfigTask");
+const quadtreeUpdateTask = work.task((get, work) => {
+  const quadtreeConfig = get(quadtreeConfigTask);
+  const quadtreeUpdateConfig = get(quadtreeUpdate);
+  let outLeaves = void 0;
+  return work(() => {
+    outLeaves = update(
+      quadtreeConfig.state,
+      quadtreeConfig.surface,
+      quadtreeUpdateConfig,
+      outLeaves
+    );
+    return outLeaves;
+  });
+}).displayName("quadtreeUpdateTask");
+const leafStorageTask = work.task((get, work) => {
+  const maxNodesVal = get(maxNodes);
+  return work(() => createLeafStorage(maxNodesVal));
+}).displayName("leafStorageTask");
+const leafGpuBufferTask = work.task((get, work) => {
+  const leafSet = get(quadtreeUpdateTask);
+  const leafStorage = get(leafStorageTask);
+  return work(() => {
+    const bufferCapacity = leafStorage.data.length / 4;
+    const leafCount = Math.min(leafSet.count, bufferCapacity);
+    for (let i = 0; i < leafCount; i += 1) {
+      const offset = i * 4;
+      leafStorage.data[offset] = leafSet.level[i] ?? 0;
+      leafStorage.data[offset + 1] = leafSet.x[i] ?? 0;
+      leafStorage.data[offset + 2] = leafSet.y[i] ?? 0;
+      leafStorage.data[offset + 3] = 1;
     }
-  }
+    leafStorage.attribute.needsUpdate = true;
+    leafStorage.node.needsUpdate = true;
+    return {
+      count: leafCount,
+      data: leafStorage.data,
+      attribute: leafStorage.attribute,
+      node: leafStorage.node
+    };
+  });
+}).displayName("leafGpuBufferTask");
+
+function createElevationFunction(callback) {
+  const tslFunction = (args) => {
+    const params = {
+      worldPosition: args.worldPosition,
+      rootSize: args.rootSize,
+      rootUV: args.rootUV,
+      tileUV: args.tileUV,
+      tileLevel: args.tileLevel,
+      tileSize: args.tileSize,
+      tileOriginVec2: args.tileOriginVec2,
+      nodeIndex: args.nodeIndex
+    };
+    return callback(params);
+  };
+  return TSL_js.Fn(tslFunction);
+}
+
+function createTerrainUniforms(params) {
+  const sanitizedId = params.instanceId?.replace(/-/g, "_");
+  const suffix = sanitizedId ? `_${sanitizedId}` : "";
+  const uRootOrigin = tsl.uniform(
+    new webgpu.Vector3(params.rootOrigin.x, params.rootOrigin.y, params.rootOrigin.z)
+  ).setName(`uRootOrigin${suffix}`);
+  const uRootSize = tsl.uniform(tsl.float(params.rootSize)).setName(`uRootSize${suffix}`);
+  const uInnerTileSegments = tsl.uniform(tsl.int(params.innerTileSegments)).setName(
+    `uInnerTileSegments${suffix}`
+  );
+  const uSkirtScale = tsl.uniform(tsl.float(params.skirtScale)).setName(`uSkirtScale${suffix}`);
+  const uElevationScale = tsl.uniform(tsl.float(params.elevationScale)).setName(`uElevationScale${suffix}`);
+  return {
+    uRootOrigin,
+    uRootSize,
+    uInnerTileSegments,
+    uSkirtScale,
+    uElevationScale
+  };
+}
+
+const instanceIdTask = work.task(() => crypto.randomUUID()).displayName("instanceIdTask").cache("once");
+
+const scratchVector3 = new three.Vector3();
+const createUniformsTask = work.task((get, work) => {
+  const uniformParams = {
+    rootOrigin: get(origin),
+    rootSize: get(rootSize),
+    innerTileSegments: get(innerTileSegments),
+    skirtScale: get(skirtScale),
+    elevationScale: get(elevationScale),
+    instanceId: get(instanceIdTask)
+  };
+  return work(() => createTerrainUniforms(uniformParams));
+}).displayName("createUniformsTask").cache("once");
+const updateUniformsTask = work.task((get, work) => {
+  const terrainUniformsContext = get(createUniformsTask);
+  const rootSizeVal = get(rootSize);
+  const rootOrigin = get(origin);
+  const innerTileSegmentsVal = get(innerTileSegments);
+  const skirtScaleVal = get(skirtScale);
+  const elevationScaleVal = get(elevationScale);
+  return work(() => {
+    terrainUniformsContext.uRootSize.value = rootSizeVal;
+    terrainUniformsContext.uRootOrigin.value = scratchVector3.set(
+      rootOrigin.x,
+      rootOrigin.y,
+      rootOrigin.z
+    );
+    terrainUniformsContext.uInnerTileSegments.value = innerTileSegmentsVal;
+    terrainUniformsContext.uSkirtScale.value = skirtScaleVal;
+    terrainUniformsContext.uElevationScale.value = elevationScaleVal;
+    return terrainUniformsContext;
+  });
+}).displayName("updateUniformsTask");
+
+const createElevationFieldContextTask = work.task((get, work) => {
+  const edgeVertexCount = get(innerTileSegments) + 3;
+  const verticesPerNode = edgeVertexCount * edgeVertexCount;
+  const totalElements = get(maxNodes) * verticesPerNode;
+  return work(() => {
+    const data = new Float32Array(totalElements);
+    const attribute = new webgpu.StorageBufferAttribute(data, 1);
+    const node = tsl.storage(attribute, "float", totalElements);
+    return {
+      data,
+      attribute,
+      node
+    };
+  });
+}).displayName("createElevationFieldContextTask");
+const tileNodesTask = work.task((get, work) => {
+  const leafStorage = get(leafStorageTask);
+  const uniforms = get(createUniformsTask);
+  return work(() => {
+    return createTileCompute(leafStorage, uniforms);
+  });
+}).displayName("tileNodesTask");
+const elevationFieldStageTask = work.task((get, work) => {
+  const tile = get(tileNodesTask);
+  const uniforms = get(createUniformsTask);
+  const elevationFieldContext = get(createElevationFieldContextTask);
+  const userElevationFn = get(elevationFn);
+  return work(() => {
+    const heightFn = createElevationFunction(userElevationFn);
+    const heightWriteFn = createElevation(tile, uniforms, heightFn);
+    return [
+      (nodeIndex, globalVertexIndex, _uv, localCoordinates) => {
+        const height = heightWriteFn(nodeIndex, localCoordinates);
+        elevationFieldContext.node.element(globalVertexIndex).assign(height);
+      }
+    ];
+  });
+}).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");
+function createNormalFromElevationField(elevationFieldNode, edgeVertexCount) {
+  return tsl.Fn(
+    ([nodeIndex, tileSize, ix, iy, elevationScale]) => {
+      const iEdge = tsl.int(edgeVertexCount);
+      const verticesPerNode = iEdge.mul(iEdge);
+      const baseOffset = tsl.int(nodeIndex).mul(verticesPerNode);
+      const xLeft = tsl.int(ix).sub(tsl.int(1));
+      const xRight = tsl.int(ix).add(tsl.int(1));
+      const yUp = tsl.int(iy).sub(tsl.int(1));
+      const yDown = tsl.int(iy).add(tsl.int(1));
+      const hLeft = elevationFieldNode.element(baseOffset.add(tsl.int(iy).mul(iEdge).add(xLeft))).mul(elevationScale);
+      const hRight = elevationFieldNode.element(baseOffset.add(tsl.int(iy).mul(iEdge).add(xRight))).mul(elevationScale);
+      const hUp = elevationFieldNode.element(baseOffset.add(yUp.mul(iEdge).add(tsl.int(ix)))).mul(elevationScale);
+      const hDown = elevationFieldNode.element(baseOffset.add(yDown.mul(iEdge).add(tsl.int(ix)))).mul(elevationScale);
+      const innerSegments = tsl.float(iEdge).sub(tsl.float(3));
+      const stepWorld = tileSize.div(innerSegments);
+      const inv2Step = tsl.float(0.5).div(stepWorld);
+      const dhdx = tsl.float(hRight).sub(tsl.float(hLeft)).mul(inv2Step);
+      const dhdz = tsl.float(hDown).sub(tsl.float(hUp)).mul(inv2Step);
+      const normal = tsl.vec3(dhdx.negate(), tsl.float(1), dhdz.negate()).normalize();
+      return tsl.vec2(normal.x, normal.z);
+    }
+  );
+}
+const normalFieldStageTask = work.task((get, work) => {
+  const upstream = get(elevationFieldStageTask);
+  const elevationFieldContext = get(createElevationFieldContextTask);
+  const normalFieldContext = get(createNormalFieldContextTask);
+  const tileEdgeVertexCount = get(innerTileSegments) + 3;
+  const tile = get(tileNodesTask);
+  const uniforms = get(createUniformsTask);
+  return work(() => {
+    const computeNormal = createNormalFromElevationField(
+      elevationFieldContext.node,
+      tileEdgeVertexCount
+    );
+    return [
+      ...upstream,
+      (nodeIndex, globalVertexIndex, _uv, localCoordinates) => {
+        const ix = tsl.int(localCoordinates.x);
+        const iy = tsl.int(localCoordinates.y);
+        const tileSize = tile.tileSize(nodeIndex);
+        const normalXZ = computeNormal(
+          nodeIndex,
+          tileSize,
+          ix,
+          iy,
+          uniforms.uElevationScale
+        );
+        normalFieldContext.node.element(globalVertexIndex).assign(tsl.packHalf2x16(normalXZ));
+      }
+    ];
+  });
+}).displayName("normalFieldStageTask");
+
+const compileComputeTask = work.task((get, work) => {
+  const pipeline = get(normalFieldStageTask);
+  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) : () => {
+    }
+  );
+}).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));
+  }).displayName("compileComputeTask");
+  const execute = work.task((get, work, { resources }) => {
+    const { execute: run } = get(compile);
+    const leafState = get(leafGpuBufferTask);
+    return work(() => resources?.renderer ? run(resources.renderer, leafState.count) : () => {
+    });
+  }).displayName("executeComputeTask").lane("gpu");
+  return { compile, execute };
+}
+
+const 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);
+  const segmentEdges = tsl.int(segmentsNode.add(3));
+  const vx = vIndex.mod(segmentEdges);
+  const vy = vIndex.div(segmentEdges);
+  const last = segmentEdges.sub(tsl.int(1));
+  return vx.equal(tsl.int(0)).or(vx.equal(last)).or(vy.equal(tsl.int(0))).or(vy.equal(last));
+});
+const isSkirtUV = tsl.Fn(([segments]) => {
+  const segmentsNode = typeof segments === "number" ? tsl.int(segments) : segments;
+  const ux = tsl.uv().x;
+  const uy = tsl.uv().y;
+  const segmentCount = segmentsNode.add(2);
+  const segmentStep = tsl.float(1).div(segmentCount);
+  const innerX = ux.greaterThan(segmentStep).and(ux.lessThan(segmentStep.oneMinus()));
+  const innerY = uy.greaterThan(segmentStep).and(uy.lessThan(segmentStep.oneMinus()));
+  return innerX.and(innerY).not();
+});
+
+function createTileBaseWorldPosition(leafStorage, terrainUniforms) {
+  return tsl.Fn(() => {
+    const nodeIndex = tsl.int(tsl.instanceIndex);
+    const nodeOffset = nodeIndex.mul(tsl.int(4));
+    const nodeLevel = leafStorage.node.element(nodeOffset).toInt();
+    const nodeX = leafStorage.node.element(nodeOffset.add(tsl.int(1))).toFloat();
+    const nodeY = leafStorage.node.element(nodeOffset.add(tsl.int(2))).toFloat();
+    const rootSize = terrainUniforms.uRootSize.toVar();
+    const rootOrigin = terrainUniforms.uRootOrigin.toVar();
+    const half = tsl.float(0.5);
+    const size = rootSize.div(tsl.pow(tsl.float(2), nodeLevel.toFloat()));
+    const halfRoot = rootSize.mul(half);
+    const centerX = rootOrigin.x.add(nodeX.add(half).mul(size)).sub(halfRoot);
+    const centerZ = rootOrigin.z.add(nodeY.add(half).mul(size)).sub(halfRoot);
+    const clampedX = tsl.positionLocal.x.max(half.negate()).min(half);
+    const clampedZ = tsl.positionLocal.z.max(half.negate()).min(half);
+    const worldX = centerX.add(clampedX.mul(size));
+    const worldZ = centerZ.add(clampedZ.mul(size));
+    return tsl.vec3(worldX, rootOrigin.y, worldZ);
+  });
+}
+function createTileElevation(terrainUniforms, elevationFieldBufferNode) {
+  if (!elevationFieldBufferNode) return tsl.float(0);
+  const edgeVertexCount = terrainUniforms.uInnerTileSegments.add(3);
+  return readElevationFieldAtPositionLocal(
+    elevationFieldBufferNode,
+    edgeVertexCount,
+    tsl.positionLocal
+  )().mul(
+    terrainUniforms.uElevationScale
+  );
+}
+function createNormalAssignment(terrainUniforms, normalFieldBufferNode) {
+  if (!normalFieldBufferNode) 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));
 }
+function createTileWorldPosition(leafStorage, terrainUniforms, elevationFieldBufferNode, normalFieldBufferNode) {
+  const baseWorldPosition = createTileBaseWorldPosition(leafStorage, terrainUniforms);
+  return tsl.Fn(() => {
+    const base = baseWorldPosition();
+    const yElevation = createTileElevation(terrainUniforms, elevationFieldBufferNode);
+    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);
+    return tsl.vec3(base.x, worldY, base.z);
+  })();
+}
+
+const positionNodeTask = work.task((get, work) => {
+  const leafStorage = get(leafStorageTask);
+  const terrainUniforms = get(createUniformsTask);
+  const elevationFieldContext = get(createElevationFieldContextTask);
+  const normalFieldContext = get(createNormalFieldContextTask);
+  return work(
+    () => createTileWorldPosition(
+      leafStorage,
+      terrainUniforms,
+      elevationFieldContext.node,
+      normalFieldContext.node
+    )
+  );
+}).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);
+}
+const terrainTasks = {
+  instanceId: instanceIdTask,
+  quadtreeConfig: quadtreeConfigTask,
+  quadtreeUpdate: quadtreeUpdateTask,
+  leafStorage: leafStorageTask,
+  surface: surfaceTask,
+  leafGpuBuffer: leafGpuBufferTask,
+  createUniforms: createUniformsTask,
+  updateUniforms: updateUniformsTask,
+  positionNode: positionNodeTask,
+  createElevationFieldContext: createElevationFieldContextTask,
+  createTileNodes: tileNodesTask,
+  createNormalFieldContext: createNormalFieldContextTask,
+  elevationFieldStage: elevationFieldStageTask,
+  normalFieldStage: normalFieldStageTask,
+  compileCompute: compileComputeTask,
+  executeCompute: executeComputeTask
+};
+
+const vGlobalVertexIndex = /* @__PURE__ */ tsl.varyingProperty("int", "vGlobalVertexIndex");
+const vElevation = /* @__PURE__ */ tsl.varyingProperty("f32", "vElevation");
+
+const cellCenter = tsl.Fn(({ cell }) => {
+  return cell.add(tsl.mx_noise_float(cell.mul(Math.PI)));
+});
+const voronoiCells = tsl.Fn((params) => {
+  const scale = tsl.float(params.scale);
+  const facet = tsl.float(params.facet);
+  const seed = tsl.float(params.seed);
+  const pos = params.uv.mul(scale).add(seed);
+  const midCell = pos.round().toVar();
+  const minCell = midCell.toVar();
+  const minDist = tsl.float(1).toVar();
+  const cell = tsl.vec3(0, 0, 0).toVar();
+  const dist = tsl.float().toVar();
+  const i = tsl.float(0).toVar();
+  tsl.Loop(27, () => {
+    const ix = i.mod(3).sub(1);
+    const iy = i.div(3).floor().mod(3).sub(1);
+    const iz = i.div(9).floor().sub(1);
+    cell.assign(midCell.add(tsl.vec3(ix, iy, iz)));
+    dist.assign(pos.distance(cellCenter({ cell })).add(tsl.mx_noise_float(pos).div(5)));
+    tsl.If(dist.lessThan(minDist), () => {
+      minDist.assign(dist);
+      minCell.assign(cell);
+    });
+    i.addAssign(1);
+  });
+  const n = tsl.mx_noise_float(minCell.mul(Math.PI)).toVar();
+  const k = tsl.mix(minDist, n.add(1).div(2), facet);
+  return k;
+});
 
-exports.Quadtree = Quadtree;
+exports.Dir = Dir;
 exports.TerrainGeometry = TerrainGeometry;
-exports.computeScreenSpaceInfo = computeScreenSpaceInfo;
-exports.distanceBasedSubdivision = distanceBasedSubdivision;
+exports.TerrainMesh = TerrainMesh;
+exports.U32_EMPTY = U32_EMPTY;
+exports.allocLeafSet = allocLeafSet;
+exports.allocSeamTable = allocSeamTable;
+exports.beginUpdate = beginUpdate;
+exports.blendAngleCorrectedNormals = blendAngleCorrectedNormals;
+exports.buildLeafIndex = buildLeafIndex;
+exports.buildSeams2to1 = buildSeams2to1;
+exports.compileComputeTask = compileComputeTask;
+exports.createComputePipelineTasks = createComputePipelineTasks;
+exports.createCubeSphereSurface = createCubeSphereSurface;
+exports.createElevationFieldContextTask = createElevationFieldContextTask;
+exports.createFlatSurface = createFlatSurface;
+exports.createInfiniteFlatSurface = createInfiniteFlatSurface;
+exports.createNormalFieldContextTask = createNormalFieldContextTask;
+exports.createSpatialIndex = createSpatialIndex;
+exports.createState = createState;
+exports.createTerrainUniforms = createTerrainUniforms;
+exports.createUniformsTask = createUniformsTask;
+exports.deriveNormalZ = deriveNormalZ;
+exports.elevationFieldStageTask = elevationFieldStageTask;
+exports.elevationFn = elevationFn;
+exports.elevationScale = elevationScale;
+exports.executeComputeTask = executeComputeTask;
+exports.innerTileSegments = innerTileSegments;
+exports.instanceIdTask = instanceIdTask;
 exports.isSkirtUV = isSkirtUV;
 exports.isSkirtVertex = isSkirtVertex;
-exports.screenSpaceSubdivision = screenSpaceSubdivision;
+exports.leafGpuBufferTask = leafGpuBufferTask;
+exports.leafStorageTask = leafStorageTask;
+exports.maxLevel = maxLevel;
+exports.maxNodes = maxNodes;
+exports.normalFieldStageTask = normalFieldStageTask;
+exports.origin = origin;
+exports.positionNodeTask = positionNodeTask;
+exports.quadtreeConfigTask = quadtreeConfigTask;
+exports.quadtreeUpdate = quadtreeUpdate;
+exports.quadtreeUpdateTask = quadtreeUpdateTask;
+exports.resetLeafSet = resetLeafSet;
+exports.resetSeamTable = resetSeamTable;
+exports.rootSize = rootSize;
+exports.skirtScale = skirtScale;
+exports.surface = surface;
+exports.surfaceTask = surfaceTask;
+exports.terrainGraph = terrainGraph;
+exports.terrainTasks = terrainTasks;
+exports.textureSpaceToVectorSpace = textureSpaceToVectorSpace;
+exports.tileNodesTask = tileNodesTask;
+exports.update = update;
+exports.updateUniformsTask = updateUniformsTask;
+exports.vElevation = vElevation;
+exports.vGlobalVertexIndex = vGlobalVertexIndex;
+exports.vectorSpaceToTextureSpace = vectorSpaceToTextureSpace;
+exports.voronoiCells = voronoiCells;