@holoscript/engine 6.0.3 → 6.0.4

package/dist/chunk-PYCOIDT2.js

@@ -0,0 +1,812 @@
+import {
+  __export
+} from "./chunk-AKLW2MUS.js";
+
+// src/terrain/index.ts
+var terrain_exports = {};
+__export(terrain_exports, {
+  ErosionBrush: () => ErosionBrush,
+  ErosionSim: () => ErosionSim,
+  TerrainBrush: () => TerrainBrush,
+  TerrainLOD: () => TerrainLOD,
+  TerrainPaintLayer: () => TerrainPaintLayer,
+  TerrainTexturing: () => TerrainTexturing
+});
+
+// src/terrain/TerrainBrush.ts
+function computeFalloff(distance, radius, curve) {
+  const t = Math.min(distance / radius, 1);
+  switch (curve) {
+    case "linear":
+      return 1 - t;
+    case "smooth":
+      return 1 - t * t * (3 - 2 * t);
+    case "sphere":
+      return Math.sqrt(Math.max(0, 1 - t * t));
+    case "tip":
+      return (1 - t) * (1 - t);
+    case "flat":
+      return t < 0.8 ? 1 : 1 - (t - 0.8) / 0.2;
+  }
+}
+var TerrainBrush = class {
+  grid = /* @__PURE__ */ new Map();
+  strokes = [];
+  undoStack = [];
+  config;
+  gridSize;
+  constructor(gridSize = 64, config) {
+    this.gridSize = gridSize;
+    this.config = {
+      mode: config?.mode ?? "raise",
+      radius: config?.radius ?? 5,
+      strength: config?.strength ?? 1,
+      falloff: config?.falloff ?? "smooth",
+      opacity: config?.opacity ?? 1
+    };
+    for (let x = 0; x < gridSize; x++) {
+      for (let z = 0; z < gridSize; z++) {
+        this.grid.set(`${x},${z}`, { height: 0, paintLayer: 0, locked: false });
+      }
+    }
+  }
+  /**
+   * Apply brush at a position
+   */
+  apply(cx, cz, overrides) {
+    const cfg = { ...this.config, ...overrides };
+    const snapshot = /* @__PURE__ */ new Map();
+    let affected = 0;
+    const r = Math.ceil(cfg.radius);
+    let avgHeight = 0;
+    let avgCount = 0;
+    if (cfg.mode === "flatten" || cfg.mode === "smooth") {
+      for (let dx = -r; dx <= r; dx++) {
+        for (let dz = -r; dz <= r; dz++) {
+          const dist = Math.sqrt(dx * dx + dz * dz);
+          if (dist > cfg.radius) continue;
+          const cell = this.grid.get(`${cx + dx},${cz + dz}`);
+          if (cell) {
+            avgHeight += cell.height;
+            avgCount++;
+          }
+        }
+      }
+      if (avgCount > 0) avgHeight /= avgCount;
+    }
+    for (let dx = -r; dx <= r; dx++) {
+      for (let dz = -r; dz <= r; dz++) {
+        const dist = Math.sqrt(dx * dx + dz * dz);
+        if (dist > cfg.radius) continue;
+        const key = `${cx + dx},${cz + dz}`;
+        const cell = this.grid.get(key);
+        if (!cell || cell.locked) continue;
+        const falloff = computeFalloff(dist, cfg.radius, cfg.falloff);
+        const intensity = cfg.strength * cfg.opacity * falloff;
+        snapshot.set(key, cell.height);
+        switch (cfg.mode) {
+          case "raise":
+            cell.height += intensity;
+            break;
+          case "lower":
+            cell.height -= intensity;
+            break;
+          case "smooth":
+            cell.height += (avgHeight - cell.height) * intensity * 0.5;
+            break;
+          case "flatten":
+            cell.height += (avgHeight - cell.height) * intensity;
+            break;
+          case "paint":
+            break;
+          case "erode":
+            cell.height += (avgHeight - cell.height) * intensity * 0.3;
+            break;
+        }
+        affected++;
+      }
+    }
+    this.undoStack.push(snapshot);
+    this.strokes.push({ x: cx, z: cz, config: cfg, timestamp: Date.now() });
+    return affected;
+  }
+  /**
+   * Paint a layer at a position
+   */
+  paint(cx, cz, layerIndex) {
+    const r = Math.ceil(this.config.radius);
+    let painted = 0;
+    for (let dx = -r; dx <= r; dx++) {
+      for (let dz = -r; dz <= r; dz++) {
+        const dist = Math.sqrt(dx * dx + dz * dz);
+        if (dist > this.config.radius) continue;
+        const cell = this.grid.get(`${cx + dx},${cz + dz}`);
+        if (cell && !cell.locked) {
+          cell.paintLayer = layerIndex;
+          painted++;
+        }
+      }
+    }
+    return painted;
+  }
+  /**
+   * Undo last stroke
+   */
+  undo() {
+    const snapshot = this.undoStack.pop();
+    if (!snapshot) return false;
+    for (const [key, height] of snapshot) {
+      const cell = this.grid.get(key);
+      if (cell) cell.height = height;
+    }
+    this.strokes.pop();
+    return true;
+  }
+  /**
+   * Get height at a grid position
+   */
+  getHeight(x, z) {
+    return this.grid.get(`${x},${z}`)?.height ?? 0;
+  }
+  /**
+   * Get cell data
+   */
+  getCell(x, z) {
+    return this.grid.get(`${x},${z}`);
+  }
+  /**
+   * Lock/unlock cells
+   */
+  setLocked(x, z, locked) {
+    const cell = this.grid.get(`${x},${z}`);
+    if (cell) cell.locked = locked;
+  }
+  /**
+   * Get current config
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Set config
+   */
+  setConfig(cfg) {
+    Object.assign(this.config, cfg);
+  }
+  /**
+   * Get stroke count
+   */
+  getStrokeCount() {
+    return this.strokes.length;
+  }
+  /**
+   * Get grid size
+   */
+  getGridSize() {
+    return this.gridSize;
+  }
+  /**
+   * Get undo count
+   */
+  getUndoCount() {
+    return this.undoStack.length;
+  }
+  /**
+   * Get height range
+   */
+  getHeightRange() {
+    let min = Infinity, max = -Infinity;
+    for (const cell of this.grid.values()) {
+      if (cell.height < min) min = cell.height;
+      if (cell.height > max) max = cell.height;
+    }
+    return { min, max };
+  }
+};
+
+// src/terrain/TerrainLOD.ts
+var _chunkId = 0;
+var TerrainLOD = class {
+  config;
+  chunks = /* @__PURE__ */ new Map();
+  activeChunks = /* @__PURE__ */ new Set();
+  constructor(config) {
+    this.config = {
+      totalSize: 1024,
+      maxLOD: 4,
+      baseResolution: 64,
+      lodDistances: [100, 250, 500, 1e3],
+      morphRange: 0.2,
+      ...config
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Generation
+  // ---------------------------------------------------------------------------
+  generateQuadtree(heightSampler) {
+    this.chunks.clear();
+    this.activeChunks.clear();
+    this.subdivide(0, 0, this.config.totalSize, 0, heightSampler);
+  }
+  subdivide(x, z, size, level, sampler) {
+    const resolution = Math.max(4, this.config.baseResolution >> level);
+    const heightData = new Float32Array(resolution * resolution);
+    for (let row = 0; row < resolution; row++) {
+      for (let col = 0; col < resolution; col++) {
+        const wx = x + col / (resolution - 1) * size;
+        const wz = z + row / (resolution - 1) * size;
+        heightData[row * resolution + col] = sampler(wx, wz);
+      }
+    }
+    const chunk = {
+      id: `chunk_${_chunkId++}`,
+      level,
+      x,
+      z,
+      size,
+      resolution,
+      heightData,
+      morphFactor: 0,
+      active: true,
+      children: []
+    };
+    this.chunks.set(chunk.id, chunk);
+    if (level < this.config.maxLOD - 1) {
+      const half = size / 2;
+      chunk.children = [
+        this.subdivide(x, z, half, level + 1, sampler),
+        this.subdivide(x + half, z, half, level + 1, sampler),
+        this.subdivide(x, z + half, half, level + 1, sampler),
+        this.subdivide(x + half, z + half, half, level + 1, sampler)
+      ];
+    }
+    return chunk.id;
+  }
+  // ---------------------------------------------------------------------------
+  // LOD Selection
+  // ---------------------------------------------------------------------------
+  selectLOD(cameraX, cameraZ) {
+    this.activeChunks.clear();
+    for (const chunk of this.chunks.values()) {
+      const cx = chunk.x + chunk.size / 2;
+      const cz = chunk.z + chunk.size / 2;
+      const dx = cx - cameraX;
+      const dz = cz - cameraZ;
+      const dist = Math.sqrt(dx * dx + dz * dz);
+      const threshold = this.config.lodDistances[chunk.level] ?? Infinity;
+      const morphStart = threshold * (1 - this.config.morphRange);
+      if (dist < threshold) {
+        chunk.active = true;
+        chunk.morphFactor = dist > morphStart ? (dist - morphStart) / (threshold - morphStart) : 0;
+        this.activeChunks.add(chunk.id);
+      } else {
+        chunk.active = false;
+        chunk.morphFactor = 1;
+      }
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Stitching
+  // ---------------------------------------------------------------------------
+  getStitchEdges(chunkId) {
+    const chunk = this.chunks.get(chunkId);
+    if (!chunk) return { north: false, south: false, east: false, west: false };
+    const result = { north: false, south: false, east: false, west: false };
+    for (const other of this.chunks.values()) {
+      if (other.id === chunkId || !other.active || other.level === chunk.level) continue;
+      if (Math.abs(other.z + other.size - chunk.z) < 0.1 && this.overlapsX(chunk, other))
+        result.north = true;
+      if (Math.abs(chunk.z + chunk.size - other.z) < 0.1 && this.overlapsX(chunk, other))
+        result.south = true;
+      if (Math.abs(other.x + other.size - chunk.x) < 0.1 && this.overlapsZ(chunk, other))
+        result.west = true;
+      if (Math.abs(chunk.x + chunk.size - other.x) < 0.1 && this.overlapsZ(chunk, other))
+        result.east = true;
+    }
+    return result;
+  }
+  overlapsX(a, b) {
+    return a.x < b.x + b.size && a.x + a.size > b.x;
+  }
+  overlapsZ(a, b) {
+    return a.z < b.z + b.size && a.z + a.size > b.z;
+  }
+  // ---------------------------------------------------------------------------
+  // Queries
+  // ---------------------------------------------------------------------------
+  getChunk(id) {
+    return this.chunks.get(id);
+  }
+  getActiveChunks() {
+    return [...this.chunks.values()].filter((c) => c.active);
+  }
+  getActiveChunkCount() {
+    return this.activeChunks.size;
+  }
+  getTotalChunkCount() {
+    return this.chunks.size;
+  }
+  sampleHeight(x, z) {
+    for (const chunk of this.chunks.values()) {
+      if (!chunk.active) continue;
+      if (x >= chunk.x && x < chunk.x + chunk.size && z >= chunk.z && z < chunk.z + chunk.size) {
+        const lx = (x - chunk.x) / chunk.size;
+        const lz = (z - chunk.z) / chunk.size;
+        const col = Math.min(chunk.resolution - 1, Math.floor(lx * (chunk.resolution - 1)));
+        const row = Math.min(chunk.resolution - 1, Math.floor(lz * (chunk.resolution - 1)));
+        return chunk.heightData[row * chunk.resolution + col];
+      }
+    }
+    return 0;
+  }
+};
+
+// src/terrain/TerrainPaintLayer.ts
+var TerrainPaintLayer = class {
+  layers = [];
+  splatMap = /* @__PURE__ */ new Map();
+  gridSize;
+  undoStack = [];
+  constructor(gridSize = 64) {
+    this.gridSize = gridSize;
+  }
+  /**
+   * Add a texture layer
+   */
+  addLayer(layer) {
+    this.layers.push(layer);
+    const idx = this.layers.length - 1;
+    for (const weights of this.splatMap.values()) {
+      weights.weights.push(0);
+    }
+    if (idx === 0) {
+      for (let x = 0; x < this.gridSize; x++) {
+        for (let z = 0; z < this.gridSize; z++) {
+          this.splatMap.set(`${x},${z}`, { weights: [1] });
+        }
+      }
+    }
+    return idx;
+  }
+  /**
+   * Remove a layer by index
+   */
+  removeLayer(index) {
+    if (index < 0 || index >= this.layers.length) return false;
+    this.layers.splice(index, 1);
+    for (const entry of this.splatMap.values()) {
+      entry.weights.splice(index, 1);
+      this.normalizeWeights(entry.weights);
+    }
+    return true;
+  }
+  /**
+   * Paint a layer at a position with given weight
+   */
+  paintAt(x, z, layerIndex, weight, radius = 1) {
+    if (layerIndex < 0 || layerIndex >= this.layers.length) return 0;
+    const snapshot = /* @__PURE__ */ new Map();
+    let painted = 0;
+    const r = Math.ceil(radius);
+    for (let dx = -r; dx <= r; dx++) {
+      for (let dz = -r; dz <= r; dz++) {
+        const dist = Math.sqrt(dx * dx + dz * dz);
+        if (dist > radius) continue;
+        const key = `${x + dx},${z + dz}`;
+        let entry = this.splatMap.get(key);
+        if (!entry) {
+          entry = { weights: new Array(this.layers.length).fill(0) };
+          if (entry.weights.length > 0) entry.weights[0] = 1;
+          this.splatMap.set(key, entry);
+        }
+        snapshot.set(key, [...entry.weights]);
+        const falloff = 1 - dist / radius;
+        const targetWeight = weight * falloff;
+        entry.weights[layerIndex] = Math.min(1, entry.weights[layerIndex] + targetWeight);
+        this.normalizeWeights(entry.weights);
+        painted++;
+      }
+    }
+    this.undoStack.push(snapshot);
+    return painted;
+  }
+  /**
+   * Get weights at a position
+   */
+  getWeights(x, z) {
+    return this.splatMap.get(`${x},${z}`)?.weights ?? [];
+  }
+  /**
+   * Get dominant layer at a position
+   */
+  getDominantLayer(x, z) {
+    const weights = this.getWeights(x, z);
+    if (weights.length === 0) return -1;
+    let maxIdx = 0;
+    for (let i = 1; i < weights.length; i++) {
+      if (weights[i] > weights[maxIdx]) maxIdx = i;
+    }
+    return maxIdx;
+  }
+  /**
+   * Undo last paint operation
+   */
+  undo() {
+    const snapshot = this.undoStack.pop();
+    if (!snapshot) return false;
+    for (const [key, weights] of snapshot) {
+      const entry = this.splatMap.get(key);
+      if (entry) entry.weights = weights;
+    }
+    return true;
+  }
+  /**
+   * Normalize weights to sum to 1
+   */
+  normalizeWeights(weights) {
+    const sum = weights.reduce((a, b) => a + b, 0);
+    if (sum > 0) {
+      for (let i = 0; i < weights.length; i++) weights[i] /= sum;
+    }
+  }
+  /**
+   * Get layer definitions
+   */
+  getLayers() {
+    return [...this.layers];
+  }
+  getLayerCount() {
+    return this.layers.length;
+  }
+  getUndoCount() {
+    return this.undoStack.length;
+  }
+};
+
+// src/terrain/TerrainTexturing.ts
+var TerrainTexturing = class {
+  layers = [];
+  splatmap = null;
+  triplanar = { sharpness: 4, tiling: 1, enabled: false };
+  detailLayers = [];
+  // ---------------------------------------------------------------------------
+  // Layers
+  // ---------------------------------------------------------------------------
+  addLayer(layer) {
+    if (this.layers.length >= 16) throw new Error("Max 16 terrain layers");
+    this.layers.push(layer);
+  }
+  getLayer(index) {
+    return this.layers[index];
+  }
+  getLayerCount() {
+    return this.layers.length;
+  }
+  removeLayer(id) {
+    this.layers = this.layers.filter((l) => l.id !== id);
+  }
+  // ---------------------------------------------------------------------------
+  // Splatmap
+  // ---------------------------------------------------------------------------
+  createSplatmap(width, height, channelCount = 4) {
+    const channels = [];
+    for (let i = 0; i < channelCount; i++) {
+      const data = new Float32Array(width * height);
+      if (i === 0) data.fill(1);
+      channels.push(data);
+    }
+    this.splatmap = { width, height, channels };
+    return this.splatmap;
+  }
+  paintSplatmap(channel, x, z, radius, strength, _heightMap) {
+    if (!this.splatmap || channel >= this.splatmap.channels.length) return;
+    const w = this.splatmap.width, h = this.splatmap.height;
+    const px = Math.floor(x * w), pz = Math.floor(z * h);
+    const r = Math.floor(radius * Math.min(w, h));
+    for (let dy = -r; dy <= r; dy++) {
+      for (let dx = -r; dx <= r; dx++) {
+        const sx = px + dx, sz = pz + dy;
+        if (sx < 0 || sx >= w || sz < 0 || sz >= h) continue;
+        const dist = Math.sqrt(dx * dx + dy * dy) / r;
+        if (dist > 1) continue;
+        const falloff = 1 - dist * dist;
+        const idx = sz * w + sx;
+        this.splatmap.channels[channel][idx] = Math.min(
+          1,
+          this.splatmap.channels[channel][idx] + strength * falloff
+        );
+        this.normalizeSplatAt(idx);
+      }
+    }
+  }
+  normalizeSplatAt(idx) {
+    if (!this.splatmap) return;
+    let total = 0;
+    for (const ch of this.splatmap.channels) total += ch[idx];
+    if (total > 0) {
+      for (const ch of this.splatmap.channels) ch[idx] /= total;
+    }
+  }
+  getSplatWeights(x, z) {
+    if (!this.splatmap) return [1, 0, 0, 0];
+    const w = this.splatmap.width, h = this.splatmap.height;
+    const px = Math.min(w - 1, Math.max(0, Math.floor(x * w)));
+    const pz = Math.min(h - 1, Math.max(0, Math.floor(z * h)));
+    const idx = pz * w + px;
+    return this.splatmap.channels.map((ch) => ch[idx]);
+  }
+  // ---------------------------------------------------------------------------
+  // Triplanar
+  // ---------------------------------------------------------------------------
+  setTriplanar(config) {
+    Object.assign(this.triplanar, config);
+  }
+  getTriplanar() {
+    return { ...this.triplanar };
+  }
+  computeTriplanarWeights(normal) {
+    const s = this.triplanar.sharpness;
+    const ax = Math.pow(Math.abs(normal.x), s);
+    const ay = Math.pow(Math.abs(normal.y), s);
+    const az = Math.pow(Math.abs(normal.z), s);
+    const total = ax + ay + az || 1;
+    return { x: ax / total, y: ay / total, z: az / total };
+  }
+  // ---------------------------------------------------------------------------
+  // Detail Layers
+  // ---------------------------------------------------------------------------
+  addDetailLayer(layerIndex, distance, tiling) {
+    this.detailLayers.push({ layerIndex, distance, tiling });
+  }
+  getDetailLayers() {
+    return [...this.detailLayers];
+  }
+};
+
+// src/terrain/ErosionBrush.ts
+var ErosionBrush = class {
+  heightmap = /* @__PURE__ */ new Map();
+  config;
+  gridSize;
+  constructor(gridSize = 64, config) {
+    this.gridSize = gridSize;
+    this.config = {
+      type: config?.type ?? "hydraulic",
+      radius: config?.radius ?? 5,
+      strength: config?.strength ?? 0.5,
+      iterations: config?.iterations ?? 10,
+      sedimentCapacity: config?.sedimentCapacity ?? 0.1,
+      thermalAngle: config?.thermalAngle ?? 45
+    };
+    for (let x = 0; x < gridSize; x++) {
+      for (let z = 0; z < gridSize; z++) {
+        this.heightmap.set(`${x},${z}`, 0);
+      }
+    }
+  }
+  /**
+   * Set heightmap data
+   */
+  setHeight(x, z, h) {
+    this.heightmap.set(`${x},${z}`, h);
+  }
+  getHeight(x, z) {
+    return this.heightmap.get(`${x},${z}`) ?? 0;
+  }
+  /**
+   * Apply erosion at a center position
+   */
+  erode(cx, cz, overrides) {
+    const cfg = { ...this.config, ...overrides };
+    let totalErosion = 0;
+    let totalDeposition = 0;
+    let cellsAffected = 0;
+    const r = Math.ceil(cfg.radius);
+    for (let iter = 0; iter < cfg.iterations; iter++) {
+      for (let dx = -r; dx <= r; dx++) {
+        for (let dz = -r; dz <= r; dz++) {
+          const dist = Math.sqrt(dx * dx + dz * dz);
+          if (dist > cfg.radius) continue;
+          const x = cx + dx;
+          const z = cz + dz;
+          const key = `${x},${z}`;
+          const h = this.heightmap.get(key);
+          if (h === void 0) continue;
+          if (cfg.type === "hydraulic") {
+            const neighbors = this.getNeighborHeights(x, z);
+            const avgNeighbor = neighbors.reduce((a, b) => a + b, 0) / (neighbors.length || 1);
+            const diff = h - avgNeighbor;
+            if (diff > 0) {
+              const erosion = Math.min(diff * cfg.strength * 0.1, cfg.sedimentCapacity);
+              this.heightmap.set(key, h - erosion);
+              totalErosion += erosion;
+              cellsAffected++;
+            } else if (diff < 0) {
+              const deposit = Math.abs(diff) * cfg.strength * 0.05;
+              this.heightmap.set(key, h + deposit);
+              totalDeposition += deposit;
+            }
+          } else if (cfg.type === "thermal") {
+            const neighbors = this.getNeighborHeights(x, z);
+            const minNeighbor = Math.min(...neighbors, h);
+            const slope = h - minNeighbor;
+            const maxSlope = Math.tan(cfg.thermalAngle * Math.PI / 180);
+            if (slope > maxSlope) {
+              const transfer = (slope - maxSlope) * cfg.strength * 0.1;
+              this.heightmap.set(key, h - transfer);
+              totalErosion += transfer;
+              cellsAffected++;
+            }
+          } else {
+            const neighbors = this.getNeighborHeights(x, z);
+            const maxN = Math.max(...neighbors, 0);
+            if (h > maxN) {
+              const erosion = (h - maxN) * cfg.strength * 0.05;
+              this.heightmap.set(key, h - erosion);
+              totalErosion += erosion;
+              cellsAffected++;
+            }
+          }
+        }
+      }
+    }
+    return { cellsAffected, totalErosion, totalDeposition, iterations: cfg.iterations };
+  }
+  getNeighborHeights(x, z) {
+    const offsets = [
+      [-1, 0],
+      [1, 0],
+      [0, -1],
+      [0, 1]
+    ];
+    const result = [];
+    for (const [dx, dz] of offsets) {
+      const h = this.heightmap.get(`${x + dx},${z + dz}`);
+      if (h !== void 0) result.push(h);
+    }
+    return result;
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  setConfig(cfg) {
+    Object.assign(this.config, cfg);
+  }
+  getGridSize() {
+    return this.gridSize;
+  }
+};
+
+// src/terrain/ErosionSim.ts
+var ErosionSim = class {
+  config;
+  constructor(config) {
+    this.config = {
+      iterations: 5e4,
+      rainAmount: 1,
+      solubility: 0.01,
+      evaporationRate: 0.02,
+      depositionRate: 0.3,
+      gravity: 4,
+      thermalAngle: 45,
+      thermalRate: 0.5,
+      seed: 42,
+      ...config
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Hydraulic Erosion (Raindrop)
+  // ---------------------------------------------------------------------------
+  hydraulicErode(heightmap, width, height) {
+    let totalEroded = 0;
+    let totalDeposited = 0;
+    let maxDepthChange = 0;
+    let rng = this.config.seed;
+    const rand = () => {
+      rng = rng * 1103515245 + 12345 & 2147483647;
+      return rng / 2147483647;
+    };
+    for (let iter = 0; iter < this.config.iterations; iter++) {
+      let x = rand() * (width - 2) + 1;
+      let z = rand() * (height - 2) + 1;
+      let water = this.config.rainAmount;
+      let sediment = 0;
+      let speed = 1;
+      for (let step = 0; step < 64; step++) {
+        const ix = Math.floor(x), iz = Math.floor(z);
+        if (ix < 1 || ix >= width - 1 || iz < 1 || iz >= height - 1) break;
+        const idx = iz * width + ix;
+        const h = heightmap[idx];
+        const gx = heightmap[idx + 1] - heightmap[idx - 1];
+        const gz = heightmap[idx + width] - heightmap[idx - width];
+        const gradLen = Math.sqrt(gx * gx + gz * gz) || 1e-3;
+        x -= gx / gradLen;
+        z -= gz / gradLen;
+        const newIx = Math.floor(x), newIz = Math.floor(z);
+        if (newIx < 0 || newIx >= width || newIz < 0 || newIz >= height) break;
+        const newH = heightmap[newIz * width + newIx];
+        const dh = h - newH;
+        const capacity = Math.max(dh, 0.01) * speed * water * this.config.solubility;
+        if (sediment > capacity || dh < 0) {
+          const deposit = dh < 0 ? Math.min(sediment, -dh) : (sediment - capacity) * this.config.depositionRate;
+          heightmap[idx] += deposit;
+          sediment -= deposit;
+          totalDeposited += deposit;
+          maxDepthChange = Math.max(maxDepthChange, deposit);
+        } else {
+          const erosion = Math.min((capacity - sediment) * this.config.solubility, h * 0.1);
+          heightmap[idx] -= erosion;
+          sediment += erosion;
+          totalEroded += erosion;
+          maxDepthChange = Math.max(maxDepthChange, erosion);
+        }
+        speed = Math.sqrt(Math.max(0, speed * speed + dh * this.config.gravity));
+        water *= 1 - this.config.evaporationRate;
+        if (water < 1e-3) break;
+      }
+    }
+    return { totalEroded, totalDeposited, iterations: this.config.iterations, maxDepthChange };
+  }
+  // ---------------------------------------------------------------------------
+  // Thermal Erosion
+  // ---------------------------------------------------------------------------
+  thermalErode(heightmap, width, height, iterations) {
+    const maxSlope = Math.tan(this.config.thermalAngle * Math.PI / 180);
+    const iters = iterations ?? Math.floor(this.config.iterations / 10);
+    let totalEroded = 0;
+    let totalDeposited = 0;
+    let maxDepthChange = 0;
+    const offsets = [
+      [-1, 0],
+      [1, 0],
+      [0, -1],
+      [0, 1]
+    ];
+    for (let iter = 0; iter < iters; iter++) {
+      for (let z = 1; z < height - 1; z++) {
+        for (let x = 1; x < width - 1; x++) {
+          const idx = z * width + x;
+          const h = heightmap[idx];
+          let maxDh = 0;
+          let steepestIdx = -1;
+          for (const [dx, dz] of offsets) {
+            const nIdx = (z + dz) * width + (x + dx);
+            const dh = h - heightmap[nIdx];
+            if (dh > maxDh) {
+              maxDh = dh;
+              steepestIdx = nIdx;
+            }
+          }
+          if (maxDh > maxSlope && steepestIdx >= 0) {
+            const transfer = (maxDh - maxSlope) * this.config.thermalRate * 0.5;
+            heightmap[idx] -= transfer;
+            heightmap[steepestIdx] += transfer;
+            totalEroded += transfer;
+            totalDeposited += transfer;
+            maxDepthChange = Math.max(maxDepthChange, transfer);
+          }
+        }
+      }
+    }
+    return { totalEroded, totalDeposited, iterations: iters, maxDepthChange };
+  }
+  // ---------------------------------------------------------------------------
+  // Config
+  // ---------------------------------------------------------------------------
+  setConfig(config) {
+    Object.assign(this.config, config);
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+};
+
+export {
+  TerrainBrush,
+  TerrainLOD,
+  TerrainPaintLayer,
+  TerrainTexturing,
+  ErosionBrush,
+  ErosionSim,
+  terrain_exports
+};