@nice2dev/game-engine 1.3.15 → 1.3.16

package/dist/esm/systems/TerrainSystem.js

@@ -1,1124 +1,1023 @@
-/**
- * @file TerrainSystem.ts
- * @description Advanced Terrain System with Heightmap, Splatmap, and Foliage
- * PRO-1.4: Professional Editor Features
- *
- * Features:
- * - Heightmap terrain with LOD
- * - Splatmap texture blending (up to 8 layers)
- * - Foliage scattering (grass, trees, rocks)
- * - Terrain brushes (raise, lower, smooth, flatten, noise, erosion)
- * - Procedural generation (Perlin noise, diamond-square, hydraulic erosion)
- * - Holes/caves support
- * - Detail meshes and decals
- * - Terrain chunks with streaming
- * - Physics collision mesh generation
- */
 const DEFAULT_TERRAIN_CONFIG = {
-    width: 1000,
-    depth: 1000,
-    maxHeight: 100,
-    heightmapResolution: 513, // Power of 2 + 1 for LOD
-    splatmapResolution: 512,
-    chunksPerSide: 4,
-    detailResolution: 1024,
-    detailResolutionPerPatch: 8,
-    basemapDistance: 1000,
-    castShadows: true,
-    drawInstanced: true,
+  width: 1e3,
+  depth: 1e3,
+  maxHeight: 100,
+  heightmapResolution: 513,
+  // Power of 2 + 1 for LOD
+  splatmapResolution: 512,
+  chunksPerSide: 4,
+  detailResolution: 1024,
+  detailResolutionPerPatch: 8,
+  basemapDistance: 1e3,
+  castShadows: true,
+  drawInstanced: true
 };
 function createTerrainLayer(id, name, diffuseTexture) {
-    return {
-        id,
-        name,
-        diffuseTexture,
-        tileSize: { x: 15, y: 15 },
-        tileOffset: { x: 0, y: 0 },
-        metallic: 0,
-        smoothness: 0.5,
-        specularColor: { r: 0.2, g: 0.2, b: 0.2, a: 1 },
-        normalScale: 1,
-        diffuseRemapMin: { r: 0, g: 0, b: 0, a: 0 },
-        diffuseRemapMax: { r: 1, g: 1, b: 1, a: 1 },
-        maskRemapMin: { r: 0, g: 0, b: 0, a: 0 },
-        maskRemapMax: { r: 1, g: 1, b: 1, a: 1 },
-    };
+  return {
+    id,
+    name,
+    diffuseTexture,
+    tileSize: { x: 15, y: 15 },
+    tileOffset: { x: 0, y: 0 },
+    metallic: 0,
+    smoothness: 0.5,
+    specularColor: { r: 0.2, g: 0.2, b: 0.2, a: 1 },
+    normalScale: 1,
+    diffuseRemapMin: { r: 0, g: 0, b: 0, a: 0 },
+    diffuseRemapMax: { r: 1, g: 1, b: 1, a: 1 },
+    maskRemapMin: { r: 0, g: 0, b: 0, a: 0 },
+    maskRemapMax: { r: 1, g: 1, b: 1, a: 1 }
+  };
 }
 function createGrassDetail(id, name, textureId) {
-    return {
-        id,
-        name,
-        textureId,
-        renderMode: 'grass',
-        useInstancing: true,
-        healthyColor: { r: 0.26, g: 0.8, b: 0.28, a: 1 },
-        dryColor: { r: 0.8, g: 0.72, b: 0.28, a: 1 },
-        minWidth: 0.8,
-        maxWidth: 1.2,
-        minHeight: 0.4,
-        maxHeight: 0.8,
-        noiseSpread: 0.1,
-        density: 1,
-        alignToGround: 0.5,
-        positionJitter: 0.5,
-        holeEdgePadding: 0,
-    };
+  return {
+    id,
+    name,
+    textureId,
+    renderMode: "grass",
+    useInstancing: true,
+    healthyColor: { r: 0.26, g: 0.8, b: 0.28, a: 1 },
+    dryColor: { r: 0.8, g: 0.72, b: 0.28, a: 1 },
+    minWidth: 0.8,
+    maxWidth: 1.2,
+    minHeight: 0.4,
+    maxHeight: 0.8,
+    noiseSpread: 0.1,
+    density: 1,
+    alignToGround: 0.5,
+    positionJitter: 0.5,
+    holeEdgePadding: 0
+  };
 }
 function createTreePrototype(id, name, meshId) {
-    return {
-        id,
-        name,
-        meshId,
-        lodMeshes: [],
-        bendFactor: 1,
-        minScale: 0.8,
-        maxScale: 1.2,
-        randomRotation: true,
-        alignToGround: 0.5,
-        navMeshArea: 0,
-    };
+  return {
+    id,
+    name,
+    meshId,
+    lodMeshes: [],
+    bendFactor: 1,
+    minScale: 0.8,
+    maxScale: 1.2,
+    randomRotation: true,
+    alignToGround: 0.5,
+    navMeshArea: 0
+  };
 }
 const DEFAULT_BRUSH = {
-    type: 'raise',
-    size: 10,
-    strength: 0.5,
-    falloff: 0.5,
-    rotation: 0,
-    spacingJitter: 0,
-    scatter: 0,
+  type: "raise",
+  size: 10,
+  strength: 0.5,
+  falloff: 0.5,
+  rotation: 0,
+  spacingJitter: 0,
+  scatter: 0
 };
-// ============================================================
-// Terrain System Class
-// ============================================================
 class TerrainSystem {
-    constructor(config) {
-        this.undoStack = [];
-        this.redoStack = [];
-        this.maxUndoSteps = 50;
-        this.data = this.createEmptyTerrain(config);
-    }
-    createEmptyTerrain(configOverride) {
-        const config = { ...DEFAULT_TERRAIN_CONFIG, ...configOverride };
-        const hmRes = config.heightmapResolution;
-        const smRes = config.splatmapResolution;
-        config.detailResolution;
-        const chunks = config.chunksPerSide;
-        // Initialize heightmap
-        const heightmap = new Float32Array(hmRes * hmRes);
-        // Initialize splatmaps (2 textures for 8 layers)
-        const splatmaps = [
-            new Uint8Array(smRes * smRes * 4),
-            new Uint8Array(smRes * smRes * 4),
-        ];
-        // Set first layer to full coverage by default
-        for (let i = 0; i < smRes * smRes; i++) {
-            splatmaps[0][i * 4] = 255; // Layer 0 = 100%
-        }
-        // Initialize holemap (all solid)
-        const holemap = new Uint8Array(hmRes * hmRes);
-        holemap.fill(1);
-        // Create chunks
-        const chunkList = [];
-        const chunkWidth = config.width / chunks;
-        const chunkDepth = config.depth / chunks;
-        for (let gz = 0; gz < chunks; gz++) {
-            for (let gx = 0; gx < chunks; gx++) {
-                chunkList.push({
-                    id: `chunk_${gx}_${gz}`,
-                    gridX: gx,
-                    gridZ: gz,
-                    boundsMin: {
-                        x: gx * chunkWidth - config.width / 2,
-                        y: 0,
-                        z: gz * chunkDepth - config.depth / 2,
-                    },
-                    boundsMax: {
-                        x: (gx + 1) * chunkWidth - config.width / 2,
-                        y: config.maxHeight,
-                        z: (gz + 1) * chunkDepth - config.depth / 2,
-                    },
-                    isLoaded: gx < 2 && gz < 2, // Load center chunks
-                    lodLevel: 0,
-                });
-            }
-        }
-        return {
-            id: `terrain_${Date.now()}`,
-            name: 'New Terrain',
-            config,
-            heightmap,
-            splatmaps,
-            holemap,
-            layers: [],
-            detailPrototypes: [],
-            detailMaps: [],
-            treePrototypes: [],
-            trees: [],
-            chunks: chunkList,
-            metadata: {
-                createdAt: Date.now(),
-                modifiedAt: Date.now(),
-                version: 1,
-            },
-        };
-    }
-    // ─── Heightmap Operations ──────────────────────────────
-    /** Get height at grid coordinates (0 to resolution-1) */
-    getHeightAtGrid(gridX, gridZ) {
-        const res = this.data.config.heightmapResolution;
-        const x = Math.max(0, Math.min(res - 1, Math.floor(gridX)));
-        const z = Math.max(0, Math.min(res - 1, Math.floor(gridZ)));
-        return this.data.heightmap[z * res + x] * this.data.config.maxHeight;
-    }
-    /** Set height at grid coordinates */
-    setHeightAtGrid(gridX, gridZ, height, recordUndo = true) {
-        const res = this.data.config.heightmapResolution;
-        const maxH = this.data.config.maxHeight;
-        if (gridX < 0 || gridX >= res || gridZ < 0 || gridZ >= res) {
-            return;
-        }
-        const idx = gridZ * res + gridX;
-        const normalizedHeight = Math.max(0, Math.min(1, height / maxH));
-        if (recordUndo) {
-            this.recordHeightChange(gridX, gridZ, this.data.heightmap[idx], normalizedHeight);
-        }
-        this.data.heightmap[idx] = normalizedHeight;
-        this.data.metadata.modifiedAt = Date.now();
-    }
-    /** Get interpolated height at world coordinates */
-    getHeightAtWorld(worldX, worldZ) {
-        const { width, depth, heightmapResolution: res } = this.data.config;
-        // Convert world to grid
-        const gx = ((worldX + width / 2) / width) * (res - 1);
-        const gz = ((worldZ + depth / 2) / depth) * (res - 1);
-        // Bilinear interpolation
-        const ix = Math.floor(gx);
-        const iz = Math.floor(gz);
-        const fx = gx - ix;
-        const fz = gz - iz;
-        const h00 = this.getHeightAtGrid(ix, iz);
-        const h10 = this.getHeightAtGrid(ix + 1, iz);
-        const h01 = this.getHeightAtGrid(ix, iz + 1);
-        const h11 = this.getHeightAtGrid(ix + 1, iz + 1);
-        const h0 = h00 + (h10 - h00) * fx;
-        const h1 = h01 + (h11 - h01) * fx;
-        return h0 + (h1 - h0) * fz;
-    }
-    /** Convert world position to grid coordinates */
-    worldToGrid(worldX, worldZ) {
-        const { width, depth, heightmapResolution: res } = this.data.config;
-        return {
-            x: ((worldX + width / 2) / width) * (res - 1),
-            y: ((worldZ + depth / 2) / depth) * (res - 1),
-        };
-    }
-    /** Convert grid coordinates to world position */
-    gridToWorld(gridX, gridZ) {
-        const { width, depth, heightmapResolution: res } = this.data.config;
-        const worldX = (gridX / (res - 1)) * width - width / 2;
-        const worldZ = (gridZ / (res - 1)) * depth - depth / 2;
-        const worldY = this.getHeightAtGrid(gridX, gridZ);
-        return { x: worldX, y: worldY, z: worldZ };
-    }
-    /// Get terrain normal at world position
-    getNormalAtWorld(worldX, worldZ) {
-        const { width, depth, heightmapResolution: res } = this.data.config;
-        const cellWidth = width / (res - 1);
-        const cellDepth = depth / (res - 1);
-        const hL = this.getHeightAtWorld(worldX - cellWidth, worldZ);
-        const hR = this.getHeightAtWorld(worldX + cellWidth, worldZ);
-        const hD = this.getHeightAtWorld(worldX, worldZ - cellDepth);
-        const hU = this.getHeightAtWorld(worldX, worldZ + cellDepth);
-        // Cross product to get normal
-        const dx = hR - hL;
-        const dz = hU - hD;
-        const nx = -dx / (2 * cellWidth);
-        const ny = 1;
-        const nz = -dz / (2 * cellDepth);
-        // Normalize
-        const len = Math.sqrt(nx * nx + ny * ny + nz * nz);
-        return { x: nx / len, y: ny / len, z: nz / len };
-    }
-    // ─── Brush Operations ──────────────────────────────────
-    applyBrush(brush, worldX, worldZ) {
-        switch (brush.type) {
-            case 'raise':
-                this.applyHeightBrush(worldX, worldZ, brush, 1);
-                break;
-            case 'lower':
-                this.applyHeightBrush(worldX, worldZ, brush, -1);
-                break;
-            case 'flatten':
-                this.applyFlattenBrush(worldX, worldZ, brush);
-                break;
-            case 'smooth':
-                this.applySmoothBrush(worldX, worldZ, brush);
-                break;
-            case 'noise':
-                this.applyNoiseBrush(worldX, worldZ, brush);
-                break;
-            case 'erosion':
-                this.applyErosionBrush(worldX, worldZ, brush);
-                break;
-            case 'paint':
-                this.applyPaintBrush(worldX, worldZ, brush);
-                break;
-            case 'paintHoles':
-                this.applyHoleBrush(worldX, worldZ, brush);
-                break;
-            case 'stampHeight':
-                this.applyStampBrush(worldX, worldZ, brush);
-                break;
-        }
-    }
-    applyHeightBrush(worldX, worldZ, brush, direction) {
-        const grid = this.worldToGrid(worldX, worldZ);
-        const { heightmapResolution: res, width, maxHeight } = this.data.config;
-        const gridRadius = (brush.size / (width / (res - 1))) * 0.5;
-        const delta = (brush.strength * direction * maxHeight) / 100;
-        const minX = Math.max(0, Math.floor(grid.x - gridRadius));
-        const maxX = Math.min(res - 1, Math.ceil(grid.x + gridRadius));
-        const minZ = Math.max(0, Math.floor(grid.y - gridRadius));
-        const maxZ = Math.min(res - 1, Math.ceil(grid.y + gridRadius));
-        for (let gz = minZ; gz <= maxZ; gz++) {
-            for (let gx = minX; gx <= maxX; gx++) {
-                const dx = gx - grid.x;
-                const dz = gz - grid.y;
-                const dist = Math.sqrt(dx * dx + dz * dz);
-                if (dist <= gridRadius) {
-                    const falloff = this.calculateFalloff(dist / gridRadius, brush.falloff);
-                    const currentHeight = this.getHeightAtGrid(gx, gz);
-                    const newHeight = currentHeight + delta * falloff;
-                    this.setHeightAtGrid(gx, gz, newHeight);
-                }
-            }
-        }
-    }
-    applyFlattenBrush(worldX, worldZ, brush) {
-        const grid = this.worldToGrid(worldX, worldZ);
-        const { heightmapResolution: res, width } = this.data.config;
-        const gridRadius = (brush.size / (width / (res - 1))) * 0.5;
-        const targetHeight = brush.targetHeight ?? this.getHeightAtWorld(worldX, worldZ);
-        const minX = Math.max(0, Math.floor(grid.x - gridRadius));
-        const maxX = Math.min(res - 1, Math.ceil(grid.x + gridRadius));
-        const minZ = Math.max(0, Math.floor(grid.y - gridRadius));
-        const maxZ = Math.min(res - 1, Math.ceil(grid.y + gridRadius));
-        for (let gz = minZ; gz <= maxZ; gz++) {
-            for (let gx = minX; gx <= maxX; gx++) {
-                const dx = gx - grid.x;
-                const dz = gz - grid.y;
-                const dist = Math.sqrt(dx * dx + dz * dz);
-                if (dist <= gridRadius) {
-                    const falloff = this.calculateFalloff(dist / gridRadius, brush.falloff);
-                    const currentHeight = this.getHeightAtGrid(gx, gz);
-                    const newHeight = currentHeight + (targetHeight - currentHeight) * falloff * brush.strength;
-                    this.setHeightAtGrid(gx, gz, newHeight);
-                }
-            }
-        }
-    }
-    applySmoothBrush(worldX, worldZ, brush) {
-        const grid = this.worldToGrid(worldX, worldZ);
-        const { heightmapResolution: res, width } = this.data.config;
-        const gridRadius = (brush.size / (width / (res - 1))) * 0.5;
-        const minX = Math.max(0, Math.floor(grid.x - gridRadius));
-        const maxX = Math.min(res - 1, Math.ceil(grid.x + gridRadius));
-        const minZ = Math.max(0, Math.floor(grid.y - gridRadius));
-        const maxZ = Math.min(res - 1, Math.ceil(grid.y + gridRadius));
-        // Collect heights first
-        const newHeights = [];
-        for (let gz = minZ; gz <= maxZ; gz++) {
-            for (let gx = minX; gx <= maxX; gx++) {
-                const dx = gx - grid.x;
-                const dz = gz - grid.y;
-                const dist = Math.sqrt(dx * dx + dz * dz);
-                if (dist <= gridRadius) {
-                    // Average of neighbors
-                    let sum = 0;
-                    let count = 0;
-                    for (let nz = -1; nz <= 1; nz++) {
-                        for (let nx = -1; nx <= 1; nx++) {
-                            const ngx = gx + nx;
-                            const ngz = gz + nz;
-                            if (ngx >= 0 && ngx < res && ngz >= 0 && ngz < res) {
-                                sum += this.getHeightAtGrid(ngx, ngz);
-                                count++;
-                            }
-                        }
-                    }
-                    const avgHeight = sum / count;
-                    const falloff = this.calculateFalloff(dist / gridRadius, brush.falloff);
-                    const currentHeight = this.getHeightAtGrid(gx, gz);
-                    const newHeight = currentHeight + (avgHeight - currentHeight) * falloff * brush.strength;
-                    newHeights.push({ gx, gz, height: newHeight });
-                }
-            }
-        }
-        // Apply new heights
-        for (const { gx, gz, height } of newHeights) {
-            this.setHeightAtGrid(gx, gz, height);
-        }
-    }
-    applyNoiseBrush(worldX, worldZ, brush) {
-        const grid = this.worldToGrid(worldX, worldZ);
-        const { heightmapResolution: res, width, maxHeight } = this.data.config;
-        const gridRadius = (brush.size / (width / (res - 1))) * 0.5;
-        const noiseScale = brush.noiseScale ?? 0.1;
-        const octaves = brush.noiseOctaves ?? 4;
-        const minX = Math.max(0, Math.floor(grid.x - gridRadius));
-        const maxX = Math.min(res - 1, Math.ceil(grid.x + gridRadius));
-        const minZ = Math.max(0, Math.floor(grid.y - gridRadius));
-        const maxZ = Math.min(res - 1, Math.ceil(grid.y + gridRadius));
-        for (let gz = minZ; gz <= maxZ; gz++) {
-            for (let gx = minX; gx <= maxX; gx++) {
-                const dx = gx - grid.x;
-                const dz = gz - grid.y;
-                const dist = Math.sqrt(dx * dx + dz * dz);
-                if (dist <= gridRadius) {
-                    const falloff = this.calculateFalloff(dist / gridRadius, brush.falloff);
-                    const noise = this.perlinNoise2D(gx * noiseScale, gz * noiseScale, octaves);
-                    const delta = noise * brush.strength * maxHeight * 0.1 * falloff;
-                    const currentHeight = this.getHeightAtGrid(gx, gz);
-                    this.setHeightAtGrid(gx, gz, currentHeight + delta);
-                }
-            }
-        }
-    }
-    applyErosionBrush(worldX, worldZ, brush) {
-        const grid = this.worldToGrid(worldX, worldZ);
-        const { heightmapResolution: res, width } = this.data.config;
-        const gridRadius = (brush.size / (width / (res - 1))) * 0.5;
-        const minX = Math.max(1, Math.floor(grid.x - gridRadius));
-        const maxX = Math.min(res - 2, Math.ceil(grid.x + gridRadius));
-        const minZ = Math.max(1, Math.floor(grid.y - gridRadius));
-        const maxZ = Math.min(res - 2, Math.ceil(grid.y + gridRadius));
-        // Simple thermal erosion
-        const newHeights = [];
-        const talusAngle = 0.5; // Adjustment factor
-        for (let gz = minZ; gz <= maxZ; gz++) {
-            for (let gx = minX; gx <= maxX; gx++) {
-                const dx = gx - grid.x;
-                const dz = gz - grid.y;
-                const dist = Math.sqrt(dx * dx + dz * dz);
-                if (dist <= gridRadius) {
-                    const falloff = this.calculateFalloff(dist / gridRadius, brush.falloff);
-                    const h = this.getHeightAtGrid(gx, gz);
-                    let totalDiff = 0;
-                    const neighbors = [
-                        this.getHeightAtGrid(gx - 1, gz),
-                        this.getHeightAtGrid(gx + 1, gz),
-                        this.getHeightAtGrid(gx, gz - 1),
-                        this.getHeightAtGrid(gx, gz + 1),
-                    ];
-                    for (const nh of neighbors) {
-                        const diff = h - nh;
-                        if (diff > talusAngle) {
-                            totalDiff += diff - talusAngle;
-                        }
-                    }
-                    // Erode if slope too steep
-                    if (totalDiff > 0) {
-                        const erosion = totalDiff * brush.strength * falloff * 0.25;
-                        newHeights.push({ gx, gz, height: h - erosion });
-                    }
-                }
-            }
-        }
-        // Apply erosion
-        for (const { gx, gz, height } of newHeights) {
-            this.setHeightAtGrid(gx, gz, height);
-        }
-    }
-    applyPaintBrush(worldX, worldZ, brush) {
-        const { splatmapResolution: res, width } = this.data.config;
-        const layerIndex = brush.layerIndex ?? 0;
-        if (layerIndex >= 8) {
-            return;
-        }
-        const splatmapIndex = Math.floor(layerIndex / 4);
-        const channelIndex = layerIndex % 4;
-        // Convert world to splatmap coords
-        const smX = ((worldX + width / 2) / width) * (res - 1);
-        const smZ = ((worldZ + width / 2) / width) * (res - 1);
-        const gridRadius = (brush.size / (width / (res - 1))) * 0.5;
-        const minX = Math.max(0, Math.floor(smX - gridRadius));
-        const maxX = Math.min(res - 1, Math.ceil(smX + gridRadius));
-        const minZ = Math.max(0, Math.floor(smZ - gridRadius));
-        const maxZ = Math.min(res - 1, Math.ceil(smZ + gridRadius));
-        const splatmap = this.data.splatmaps[splatmapIndex];
-        for (let z = minZ; z <= maxZ; z++) {
-            for (let x = minX; x <= maxX; x++) {
-                const dx = x - smX;
-                const dz = z - smZ;
-                const dist = Math.sqrt(dx * dx + dz * dz);
-                if (dist <= gridRadius) {
-                    const falloff = this.calculateFalloff(dist / gridRadius, brush.falloff);
-                    const idx = (z * res + x) * 4;
-                    const strength = brush.strength * falloff * 255;
-                    // Add to target channel
-                    const current = splatmap[idx + channelIndex];
-                    const newValue = Math.min(255, current + strength);
-                    splatmap[idx + channelIndex] = newValue;
-                    // Normalize all channels so they sum to 255
-                    this.normalizeSplatmapPixel(x, z);
-                }
-            }
-        }
-        this.data.metadata.modifiedAt = Date.now();
-    }
-    normalizeSplatmapPixel(x, z) {
-        const res = this.data.config.splatmapResolution;
-        let total = 0;
-        // Sum all 8 channels
-        for (let s = 0; s < 2; s++) {
-            const idx = (z * res + x) * 4;
-            for (let c = 0; c < 4; c++) {
-                total += this.data.splatmaps[s][idx + c];
-            }
-        }
-        // Normalize
-        if (total > 0) {
-            const scale = 255 / total;
-            for (let s = 0; s < 2; s++) {
-                const idx = (z * res + x) * 4;
-                for (let c = 0; c < 4; c++) {
-                    this.data.splatmaps[s][idx + c] = Math.round(this.data.splatmaps[s][idx + c] * scale);
-                }
-            }
-        }
-    }
-    applyHoleBrush(worldX, worldZ, brush) {
-        const { heightmapResolution: res, width } = this.data.config;
-        const gridCoords = this.worldToGrid(worldX, worldZ);
-        const gridRadius = (brush.size / (width / (res - 1))) * 0.5;
-        const isAddHole = brush.strength > 0;
-        const minX = Math.max(0, Math.floor(gridCoords.x - gridRadius));
-        const maxX = Math.min(res - 1, Math.ceil(gridCoords.x + gridRadius));
-        const minZ = Math.max(0, Math.floor(gridCoords.y - gridRadius));
-        const maxZ = Math.min(res - 1, Math.ceil(gridCoords.y + gridRadius));
-        for (let gz = minZ; gz <= maxZ; gz++) {
-            for (let gx = minX; gx <= maxX; gx++) {
-                const dx = gx - gridCoords.x;
-                const dz = gz - gridCoords.y;
-                const dist = Math.sqrt(dx * dx + dz * dz);
-                if (dist <= gridRadius) {
-                    this.data.holemap[gz * res + gx] = isAddHole ? 0 : 1;
-                }
-            }
-        }
-        this.data.metadata.modifiedAt = Date.now();
-    }
-    applyStampBrush(worldX, worldZ, brush) {
-        // TODO: Apply stamp texture as height
-        // For now, just raise
-        this.applyHeightBrush(worldX, worldZ, brush, 1);
-    }
-    calculateFalloff(t, falloffStrength) {
-        // t is 0 at center, 1 at edge
-        // falloffStrength: 0 = hard edge, 1 = very smooth
-        if (t >= 1) {
-            return 0;
-        }
-        if (falloffStrength <= 0) {
-            return 1;
-        }
-        const smoothT = t * t * (3 - 2 * t); // Smoothstep
-        const power = 1 + falloffStrength * 3;
-        return Math.pow(1 - smoothT, power);
-    }
-    // ─── Procedural Generation ─────────────────────────────
-    generatePerlinTerrain(scale = 0.01, octaves = 6, persistence = 0.5) {
-        const res = this.data.config.heightmapResolution;
-        for (let z = 0; z < res; z++) {
-            for (let x = 0; x < res; x++) {
-                const height = this.perlinNoise2D(x * scale, z * scale, octaves, persistence);
-                this.data.heightmap[z * res + x] = (height + 1) * 0.5; // Normalize to 0-1
-            }
-        }
-        this.data.metadata.modifiedAt = Date.now();
-    }
-    generateDiamondSquare(roughness = 0.5) {
-        const size = this.data.config.heightmapResolution;
-        // Initialize corners
-        this.data.heightmap[0] = Math.random();
-        this.data.heightmap[size - 1] = Math.random();
-        this.data.heightmap[(size - 1) * size] = Math.random();
-        this.data.heightmap[(size - 1) * size + size - 1] = Math.random();
-        let stepSize = size - 1;
-        let scale = roughness;
-        while (stepSize > 1) {
-            const halfStep = stepSize / 2;
-            // Diamond step
-            for (let z = halfStep; z < size - 1; z += stepSize) {
-                for (let x = halfStep; x < size - 1; x += stepSize) {
-                    const avg = (this.data.heightmap[(z - halfStep) * size + (x - halfStep)] +
-                        this.data.heightmap[(z - halfStep) * size + (x + halfStep)] +
-                        this.data.heightmap[(z + halfStep) * size + (x - halfStep)] +
-                        this.data.heightmap[(z + halfStep) * size + (x + halfStep)]) /
-                        4;
-                    this.data.heightmap[z * size + x] = avg + (Math.random() - 0.5) * scale;
-                }
-            }
-            // Square step
-            for (let z = 0; z < size; z += halfStep) {
-                for (let x = (z + halfStep) % stepSize; x < size; x += stepSize) {
-                    let sum = 0;
-                    let count = 0;
-                    if (z - halfStep >= 0) {
-                        sum += this.data.heightmap[(z - halfStep) * size + x];
-                        count++;
-                    }
-                    if (z + halfStep < size) {
-                        sum += this.data.heightmap[(z + halfStep) * size + x];
-                        count++;
-                    }
-                    if (x - halfStep >= 0) {
-                        sum += this.data.heightmap[z * size + (x - halfStep)];
-                        count++;
-                    }
-                    if (x + halfStep < size) {
-                        sum += this.data.heightmap[z * size + (x + halfStep)];
-                        count++;
-                    }
-                    this.data.heightmap[z * size + x] = sum / count + (Math.random() - 0.5) * scale;
-                }
-            }
-            stepSize = halfStep;
-            scale *= 0.5;
-        }
-        // Normalize
-        let min = Infinity;
-        let max = -Infinity;
-        for (let i = 0; i < this.data.heightmap.length; i++) {
-            min = Math.min(min, this.data.heightmap[i]);
-            max = Math.max(max, this.data.heightmap[i]);
-        }
-        const range = max - min;
-        if (range > 0) {
-            for (let i = 0; i < this.data.heightmap.length; i++) {
-                this.data.heightmap[i] = (this.data.heightmap[i] - min) / range;
-            }
-        }
-        this.data.metadata.modifiedAt = Date.now();
-    }
-    applyHydraulicErosion(iterations = 50000) {
-        const res = this.data.config.heightmapResolution;
-        const { maxHeight: _maxHeight } = this.data.config;
-        // Erosion parameters
-        const inertia = 0.05;
-        const sedimentCapacityFactor = 4;
-        const minSedimentCapacity = 0.01;
-        const erodeSpeed = 0.3;
-        const depositSpeed = 0.3;
-        const evaporateSpeed = 0.01;
-        const gravity = 4;
-        const maxDropletLifetime = 30;
-        const initialWaterVolume = 1;
-        const initialSpeed = 1;
-        for (let i = 0; i < iterations; i++) {
-            // Start at random position
-            let posX = Math.random() * (res - 1);
-            let posZ = Math.random() * (res - 1);
-            let dirX = 0;
-            let dirZ = 0;
-            let speed = initialSpeed;
-            let water = initialWaterVolume;
-            let sediment = 0;
-            for (let lifetime = 0; lifetime < maxDropletLifetime; lifetime++) {
-                const cellX = Math.floor(posX);
-                const cellZ = Math.floor(posZ);
-                const cellOffsetX = posX - cellX;
-                const cellOffsetZ = posZ - cellZ;
-                // Calculate gradient
-                const heightNW = this.data.heightmap[cellZ * res + cellX];
-                const heightNE = cellX < res - 1 ? this.data.heightmap[cellZ * res + cellX + 1] : heightNW;
-                const heightSW = cellZ < res - 1 ? this.data.heightmap[(cellZ + 1) * res + cellX] : heightNW;
-                const heightSE = cellX < res - 1 && cellZ < res - 1
-                    ? this.data.heightmap[(cellZ + 1) * res + cellX + 1]
-                    : heightNW;
-                const gradientX = (heightNE - heightNW) * (1 - cellOffsetZ) + (heightSE - heightSW) * cellOffsetZ;
-                const gradientZ = (heightSW - heightNW) * (1 - cellOffsetX) + (heightSE - heightNE) * cellOffsetX;
-                // Update direction with inertia
-                dirX = dirX * inertia - gradientX * (1 - inertia);
-                dirZ = dirZ * inertia - gradientZ * (1 - inertia);
-                // Normalize direction
-                const len = Math.sqrt(dirX * dirX + dirZ * dirZ);
-                if (len > 0) {
-                    dirX /= len;
-                    dirZ /= len;
-                }
-                // Move
-                posX += dirX;
-                posZ += dirZ;
-                // Check bounds
-                if (posX < 0 || posX >= res - 1 || posZ < 0 || posZ >= res - 1 || len === 0) {
-                    break;
-                }
-                // Calculate height difference
-                const newHeight = heightNW * (1 - cellOffsetX) * (1 - cellOffsetZ) +
-                    heightNE * cellOffsetX * (1 - cellOffsetZ) +
-                    heightSW * (1 - cellOffsetX) * cellOffsetZ +
-                    heightSE * cellOffsetX * cellOffsetZ;
-                const oldHeight = this.data.heightmap[cellZ * res + cellX] * (1 - cellOffsetX) * (1 - cellOffsetZ) +
-                    (cellX < res - 1
-                        ? this.data.heightmap[cellZ * res + cellX + 1]
-                        : this.data.heightmap[cellZ * res + cellX]) *
-                        cellOffsetX *
-                        (1 - cellOffsetZ) +
-                    (cellZ < res - 1
-                        ? this.data.heightmap[(cellZ + 1) * res + cellX]
-                        : this.data.heightmap[cellZ * res + cellX]) *
-                        (1 - cellOffsetX) *
-                        cellOffsetZ +
-                    (cellX < res - 1 && cellZ < res - 1
-                        ? this.data.heightmap[(cellZ + 1) * res + cellX + 1]
-                        : this.data.heightmap[cellZ * res + cellX]) *
-                        cellOffsetX *
-                        cellOffsetZ;
-                const heightDiff = newHeight - oldHeight;
-                // Calculate sediment capacity
-                const sedimentCapacity = Math.max(-heightDiff * speed * water * sedimentCapacityFactor, minSedimentCapacity);
-                // Deposit or erode
-                if (sediment > sedimentCapacity || heightDiff > 0) {
-                    // Deposit
-                    const depositAmount = heightDiff > 0
-                        ? Math.min(heightDiff, sediment)
-                        : (sediment - sedimentCapacity) * depositSpeed;
-                    sediment -= depositAmount;
-                    this.data.heightmap[cellZ * res + cellX] +=
-                        depositAmount * (1 - cellOffsetX) * (1 - cellOffsetZ);
-                    if (cellX < res - 1) {
-                        this.data.heightmap[cellZ * res + cellX + 1] +=
-                            depositAmount * cellOffsetX * (1 - cellOffsetZ);
-                    }
-                    if (cellZ < res - 1) {
-                        this.data.heightmap[(cellZ + 1) * res + cellX] +=
-                            depositAmount * (1 - cellOffsetX) * cellOffsetZ;
-                    }
-                    if (cellX < res - 1 && cellZ < res - 1) {
-                        this.data.heightmap[(cellZ + 1) * res + cellX + 1] +=
-                            depositAmount * cellOffsetX * cellOffsetZ;
-                    }
-                }
-                else {
-                    // Erode
-                    const erodeAmount = Math.min((sedimentCapacity - sediment) * erodeSpeed, -heightDiff);
-                    this.data.heightmap[cellZ * res + cellX] -=
-                        erodeAmount * (1 - cellOffsetX) * (1 - cellOffsetZ);
-                    if (cellX < res - 1) {
-                        this.data.heightmap[cellZ * res + cellX + 1] -=
-                            erodeAmount * cellOffsetX * (1 - cellOffsetZ);
-                    }
-                    if (cellZ < res - 1) {
-                        this.data.heightmap[(cellZ + 1) * res + cellX] -=
-                            erodeAmount * (1 - cellOffsetX) * cellOffsetZ;
-                    }
-                    if (cellX < res - 1 && cellZ < res - 1) {
-                        this.data.heightmap[(cellZ + 1) * res + cellX + 1] -=
-                            erodeAmount * cellOffsetX * cellOffsetZ;
-                    }
-                    sediment += erodeAmount;
-                }
-                // Update speed and water
-                speed = Math.sqrt(Math.max(0, speed * speed + heightDiff * gravity));
-                water *= 1 - evaporateSpeed;
-            }
-        }
-        // Clamp heights
-        for (let i = 0; i < this.data.heightmap.length; i++) {
-            this.data.heightmap[i] = Math.max(0, Math.min(1, this.data.heightmap[i]));
-        }
-        this.data.metadata.modifiedAt = Date.now();
-    }
-    // ─── Perlin Noise ──────────────────────────────────────
-    perlinNoise2D(x, y, octaves = 6, persistence = 0.5) {
-        let total = 0;
-        let frequency = 1;
-        let amplitude = 1;
-        let maxValue = 0;
-        for (let i = 0; i < octaves; i++) {
-            total += this.noise2D(x * frequency, y * frequency) * amplitude;
-            maxValue += amplitude;
-            amplitude *= persistence;
-            frequency *= 2;
-        }
-        return total / maxValue;
-    }
-    noise2D(x, y) {
-        // Simple hash-based noise
-        const X = Math.floor(x) & 255;
-        const Y = Math.floor(y) & 255;
-        const xf = x - Math.floor(x);
-        const yf = y - Math.floor(y);
-        const topRight = this.dot2D(X + 1, Y, xf - 1, yf);
-        const topLeft = this.dot2D(X, Y, xf, yf);
-        const bottomRight = this.dot2D(X + 1, Y + 1, xf - 1, yf - 1);
-        const bottomLeft = this.dot2D(X, Y + 1, xf, yf - 1);
-        const u = this.fade(xf);
-        const v = this.fade(yf);
-        return this.lerp(this.lerp(topLeft, topRight, u), this.lerp(bottomLeft, bottomRight, u), v);
-    }
-    dot2D(ix, iy, x, y) {
-        // Pseudo-random gradient
-        const random = this.hash(ix, iy);
-        const angle = random * Math.PI * 2;
-        return x * Math.cos(angle) + y * Math.sin(angle);
-    }
-    hash(x, y) {
-        const n = x + y * 57;
-        const nn = (n << 13) ^ n;
-        return ((nn * (nn * nn * 15731 + 789221) + 1376312589) & 0x7fffffff) / 2147483648.0;
-    }
-    fade(t) {
-        return t * t * t * (t * (t * 6 - 15) + 10);
-    }
-    lerp(a, b, t) {
-        return a + t * (b - a);
-    }
-    // ─── Foliage ───────────────────────────────────────────
-    addDetailPrototype(prototype) {
-        this.data.detailPrototypes.push(prototype);
-        // Create corresponding density map
-        const res = this.data.config.detailResolution;
-        this.data.detailMaps.push(new Uint8Array(res * res));
-        this.data.metadata.modifiedAt = Date.now();
-    }
-    paintDetail(worldX, worldZ, prototypeIndex, radius, density) {
-        if (prototypeIndex >= this.data.detailMaps.length) {
-            return;
-        }
-        const { width, detailResolution: res } = this.data.config;
-        const densityMap = this.data.detailMaps[prototypeIndex];
-        const gridX = ((worldX + width / 2) / width) * (res - 1);
-        const gridZ = ((worldZ + width / 2) / width) * (res - 1);
-        const gridRadius = (radius / width) * res;
-        const minX = Math.max(0, Math.floor(gridX - gridRadius));
-        const maxX = Math.min(res - 1, Math.ceil(gridX + gridRadius));
-        const minZ = Math.max(0, Math.floor(gridZ - gridRadius));
-        const maxZ = Math.min(res - 1, Math.ceil(gridZ + gridRadius));
-        for (let z = minZ; z <= maxZ; z++) {
-            for (let x = minX; x <= maxX; x++) {
-                const dx = x - gridX;
-                const dz = z - gridZ;
-                const dist = Math.sqrt(dx * dx + dz * dz);
-                if (dist <= gridRadius) {
-                    const falloff = 1 - dist / gridRadius;
-                    const idx = z * res + x;
-                    const current = densityMap[idx];
-                    densityMap[idx] = Math.min(255, current + density * falloff * 255);
-                }
-            }
-        }
-        this.data.metadata.modifiedAt = Date.now();
-    }
-    scatterFoliage(prototypeIndex, minSlope = 0, maxSlope = 45, minHeight = 0, maxHeight = 1) {
-        if (prototypeIndex >= this.data.detailPrototypes.length) {
-            return;
-        }
-        const { width, depth, heightmapResolution: _hmRes, detailResolution: res } = this.data.config;
-        const densityMap = this.data.detailMaps[prototypeIndex];
-        const prototype = this.data.detailPrototypes[prototypeIndex];
-        for (let z = 0; z < res; z++) {
-            for (let x = 0; x < res; x++) {
-                const worldX = (x / (res - 1)) * width - width / 2;
-                const worldZ = (z / (res - 1)) * depth - depth / 2;
-                // Get terrain properties at this point
-                const height = this.getHeightAtWorld(worldX, worldZ) / this.data.config.maxHeight;
-                const normal = this.getNormalAtWorld(worldX, worldZ);
-                const slope = Math.acos(normal.y) * (180 / Math.PI);
-                // Check constraints
-                const isValidHeight = height >= minHeight && height <= maxHeight;
-                const isValidSlope = slope >= minSlope && slope <= maxSlope;
-                if (isValidHeight && isValidSlope) {
-                    // Apply noise-based density
-                    const noise = (this.perlinNoise2D(x * 0.1, z * 0.1, 2) + 1) * 0.5;
-                    const baseDensity = prototype.density * noise;
-                    densityMap[z * res + x] = Math.min(255, densityMap[z * res + x] + baseDensity * 255);
-                }
-            }
-        }
-        this.data.metadata.modifiedAt = Date.now();
-    }
-    // ─── Trees ─────────────────────────────────────────────
-    addTreePrototype(prototype) {
-        this.data.treePrototypes.push(prototype);
-        this.data.metadata.modifiedAt = Date.now();
-    }
-    addTree(worldX, worldZ, prototypeId, scale, rotation) {
-        const prototype = this.data.treePrototypes.find((p) => p.id === prototypeId);
-        if (!prototype) {
-            return null;
-        }
-        const height = this.getHeightAtWorld(worldX, worldZ);
-        const actualScale = scale ?? prototype.minScale + Math.random() * (prototype.maxScale - prototype.minScale);
-        const actualRotation = rotation ?? (prototype.randomRotation ? Math.random() * Math.PI * 2 : 0);
-        const instance = {
-            position: { x: worldX, y: height, z: worldZ },
-            rotation: actualRotation,
-            scale: { x: actualScale, y: actualScale, z: actualScale },
-            prototypeId,
-            color: { r: 1, g: 1, b: 1, a: 1 },
-            lightmapColor: { r: 1, g: 1, b: 1, a: 1 },
-        };
-        this.data.trees.push(instance);
-        this.data.metadata.modifiedAt = Date.now();
-        return instance;
-    }
-    scatterTrees(prototypeId, density, minSlope = 0, maxSlope = 30, minHeight = 0, maxHeight = 1, minSpacing = 5) {
-        const prototype = this.data.treePrototypes.find((p) => p.id === prototypeId);
-        if (!prototype) {
-            return 0;
-        }
-        const { width, depth } = this.data.config;
-        let treesAdded = 0;
-        // Use Poisson disk sampling for natural distribution
-        const cellSize = minSpacing / Math.SQRT2;
-        const gridWidth = Math.ceil(width / cellSize);
-        const gridDepth = Math.ceil(depth / cellSize);
-        const grid = [];
-        for (let i = 0; i < gridWidth; i++) {
-            grid[i] = [];
-            for (let j = 0; j < gridDepth; j++) {
-                grid[i][j] = null;
-            }
-        }
-        const numAttempts = Math.floor(width * depth * density);
-        const activeList = [];
-        // Start with a random point
-        const startX = Math.random() * width - width / 2;
-        const startZ = Math.random() * depth - depth / 2;
-        const startHeight = this.getHeightAtWorld(startX, startZ);
-        activeList.push({ x: startX, y: startHeight, z: startZ });
-        for (let attempt = 0; attempt < numAttempts && activeList.length > 0; attempt++) {
-            const idx = Math.floor(Math.random() * activeList.length);
-            const point = activeList[idx];
-            let found = false;
-            for (let k = 0; k < 30; k++) {
-                const angle = Math.random() * Math.PI * 2;
-                const r = minSpacing + Math.random() * minSpacing;
-                const newX = point.x + Math.cos(angle) * r;
-                const newZ = point.z + Math.sin(angle) * r;
-                // Check bounds
-                if (newX < -width / 2 || newX > width / 2 || newZ < -depth / 2 || newZ > depth / 2) {
-                    continue;
-                }
-                // Check terrain constraints
-                const newHeight = this.getHeightAtWorld(newX, newZ) / this.data.config.maxHeight;
-                const normal = this.getNormalAtWorld(newX, newZ);
-                const slope = Math.acos(normal.y) * (180 / Math.PI);
-                if (newHeight < minHeight ||
-                    newHeight > maxHeight ||
-                    slope < minSlope ||
-                    slope > maxSlope) {
-                    continue;
-                }
-                // Check grid for nearby points
-                const gridX = Math.floor((newX + width / 2) / cellSize);
-                const gridZ = Math.floor((newZ + depth / 2) / cellSize);
-                let tooClose = false;
-                for (let di = -2; di <= 2 && !tooClose; di++) {
-                    for (let dj = -2; dj <= 2 && !tooClose; dj++) {
-                        const ni = gridX + di;
-                        const nj = gridZ + dj;
-                        if (ni >= 0 && ni < gridWidth && nj >= 0 && nj < gridDepth && grid[ni][nj]) {
-                            const neighbor = grid[ni][nj];
-                            const dx = neighbor.x - newX;
-                            const dz = neighbor.z - newZ;
-                            if (dx * dx + dz * dz < minSpacing * minSpacing) {
-                                tooClose = true;
-                            }
-                        }
-                    }
-                }
-                if (!tooClose) {
-                    const newPoint = { x: newX, y: this.getHeightAtWorld(newX, newZ), z: newZ };
-                    grid[gridX][gridZ] = newPoint;
-                    activeList.push(newPoint);
-                    this.addTree(newX, newZ, prototypeId);
-                    treesAdded++;
-                    found = true;
-                    break;
-                }
-            }
-            if (!found) {
-                activeList.splice(idx, 1);
-            }
-        }
-        return treesAdded;
-    }
-    removeTreesInRadius(worldX, worldZ, radius) {
-        const initialCount = this.data.trees.length;
-        this.data.trees = this.data.trees.filter((tree) => {
-            const dx = tree.position.x - worldX;
-            const dz = tree.position.z - worldZ;
-            return dx * dx + dz * dz > radius * radius;
-        });
-        this.data.metadata.modifiedAt = Date.now();
-        return initialCount - this.data.trees.length;
-    }
-    // ─── Undo/Redo ─────────────────────────────────────────
-    recordHeightChange(gridX, gridZ, oldValue, newValue) {
-        const operation = {
-            type: 'height',
-            gridX,
-            gridZ,
-            oldValue,
-            newValue,
-            timestamp: Date.now(),
-        };
-        this.undoStack.push(operation);
-        if (this.undoStack.length > this.maxUndoSteps) {
-            this.undoStack.shift();
-        }
-        this.redoStack = [];
-    }
-    undo() {
-        const operation = this.undoStack.pop();
-        if (!operation) {
-            return false;
-        }
-        if (operation.type === 'height') {
-            const res = this.data.config.heightmapResolution;
-            this.data.heightmap[operation.gridZ * res + operation.gridX] = operation.oldValue;
-        }
-        this.redoStack.push(operation);
-        this.data.metadata.modifiedAt = Date.now();
-        return true;
-    }
-    redo() {
-        const operation = this.redoStack.pop();
-        if (!operation) {
-            return false;
-        }
-        if (operation.type === 'height') {
-            const res = this.data.config.heightmapResolution;
-            this.data.heightmap[operation.gridZ * res + operation.gridX] = operation.newValue;
-        }
-        this.undoStack.push(operation);
-        this.data.metadata.modifiedAt = Date.now();
-        return true;
-    }
-    // ─── Serialization ─────────────────────────────────────
-    getData() {
-        return this.data;
-    }
-    setData(data) {
-        this.data = data;
-        this.undoStack = [];
-        this.redoStack = [];
-    }
-    serialize() {
-        return JSON.stringify({
-            ...this.data,
-            heightmap: Array.from(this.data.heightmap),
-            splatmaps: this.data.splatmaps.map((s) => Array.from(s)),
-            holemap: Array.from(this.data.holemap),
-            detailMaps: this.data.detailMaps.map((d) => Array.from(d)),
+  constructor(config) {
+    this.undoStack = [];
+    this.redoStack = [];
+    this.maxUndoSteps = 50;
+    this.data = this.createEmptyTerrain(config);
+  }
+  createEmptyTerrain(configOverride) {
+    const config = { ...DEFAULT_TERRAIN_CONFIG, ...configOverride };
+    const hmRes = config.heightmapResolution;
+    const smRes = config.splatmapResolution;
+    config.detailResolution;
+    const chunks = config.chunksPerSide;
+    const heightmap = new Float32Array(hmRes * hmRes);
+    const splatmaps = [
+      new Uint8Array(smRes * smRes * 4),
+      new Uint8Array(smRes * smRes * 4)
+    ];
+    for (let i = 0; i < smRes * smRes; i++) {
+      splatmaps[0][i * 4] = 255;
+    }
+    const holemap = new Uint8Array(hmRes * hmRes);
+    holemap.fill(1);
+    const chunkList = [];
+    const chunkWidth = config.width / chunks;
+    const chunkDepth = config.depth / chunks;
+    for (let gz = 0; gz < chunks; gz++) {
+      for (let gx = 0; gx < chunks; gx++) {
+        chunkList.push({
+          id: `chunk_${gx}_${gz}`,
+          gridX: gx,
+          gridZ: gz,
+          boundsMin: {
+            x: gx * chunkWidth - config.width / 2,
+            y: 0,
+            z: gz * chunkDepth - config.depth / 2
+          },
+          boundsMax: {
+            x: (gx + 1) * chunkWidth - config.width / 2,
+            y: config.maxHeight,
+            z: (gz + 1) * chunkDepth - config.depth / 2
+          },
+          isLoaded: gx < 2 && gz < 2,
+          // Load center chunks
+          lodLevel: 0
         });
+      }
     }
-    static deserialize(json) {
-        const data = JSON.parse(json);
-        const terrain = new TerrainSystem(data.config);
-        terrain.data = {
-            ...data,
-            heightmap: new Float32Array(data.heightmap),
-            splatmaps: data.splatmaps.map((s) => new Uint8Array(s)),
-            holemap: new Uint8Array(data.holemap),
-            detailMaps: data.detailMaps.map((d) => new Uint8Array(d)),
-        };
-        return terrain;
-    }
-    // ─── Export Heightmap ──────────────────────────────────
-    exportHeightmapAsRAW() {
-        const res = this.data.config.heightmapResolution;
-        const buffer = new ArrayBuffer(res * res * 2); // 16-bit
-        const view = new Uint16Array(buffer);
-        for (let i = 0; i < this.data.heightmap.length; i++) {
-            view[i] = Math.round(this.data.heightmap[i] * 65535);
-        }
-        return buffer;
-    }
-    importHeightmapFromRAW(buffer, is16bit = true) {
-        const res = this.data.config.heightmapResolution;
-        if (is16bit) {
-            const view = new Uint16Array(buffer);
-            const expectedSize = res * res;
-            if (view.length !== expectedSize) {
-                throw new Error(`RAW size mismatch: expected ${expectedSize}, got ${view.length}`);
-            }
-            for (let i = 0; i < view.length; i++) {
-                this.data.heightmap[i] = view[i] / 65535;
+    return {
+      id: `terrain_${Date.now()}`,
+      name: "New Terrain",
+      config,
+      heightmap,
+      splatmaps,
+      holemap,
+      layers: [],
+      detailPrototypes: [],
+      detailMaps: [],
+      treePrototypes: [],
+      trees: [],
+      chunks: chunkList,
+      metadata: {
+        createdAt: Date.now(),
+        modifiedAt: Date.now(),
+        version: 1
+      }
+    };
+  }
+  // ─── Heightmap Operations ──────────────────────────────
+  /** Get height at grid coordinates (0 to resolution-1) */
+  getHeightAtGrid(gridX, gridZ) {
+    const res = this.data.config.heightmapResolution;
+    const x = Math.max(0, Math.min(res - 1, Math.floor(gridX)));
+    const z = Math.max(0, Math.min(res - 1, Math.floor(gridZ)));
+    return this.data.heightmap[z * res + x] * this.data.config.maxHeight;
+  }
+  /** Set height at grid coordinates */
+  setHeightAtGrid(gridX, gridZ, height, recordUndo = true) {
+    const res = this.data.config.heightmapResolution;
+    const maxH = this.data.config.maxHeight;
+    if (gridX < 0 || gridX >= res || gridZ < 0 || gridZ >= res) {
+      return;
+    }
+    const idx = gridZ * res + gridX;
+    const normalizedHeight = Math.max(0, Math.min(1, height / maxH));
+    if (recordUndo) {
+      this.recordHeightChange(gridX, gridZ, this.data.heightmap[idx], normalizedHeight);
+    }
+    this.data.heightmap[idx] = normalizedHeight;
+    this.data.metadata.modifiedAt = Date.now();
+  }
+  /** Get interpolated height at world coordinates */
+  getHeightAtWorld(worldX, worldZ) {
+    const { width, depth, heightmapResolution: res } = this.data.config;
+    const gx = (worldX + width / 2) / width * (res - 1);
+    const gz = (worldZ + depth / 2) / depth * (res - 1);
+    const ix = Math.floor(gx);
+    const iz = Math.floor(gz);
+    const fx = gx - ix;
+    const fz = gz - iz;
+    const h00 = this.getHeightAtGrid(ix, iz);
+    const h10 = this.getHeightAtGrid(ix + 1, iz);
+    const h01 = this.getHeightAtGrid(ix, iz + 1);
+    const h11 = this.getHeightAtGrid(ix + 1, iz + 1);
+    const h0 = h00 + (h10 - h00) * fx;
+    const h1 = h01 + (h11 - h01) * fx;
+    return h0 + (h1 - h0) * fz;
+  }
+  /** Convert world position to grid coordinates */
+  worldToGrid(worldX, worldZ) {
+    const { width, depth, heightmapResolution: res } = this.data.config;
+    return {
+      x: (worldX + width / 2) / width * (res - 1),
+      y: (worldZ + depth / 2) / depth * (res - 1)
+    };
+  }
+  /** Convert grid coordinates to world position */
+  gridToWorld(gridX, gridZ) {
+    const { width, depth, heightmapResolution: res } = this.data.config;
+    const worldX = gridX / (res - 1) * width - width / 2;
+    const worldZ = gridZ / (res - 1) * depth - depth / 2;
+    const worldY = this.getHeightAtGrid(gridX, gridZ);
+    return { x: worldX, y: worldY, z: worldZ };
+  }
+  /// Get terrain normal at world position
+  getNormalAtWorld(worldX, worldZ) {
+    const { width, depth, heightmapResolution: res } = this.data.config;
+    const cellWidth = width / (res - 1);
+    const cellDepth = depth / (res - 1);
+    const hL = this.getHeightAtWorld(worldX - cellWidth, worldZ);
+    const hR = this.getHeightAtWorld(worldX + cellWidth, worldZ);
+    const hD = this.getHeightAtWorld(worldX, worldZ - cellDepth);
+    const hU = this.getHeightAtWorld(worldX, worldZ + cellDepth);
+    const dx = hR - hL;
+    const dz = hU - hD;
+    const nx = -dx / (2 * cellWidth);
+    const ny = 1;
+    const nz = -dz / (2 * cellDepth);
+    const len = Math.sqrt(nx * nx + ny * ny + nz * nz);
+    return { x: nx / len, y: ny / len, z: nz / len };
+  }
+  // ─── Brush Operations ──────────────────────────────────
+  applyBrush(brush, worldX, worldZ) {
+    switch (brush.type) {
+      case "raise":
+        this.applyHeightBrush(worldX, worldZ, brush, 1);
+        break;
+      case "lower":
+        this.applyHeightBrush(worldX, worldZ, brush, -1);
+        break;
+      case "flatten":
+        this.applyFlattenBrush(worldX, worldZ, brush);
+        break;
+      case "smooth":
+        this.applySmoothBrush(worldX, worldZ, brush);
+        break;
+      case "noise":
+        this.applyNoiseBrush(worldX, worldZ, brush);
+        break;
+      case "erosion":
+        this.applyErosionBrush(worldX, worldZ, brush);
+        break;
+      case "paint":
+        this.applyPaintBrush(worldX, worldZ, brush);
+        break;
+      case "paintHoles":
+        this.applyHoleBrush(worldX, worldZ, brush);
+        break;
+      case "stampHeight":
+        this.applyStampBrush(worldX, worldZ, brush);
+        break;
+    }
+  }
+  applyHeightBrush(worldX, worldZ, brush, direction) {
+    const grid = this.worldToGrid(worldX, worldZ);
+    const { heightmapResolution: res, width, maxHeight } = this.data.config;
+    const gridRadius = brush.size / (width / (res - 1)) * 0.5;
+    const delta = brush.strength * direction * maxHeight / 100;
+    const minX = Math.max(0, Math.floor(grid.x - gridRadius));
+    const maxX = Math.min(res - 1, Math.ceil(grid.x + gridRadius));
+    const minZ = Math.max(0, Math.floor(grid.y - gridRadius));
+    const maxZ = Math.min(res - 1, Math.ceil(grid.y + gridRadius));
+    for (let gz = minZ; gz <= maxZ; gz++) {
+      for (let gx = minX; gx <= maxX; gx++) {
+        const dx = gx - grid.x;
+        const dz = gz - grid.y;
+        const dist = Math.sqrt(dx * dx + dz * dz);
+        if (dist <= gridRadius) {
+          const falloff = this.calculateFalloff(dist / gridRadius, brush.falloff);
+          const currentHeight = this.getHeightAtGrid(gx, gz);
+          const newHeight = currentHeight + delta * falloff;
+          this.setHeightAtGrid(gx, gz, newHeight);
+        }
+      }
+    }
+  }
+  applyFlattenBrush(worldX, worldZ, brush) {
+    const grid = this.worldToGrid(worldX, worldZ);
+    const { heightmapResolution: res, width } = this.data.config;
+    const gridRadius = brush.size / (width / (res - 1)) * 0.5;
+    const targetHeight = brush.targetHeight ?? this.getHeightAtWorld(worldX, worldZ);
+    const minX = Math.max(0, Math.floor(grid.x - gridRadius));
+    const maxX = Math.min(res - 1, Math.ceil(grid.x + gridRadius));
+    const minZ = Math.max(0, Math.floor(grid.y - gridRadius));
+    const maxZ = Math.min(res - 1, Math.ceil(grid.y + gridRadius));
+    for (let gz = minZ; gz <= maxZ; gz++) {
+      for (let gx = minX; gx <= maxX; gx++) {
+        const dx = gx - grid.x;
+        const dz = gz - grid.y;
+        const dist = Math.sqrt(dx * dx + dz * dz);
+        if (dist <= gridRadius) {
+          const falloff = this.calculateFalloff(dist / gridRadius, brush.falloff);
+          const currentHeight = this.getHeightAtGrid(gx, gz);
+          const newHeight = currentHeight + (targetHeight - currentHeight) * falloff * brush.strength;
+          this.setHeightAtGrid(gx, gz, newHeight);
+        }
+      }
+    }
+  }
+  applySmoothBrush(worldX, worldZ, brush) {
+    const grid = this.worldToGrid(worldX, worldZ);
+    const { heightmapResolution: res, width } = this.data.config;
+    const gridRadius = brush.size / (width / (res - 1)) * 0.5;
+    const minX = Math.max(0, Math.floor(grid.x - gridRadius));
+    const maxX = Math.min(res - 1, Math.ceil(grid.x + gridRadius));
+    const minZ = Math.max(0, Math.floor(grid.y - gridRadius));
+    const maxZ = Math.min(res - 1, Math.ceil(grid.y + gridRadius));
+    const newHeights = [];
+    for (let gz = minZ; gz <= maxZ; gz++) {
+      for (let gx = minX; gx <= maxX; gx++) {
+        const dx = gx - grid.x;
+        const dz = gz - grid.y;
+        const dist = Math.sqrt(dx * dx + dz * dz);
+        if (dist <= gridRadius) {
+          let sum = 0;
+          let count = 0;
+          for (let nz = -1; nz <= 1; nz++) {
+            for (let nx = -1; nx <= 1; nx++) {
+              const ngx = gx + nx;
+              const ngz = gz + nz;
+              if (ngx >= 0 && ngx < res && ngz >= 0 && ngz < res) {
+                sum += this.getHeightAtGrid(ngx, ngz);
+                count++;
+              }
             }
-        }
-        else {
-            const view = new Uint8Array(buffer);
-            const expectedSize = res * res;
-            if (view.length !== expectedSize) {
-                throw new Error(`RAW size mismatch: expected ${expectedSize}, got ${view.length}`);
+          }
+          const avgHeight = sum / count;
+          const falloff = this.calculateFalloff(dist / gridRadius, brush.falloff);
+          const currentHeight = this.getHeightAtGrid(gx, gz);
+          const newHeight = currentHeight + (avgHeight - currentHeight) * falloff * brush.strength;
+          newHeights.push({ gx, gz, height: newHeight });
+        }
+      }
+    }
+    for (const { gx, gz, height } of newHeights) {
+      this.setHeightAtGrid(gx, gz, height);
+    }
+  }
+  applyNoiseBrush(worldX, worldZ, brush) {
+    const grid = this.worldToGrid(worldX, worldZ);
+    const { heightmapResolution: res, width, maxHeight } = this.data.config;
+    const gridRadius = brush.size / (width / (res - 1)) * 0.5;
+    const noiseScale = brush.noiseScale ?? 0.1;
+    const octaves = brush.noiseOctaves ?? 4;
+    const minX = Math.max(0, Math.floor(grid.x - gridRadius));
+    const maxX = Math.min(res - 1, Math.ceil(grid.x + gridRadius));
+    const minZ = Math.max(0, Math.floor(grid.y - gridRadius));
+    const maxZ = Math.min(res - 1, Math.ceil(grid.y + gridRadius));
+    for (let gz = minZ; gz <= maxZ; gz++) {
+      for (let gx = minX; gx <= maxX; gx++) {
+        const dx = gx - grid.x;
+        const dz = gz - grid.y;
+        const dist = Math.sqrt(dx * dx + dz * dz);
+        if (dist <= gridRadius) {
+          const falloff = this.calculateFalloff(dist / gridRadius, brush.falloff);
+          const noise = this.perlinNoise2D(gx * noiseScale, gz * noiseScale, octaves);
+          const delta = noise * brush.strength * maxHeight * 0.1 * falloff;
+          const currentHeight = this.getHeightAtGrid(gx, gz);
+          this.setHeightAtGrid(gx, gz, currentHeight + delta);
+        }
+      }
+    }
+  }
+  applyErosionBrush(worldX, worldZ, brush) {
+    const grid = this.worldToGrid(worldX, worldZ);
+    const { heightmapResolution: res, width } = this.data.config;
+    const gridRadius = brush.size / (width / (res - 1)) * 0.5;
+    const minX = Math.max(1, Math.floor(grid.x - gridRadius));
+    const maxX = Math.min(res - 2, Math.ceil(grid.x + gridRadius));
+    const minZ = Math.max(1, Math.floor(grid.y - gridRadius));
+    const maxZ = Math.min(res - 2, Math.ceil(grid.y + gridRadius));
+    const newHeights = [];
+    const talusAngle = 0.5;
+    for (let gz = minZ; gz <= maxZ; gz++) {
+      for (let gx = minX; gx <= maxX; gx++) {
+        const dx = gx - grid.x;
+        const dz = gz - grid.y;
+        const dist = Math.sqrt(dx * dx + dz * dz);
+        if (dist <= gridRadius) {
+          const falloff = this.calculateFalloff(dist / gridRadius, brush.falloff);
+          const h = this.getHeightAtGrid(gx, gz);
+          let totalDiff = 0;
+          const neighbors = [
+            this.getHeightAtGrid(gx - 1, gz),
+            this.getHeightAtGrid(gx + 1, gz),
+            this.getHeightAtGrid(gx, gz - 1),
+            this.getHeightAtGrid(gx, gz + 1)
+          ];
+          for (const nh of neighbors) {
+            const diff = h - nh;
+            if (diff > talusAngle) {
+              totalDiff += diff - talusAngle;
             }
-            for (let i = 0; i < view.length; i++) {
-                this.data.heightmap[i] = view[i] / 255;
+          }
+          if (totalDiff > 0) {
+            const erosion = totalDiff * brush.strength * falloff * 0.25;
+            newHeights.push({ gx, gz, height: h - erosion });
+          }
+        }
+      }
+    }
+    for (const { gx, gz, height } of newHeights) {
+      this.setHeightAtGrid(gx, gz, height);
+    }
+  }
+  applyPaintBrush(worldX, worldZ, brush) {
+    const { splatmapResolution: res, width } = this.data.config;
+    const layerIndex = brush.layerIndex ?? 0;
+    if (layerIndex >= 8) {
+      return;
+    }
+    const splatmapIndex = Math.floor(layerIndex / 4);
+    const channelIndex = layerIndex % 4;
+    const smX = (worldX + width / 2) / width * (res - 1);
+    const smZ = (worldZ + width / 2) / width * (res - 1);
+    const gridRadius = brush.size / (width / (res - 1)) * 0.5;
+    const minX = Math.max(0, Math.floor(smX - gridRadius));
+    const maxX = Math.min(res - 1, Math.ceil(smX + gridRadius));
+    const minZ = Math.max(0, Math.floor(smZ - gridRadius));
+    const maxZ = Math.min(res - 1, Math.ceil(smZ + gridRadius));
+    const splatmap = this.data.splatmaps[splatmapIndex];
+    for (let z = minZ; z <= maxZ; z++) {
+      for (let x = minX; x <= maxX; x++) {
+        const dx = x - smX;
+        const dz = z - smZ;
+        const dist = Math.sqrt(dx * dx + dz * dz);
+        if (dist <= gridRadius) {
+          const falloff = this.calculateFalloff(dist / gridRadius, brush.falloff);
+          const idx = (z * res + x) * 4;
+          const strength = brush.strength * falloff * 255;
+          const current = splatmap[idx + channelIndex];
+          const newValue = Math.min(255, current + strength);
+          splatmap[idx + channelIndex] = newValue;
+          this.normalizeSplatmapPixel(x, z);
+        }
+      }
+    }
+    this.data.metadata.modifiedAt = Date.now();
+  }
+  normalizeSplatmapPixel(x, z) {
+    const res = this.data.config.splatmapResolution;
+    let total = 0;
+    for (let s = 0; s < 2; s++) {
+      const idx = (z * res + x) * 4;
+      for (let c = 0; c < 4; c++) {
+        total += this.data.splatmaps[s][idx + c];
+      }
+    }
+    if (total > 0) {
+      const scale = 255 / total;
+      for (let s = 0; s < 2; s++) {
+        const idx = (z * res + x) * 4;
+        for (let c = 0; c < 4; c++) {
+          this.data.splatmaps[s][idx + c] = Math.round(this.data.splatmaps[s][idx + c] * scale);
+        }
+      }
+    }
+  }
+  applyHoleBrush(worldX, worldZ, brush) {
+    const { heightmapResolution: res, width } = this.data.config;
+    const gridCoords = this.worldToGrid(worldX, worldZ);
+    const gridRadius = brush.size / (width / (res - 1)) * 0.5;
+    const isAddHole = brush.strength > 0;
+    const minX = Math.max(0, Math.floor(gridCoords.x - gridRadius));
+    const maxX = Math.min(res - 1, Math.ceil(gridCoords.x + gridRadius));
+    const minZ = Math.max(0, Math.floor(gridCoords.y - gridRadius));
+    const maxZ = Math.min(res - 1, Math.ceil(gridCoords.y + gridRadius));
+    for (let gz = minZ; gz <= maxZ; gz++) {
+      for (let gx = minX; gx <= maxX; gx++) {
+        const dx = gx - gridCoords.x;
+        const dz = gz - gridCoords.y;
+        const dist = Math.sqrt(dx * dx + dz * dz);
+        if (dist <= gridRadius) {
+          this.data.holemap[gz * res + gx] = isAddHole ? 0 : 1;
+        }
+      }
+    }
+    this.data.metadata.modifiedAt = Date.now();
+  }
+  applyStampBrush(worldX, worldZ, brush) {
+    this.applyHeightBrush(worldX, worldZ, brush, 1);
+  }
+  calculateFalloff(t, falloffStrength) {
+    if (t >= 1) {
+      return 0;
+    }
+    if (falloffStrength <= 0) {
+      return 1;
+    }
+    const smoothT = t * t * (3 - 2 * t);
+    const power = 1 + falloffStrength * 3;
+    return Math.pow(1 - smoothT, power);
+  }
+  // ─── Procedural Generation ─────────────────────────────
+  generatePerlinTerrain(scale = 0.01, octaves = 6, persistence = 0.5) {
+    const res = this.data.config.heightmapResolution;
+    for (let z = 0; z < res; z++) {
+      for (let x = 0; x < res; x++) {
+        const height = this.perlinNoise2D(x * scale, z * scale, octaves, persistence);
+        this.data.heightmap[z * res + x] = (height + 1) * 0.5;
+      }
+    }
+    this.data.metadata.modifiedAt = Date.now();
+  }
+  generateDiamondSquare(roughness = 0.5) {
+    const size = this.data.config.heightmapResolution;
+    this.data.heightmap[0] = Math.random();
+    this.data.heightmap[size - 1] = Math.random();
+    this.data.heightmap[(size - 1) * size] = Math.random();
+    this.data.heightmap[(size - 1) * size + size - 1] = Math.random();
+    let stepSize = size - 1;
+    let scale = roughness;
+    while (stepSize > 1) {
+      const halfStep = stepSize / 2;
+      for (let z = halfStep; z < size - 1; z += stepSize) {
+        for (let x = halfStep; x < size - 1; x += stepSize) {
+          const avg = (this.data.heightmap[(z - halfStep) * size + (x - halfStep)] + this.data.heightmap[(z - halfStep) * size + (x + halfStep)] + this.data.heightmap[(z + halfStep) * size + (x - halfStep)] + this.data.heightmap[(z + halfStep) * size + (x + halfStep)]) / 4;
+          this.data.heightmap[z * size + x] = avg + (Math.random() - 0.5) * scale;
+        }
+      }
+      for (let z = 0; z < size; z += halfStep) {
+        for (let x = (z + halfStep) % stepSize; x < size; x += stepSize) {
+          let sum = 0;
+          let count = 0;
+          if (z - halfStep >= 0) {
+            sum += this.data.heightmap[(z - halfStep) * size + x];
+            count++;
+          }
+          if (z + halfStep < size) {
+            sum += this.data.heightmap[(z + halfStep) * size + x];
+            count++;
+          }
+          if (x - halfStep >= 0) {
+            sum += this.data.heightmap[z * size + (x - halfStep)];
+            count++;
+          }
+          if (x + halfStep < size) {
+            sum += this.data.heightmap[z * size + (x + halfStep)];
+            count++;
+          }
+          this.data.heightmap[z * size + x] = sum / count + (Math.random() - 0.5) * scale;
+        }
+      }
+      stepSize = halfStep;
+      scale *= 0.5;
+    }
+    let min = Infinity;
+    let max = -Infinity;
+    for (let i = 0; i < this.data.heightmap.length; i++) {
+      min = Math.min(min, this.data.heightmap[i]);
+      max = Math.max(max, this.data.heightmap[i]);
+    }
+    const range = max - min;
+    if (range > 0) {
+      for (let i = 0; i < this.data.heightmap.length; i++) {
+        this.data.heightmap[i] = (this.data.heightmap[i] - min) / range;
+      }
+    }
+    this.data.metadata.modifiedAt = Date.now();
+  }
+  applyHydraulicErosion(iterations = 5e4) {
+    const res = this.data.config.heightmapResolution;
+    const { maxHeight: _maxHeight } = this.data.config;
+    const inertia = 0.05;
+    const sedimentCapacityFactor = 4;
+    const minSedimentCapacity = 0.01;
+    const erodeSpeed = 0.3;
+    const depositSpeed = 0.3;
+    const evaporateSpeed = 0.01;
+    const gravity = 4;
+    const maxDropletLifetime = 30;
+    const initialWaterVolume = 1;
+    const initialSpeed = 1;
+    for (let i = 0; i < iterations; i++) {
+      let posX = Math.random() * (res - 1);
+      let posZ = Math.random() * (res - 1);
+      let dirX = 0;
+      let dirZ = 0;
+      let speed = initialSpeed;
+      let water = initialWaterVolume;
+      let sediment = 0;
+      for (let lifetime = 0; lifetime < maxDropletLifetime; lifetime++) {
+        const cellX = Math.floor(posX);
+        const cellZ = Math.floor(posZ);
+        const cellOffsetX = posX - cellX;
+        const cellOffsetZ = posZ - cellZ;
+        const heightNW = this.data.heightmap[cellZ * res + cellX];
+        const heightNE = cellX < res - 1 ? this.data.heightmap[cellZ * res + cellX + 1] : heightNW;
+        const heightSW = cellZ < res - 1 ? this.data.heightmap[(cellZ + 1) * res + cellX] : heightNW;
+        const heightSE = cellX < res - 1 && cellZ < res - 1 ? this.data.heightmap[(cellZ + 1) * res + cellX + 1] : heightNW;
+        const gradientX = (heightNE - heightNW) * (1 - cellOffsetZ) + (heightSE - heightSW) * cellOffsetZ;
+        const gradientZ = (heightSW - heightNW) * (1 - cellOffsetX) + (heightSE - heightNE) * cellOffsetX;
+        dirX = dirX * inertia - gradientX * (1 - inertia);
+        dirZ = dirZ * inertia - gradientZ * (1 - inertia);
+        const len = Math.sqrt(dirX * dirX + dirZ * dirZ);
+        if (len > 0) {
+          dirX /= len;
+          dirZ /= len;
+        }
+        posX += dirX;
+        posZ += dirZ;
+        if (posX < 0 || posX >= res - 1 || posZ < 0 || posZ >= res - 1 || len === 0) {
+          break;
+        }
+        const newHeight = heightNW * (1 - cellOffsetX) * (1 - cellOffsetZ) + heightNE * cellOffsetX * (1 - cellOffsetZ) + heightSW * (1 - cellOffsetX) * cellOffsetZ + heightSE * cellOffsetX * cellOffsetZ;
+        const oldHeight = this.data.heightmap[cellZ * res + cellX] * (1 - cellOffsetX) * (1 - cellOffsetZ) + (cellX < res - 1 ? this.data.heightmap[cellZ * res + cellX + 1] : this.data.heightmap[cellZ * res + cellX]) * cellOffsetX * (1 - cellOffsetZ) + (cellZ < res - 1 ? this.data.heightmap[(cellZ + 1) * res + cellX] : this.data.heightmap[cellZ * res + cellX]) * (1 - cellOffsetX) * cellOffsetZ + (cellX < res - 1 && cellZ < res - 1 ? this.data.heightmap[(cellZ + 1) * res + cellX + 1] : this.data.heightmap[cellZ * res + cellX]) * cellOffsetX * cellOffsetZ;
+        const heightDiff = newHeight - oldHeight;
+        const sedimentCapacity = Math.max(
+          -heightDiff * speed * water * sedimentCapacityFactor,
+          minSedimentCapacity
+        );
+        if (sediment > sedimentCapacity || heightDiff > 0) {
+          const depositAmount = heightDiff > 0 ? Math.min(heightDiff, sediment) : (sediment - sedimentCapacity) * depositSpeed;
+          sediment -= depositAmount;
+          this.data.heightmap[cellZ * res + cellX] += depositAmount * (1 - cellOffsetX) * (1 - cellOffsetZ);
+          if (cellX < res - 1) {
+            this.data.heightmap[cellZ * res + cellX + 1] += depositAmount * cellOffsetX * (1 - cellOffsetZ);
+          }
+          if (cellZ < res - 1) {
+            this.data.heightmap[(cellZ + 1) * res + cellX] += depositAmount * (1 - cellOffsetX) * cellOffsetZ;
+          }
+          if (cellX < res - 1 && cellZ < res - 1) {
+            this.data.heightmap[(cellZ + 1) * res + cellX + 1] += depositAmount * cellOffsetX * cellOffsetZ;
+          }
+        } else {
+          const erodeAmount = Math.min((sedimentCapacity - sediment) * erodeSpeed, -heightDiff);
+          this.data.heightmap[cellZ * res + cellX] -= erodeAmount * (1 - cellOffsetX) * (1 - cellOffsetZ);
+          if (cellX < res - 1) {
+            this.data.heightmap[cellZ * res + cellX + 1] -= erodeAmount * cellOffsetX * (1 - cellOffsetZ);
+          }
+          if (cellZ < res - 1) {
+            this.data.heightmap[(cellZ + 1) * res + cellX] -= erodeAmount * (1 - cellOffsetX) * cellOffsetZ;
+          }
+          if (cellX < res - 1 && cellZ < res - 1) {
+            this.data.heightmap[(cellZ + 1) * res + cellX + 1] -= erodeAmount * cellOffsetX * cellOffsetZ;
+          }
+          sediment += erodeAmount;
+        }
+        speed = Math.sqrt(Math.max(0, speed * speed + heightDiff * gravity));
+        water *= 1 - evaporateSpeed;
+      }
+    }
+    for (let i = 0; i < this.data.heightmap.length; i++) {
+      this.data.heightmap[i] = Math.max(0, Math.min(1, this.data.heightmap[i]));
+    }
+    this.data.metadata.modifiedAt = Date.now();
+  }
+  // ─── Perlin Noise ──────────────────────────────────────
+  perlinNoise2D(x, y, octaves = 6, persistence = 0.5) {
+    let total = 0;
+    let frequency = 1;
+    let amplitude = 1;
+    let maxValue = 0;
+    for (let i = 0; i < octaves; i++) {
+      total += this.noise2D(x * frequency, y * frequency) * amplitude;
+      maxValue += amplitude;
+      amplitude *= persistence;
+      frequency *= 2;
+    }
+    return total / maxValue;
+  }
+  noise2D(x, y) {
+    const X = Math.floor(x) & 255;
+    const Y = Math.floor(y) & 255;
+    const xf = x - Math.floor(x);
+    const yf = y - Math.floor(y);
+    const topRight = this.dot2D(X + 1, Y, xf - 1, yf);
+    const topLeft = this.dot2D(X, Y, xf, yf);
+    const bottomRight = this.dot2D(X + 1, Y + 1, xf - 1, yf - 1);
+    const bottomLeft = this.dot2D(X, Y + 1, xf, yf - 1);
+    const u = this.fade(xf);
+    const v = this.fade(yf);
+    return this.lerp(this.lerp(topLeft, topRight, u), this.lerp(bottomLeft, bottomRight, u), v);
+  }
+  dot2D(ix, iy, x, y) {
+    const random = this.hash(ix, iy);
+    const angle = random * Math.PI * 2;
+    return x * Math.cos(angle) + y * Math.sin(angle);
+  }
+  hash(x, y) {
+    const n = x + y * 57;
+    const nn = n << 13 ^ n;
+    return (nn * (nn * nn * 15731 + 789221) + 1376312589 & 2147483647) / 2147483648;
+  }
+  fade(t) {
+    return t * t * t * (t * (t * 6 - 15) + 10);
+  }
+  lerp(a, b, t) {
+    return a + t * (b - a);
+  }
+  // ─── Foliage ───────────────────────────────────────────
+  addDetailPrototype(prototype) {
+    this.data.detailPrototypes.push(prototype);
+    const res = this.data.config.detailResolution;
+    this.data.detailMaps.push(new Uint8Array(res * res));
+    this.data.metadata.modifiedAt = Date.now();
+  }
+  paintDetail(worldX, worldZ, prototypeIndex, radius, density) {
+    if (prototypeIndex >= this.data.detailMaps.length) {
+      return;
+    }
+    const { width, detailResolution: res } = this.data.config;
+    const densityMap = this.data.detailMaps[prototypeIndex];
+    const gridX = (worldX + width / 2) / width * (res - 1);
+    const gridZ = (worldZ + width / 2) / width * (res - 1);
+    const gridRadius = radius / width * res;
+    const minX = Math.max(0, Math.floor(gridX - gridRadius));
+    const maxX = Math.min(res - 1, Math.ceil(gridX + gridRadius));
+    const minZ = Math.max(0, Math.floor(gridZ - gridRadius));
+    const maxZ = Math.min(res - 1, Math.ceil(gridZ + gridRadius));
+    for (let z = minZ; z <= maxZ; z++) {
+      for (let x = minX; x <= maxX; x++) {
+        const dx = x - gridX;
+        const dz = z - gridZ;
+        const dist = Math.sqrt(dx * dx + dz * dz);
+        if (dist <= gridRadius) {
+          const falloff = 1 - dist / gridRadius;
+          const idx = z * res + x;
+          const current = densityMap[idx];
+          densityMap[idx] = Math.min(255, current + density * falloff * 255);
+        }
+      }
+    }
+    this.data.metadata.modifiedAt = Date.now();
+  }
+  scatterFoliage(prototypeIndex, minSlope = 0, maxSlope = 45, minHeight = 0, maxHeight = 1) {
+    if (prototypeIndex >= this.data.detailPrototypes.length) {
+      return;
+    }
+    const { width, depth, heightmapResolution: _hmRes, detailResolution: res } = this.data.config;
+    const densityMap = this.data.detailMaps[prototypeIndex];
+    const prototype = this.data.detailPrototypes[prototypeIndex];
+    for (let z = 0; z < res; z++) {
+      for (let x = 0; x < res; x++) {
+        const worldX = x / (res - 1) * width - width / 2;
+        const worldZ = z / (res - 1) * depth - depth / 2;
+        const height = this.getHeightAtWorld(worldX, worldZ) / this.data.config.maxHeight;
+        const normal = this.getNormalAtWorld(worldX, worldZ);
+        const slope = Math.acos(normal.y) * (180 / Math.PI);
+        const isValidHeight = height >= minHeight && height <= maxHeight;
+        const isValidSlope = slope >= minSlope && slope <= maxSlope;
+        if (isValidHeight && isValidSlope) {
+          const noise = (this.perlinNoise2D(x * 0.1, z * 0.1, 2) + 1) * 0.5;
+          const baseDensity = prototype.density * noise;
+          densityMap[z * res + x] = Math.min(255, densityMap[z * res + x] + baseDensity * 255);
+        }
+      }
+    }
+    this.data.metadata.modifiedAt = Date.now();
+  }
+  // ─── Trees ─────────────────────────────────────────────
+  addTreePrototype(prototype) {
+    this.data.treePrototypes.push(prototype);
+    this.data.metadata.modifiedAt = Date.now();
+  }
+  addTree(worldX, worldZ, prototypeId, scale, rotation) {
+    const prototype = this.data.treePrototypes.find((p) => p.id === prototypeId);
+    if (!prototype) {
+      return null;
+    }
+    const height = this.getHeightAtWorld(worldX, worldZ);
+    const actualScale = scale ?? prototype.minScale + Math.random() * (prototype.maxScale - prototype.minScale);
+    const actualRotation = rotation ?? (prototype.randomRotation ? Math.random() * Math.PI * 2 : 0);
+    const instance = {
+      position: { x: worldX, y: height, z: worldZ },
+      rotation: actualRotation,
+      scale: { x: actualScale, y: actualScale, z: actualScale },
+      prototypeId,
+      color: { r: 1, g: 1, b: 1, a: 1 },
+      lightmapColor: { r: 1, g: 1, b: 1, a: 1 }
+    };
+    this.data.trees.push(instance);
+    this.data.metadata.modifiedAt = Date.now();
+    return instance;
+  }
+  scatterTrees(prototypeId, density, minSlope = 0, maxSlope = 30, minHeight = 0, maxHeight = 1, minSpacing = 5) {
+    const prototype = this.data.treePrototypes.find((p) => p.id === prototypeId);
+    if (!prototype) {
+      return 0;
+    }
+    const { width, depth } = this.data.config;
+    let treesAdded = 0;
+    const cellSize = minSpacing / Math.SQRT2;
+    const gridWidth = Math.ceil(width / cellSize);
+    const gridDepth = Math.ceil(depth / cellSize);
+    const grid = [];
+    for (let i = 0; i < gridWidth; i++) {
+      grid[i] = [];
+      for (let j = 0; j < gridDepth; j++) {
+        grid[i][j] = null;
+      }
+    }
+    const numAttempts = Math.floor(width * depth * density);
+    const activeList = [];
+    const startX = Math.random() * width - width / 2;
+    const startZ = Math.random() * depth - depth / 2;
+    const startHeight = this.getHeightAtWorld(startX, startZ);
+    activeList.push({ x: startX, y: startHeight, z: startZ });
+    for (let attempt = 0; attempt < numAttempts && activeList.length > 0; attempt++) {
+      const idx = Math.floor(Math.random() * activeList.length);
+      const point = activeList[idx];
+      let found = false;
+      for (let k = 0; k < 30; k++) {
+        const angle = Math.random() * Math.PI * 2;
+        const r = minSpacing + Math.random() * minSpacing;
+        const newX = point.x + Math.cos(angle) * r;
+        const newZ = point.z + Math.sin(angle) * r;
+        if (newX < -width / 2 || newX > width / 2 || newZ < -depth / 2 || newZ > depth / 2) {
+          continue;
+        }
+        const newHeight = this.getHeightAtWorld(newX, newZ) / this.data.config.maxHeight;
+        const normal = this.getNormalAtWorld(newX, newZ);
+        const slope = Math.acos(normal.y) * (180 / Math.PI);
+        if (newHeight < minHeight || newHeight > maxHeight || slope < minSlope || slope > maxSlope) {
+          continue;
+        }
+        const gridX = Math.floor((newX + width / 2) / cellSize);
+        const gridZ = Math.floor((newZ + depth / 2) / cellSize);
+        let tooClose = false;
+        for (let di = -2; di <= 2 && !tooClose; di++) {
+          for (let dj = -2; dj <= 2 && !tooClose; dj++) {
+            const ni = gridX + di;
+            const nj = gridZ + dj;
+            if (ni >= 0 && ni < gridWidth && nj >= 0 && nj < gridDepth && grid[ni][nj]) {
+              const neighbor = grid[ni][nj];
+              const dx = neighbor.x - newX;
+              const dz = neighbor.z - newZ;
+              if (dx * dx + dz * dz < minSpacing * minSpacing) {
+                tooClose = true;
+              }
             }
-        }
-        this.data.metadata.modifiedAt = Date.now();
-    }
-    exportSplatmapAsPNG(splatmapIndex) {
-        if (splatmapIndex >= this.data.splatmaps.length) {
-            return null;
-        }
-        const res = this.data.config.splatmapResolution;
-        const splatmap = this.data.splatmaps[splatmapIndex];
-        const imageData = new ImageData(res, res);
-        for (let i = 0; i < splatmap.length; i++) {
-            imageData.data[i] = splatmap[i];
-        }
-        return imageData;
-    }
+          }
+        }
+        if (!tooClose) {
+          const newPoint = { x: newX, y: this.getHeightAtWorld(newX, newZ), z: newZ };
+          grid[gridX][gridZ] = newPoint;
+          activeList.push(newPoint);
+          this.addTree(newX, newZ, prototypeId);
+          treesAdded++;
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        activeList.splice(idx, 1);
+      }
+    }
+    return treesAdded;
+  }
+  removeTreesInRadius(worldX, worldZ, radius) {
+    const initialCount = this.data.trees.length;
+    this.data.trees = this.data.trees.filter((tree) => {
+      const dx = tree.position.x - worldX;
+      const dz = tree.position.z - worldZ;
+      return dx * dx + dz * dz > radius * radius;
+    });
+    this.data.metadata.modifiedAt = Date.now();
+    return initialCount - this.data.trees.length;
+  }
+  // ─── Undo/Redo ─────────────────────────────────────────
+  recordHeightChange(gridX, gridZ, oldValue, newValue) {
+    const operation = {
+      type: "height",
+      gridX,
+      gridZ,
+      oldValue,
+      newValue,
+      timestamp: Date.now()
+    };
+    this.undoStack.push(operation);
+    if (this.undoStack.length > this.maxUndoSteps) {
+      this.undoStack.shift();
+    }
+    this.redoStack = [];
+  }
+  undo() {
+    const operation = this.undoStack.pop();
+    if (!operation) {
+      return false;
+    }
+    if (operation.type === "height") {
+      const res = this.data.config.heightmapResolution;
+      this.data.heightmap[operation.gridZ * res + operation.gridX] = operation.oldValue;
+    }
+    this.redoStack.push(operation);
+    this.data.metadata.modifiedAt = Date.now();
+    return true;
+  }
+  redo() {
+    const operation = this.redoStack.pop();
+    if (!operation) {
+      return false;
+    }
+    if (operation.type === "height") {
+      const res = this.data.config.heightmapResolution;
+      this.data.heightmap[operation.gridZ * res + operation.gridX] = operation.newValue;
+    }
+    this.undoStack.push(operation);
+    this.data.metadata.modifiedAt = Date.now();
+    return true;
+  }
+  // ─── Serialization ─────────────────────────────────────
+  getData() {
+    return this.data;
+  }
+  setData(data) {
+    this.data = data;
+    this.undoStack = [];
+    this.redoStack = [];
+  }
+  serialize() {
+    return JSON.stringify({
+      ...this.data,
+      heightmap: Array.from(this.data.heightmap),
+      splatmaps: this.data.splatmaps.map((s) => Array.from(s)),
+      holemap: Array.from(this.data.holemap),
+      detailMaps: this.data.detailMaps.map((d) => Array.from(d))
+    });
+  }
+  static deserialize(json) {
+    const data = JSON.parse(json);
+    const terrain = new TerrainSystem(data.config);
+    terrain.data = {
+      ...data,
+      heightmap: new Float32Array(data.heightmap),
+      splatmaps: data.splatmaps.map((s) => new Uint8Array(s)),
+      holemap: new Uint8Array(data.holemap),
+      detailMaps: data.detailMaps.map((d) => new Uint8Array(d))
+    };
+    return terrain;
+  }
+  // ─── Export Heightmap ──────────────────────────────────
+  exportHeightmapAsRAW() {
+    const res = this.data.config.heightmapResolution;
+    const buffer = new ArrayBuffer(res * res * 2);
+    const view = new Uint16Array(buffer);
+    for (let i = 0; i < this.data.heightmap.length; i++) {
+      view[i] = Math.round(this.data.heightmap[i] * 65535);
+    }
+    return buffer;
+  }
+  importHeightmapFromRAW(buffer, is16bit = true) {
+    const res = this.data.config.heightmapResolution;
+    if (is16bit) {
+      const view = new Uint16Array(buffer);
+      const expectedSize = res * res;
+      if (view.length !== expectedSize) {
+        throw new Error(`RAW size mismatch: expected ${expectedSize}, got ${view.length}`);
+      }
+      for (let i = 0; i < view.length; i++) {
+        this.data.heightmap[i] = view[i] / 65535;
+      }
+    } else {
+      const view = new Uint8Array(buffer);
+      const expectedSize = res * res;
+      if (view.length !== expectedSize) {
+        throw new Error(`RAW size mismatch: expected ${expectedSize}, got ${view.length}`);
+      }
+      for (let i = 0; i < view.length; i++) {
+        this.data.heightmap[i] = view[i] / 255;
+      }
+    }
+    this.data.metadata.modifiedAt = Date.now();
+  }
+  exportSplatmapAsPNG(splatmapIndex) {
+    if (splatmapIndex >= this.data.splatmaps.length) {
+      return null;
+    }
+    const res = this.data.config.splatmapResolution;
+    const splatmap = this.data.splatmaps[splatmapIndex];
+    const imageData = new ImageData(res, res);
+    for (let i = 0; i < splatmap.length; i++) {
+      imageData.data[i] = splatmap[i];
+    }
+    return imageData;
+  }
 }
-// ============================================================
-// Factory Functions
-// ============================================================
 function createTerrain(config) {
-    return new TerrainSystem(config);
+  return new TerrainSystem(config);
 }
 function createFlatTerrain(config) {
-    const terrain = new TerrainSystem(config);
-    // Already flat (heights = 0)
-    return terrain;
+  const terrain = new TerrainSystem(config);
+  return terrain;
 }
 function createHillyTerrain(config) {
-    const terrain = new TerrainSystem(config);
-    terrain.generatePerlinTerrain(0.005, 6, 0.5);
-    return terrain;
+  const terrain = new TerrainSystem(config);
+  terrain.generatePerlinTerrain(5e-3, 6, 0.5);
+  return terrain;
 }
 function createMountainousTerrain(config) {
-    const terrain = new TerrainSystem(config);
-    terrain.generateDiamondSquare(0.6);
-    terrain.applyHydraulicErosion(30000);
-    return terrain;
+  const terrain = new TerrainSystem(config);
+  terrain.generateDiamondSquare(0.6);
+  terrain.applyHydraulicErosion(3e4);
+  return terrain;
 }
 function createIslandTerrain(config) {
-    const terrain = new TerrainSystem(config);
-    const res = terrain.getData().config.heightmapResolution;
-    const data = terrain.getData();
-    // Generate hills
-    terrain.generatePerlinTerrain(0.008, 5, 0.5);
-    // Apply radial falloff for island shape
-    const centerX = res / 2;
-    const centerZ = res / 2;
-    const maxDist = Math.min(centerX, centerZ) * 0.9;
-    for (let z = 0; z < res; z++) {
-        for (let x = 0; x < res; x++) {
-            const dx = x - centerX;
-            const dz = z - centerZ;
-            const dist = Math.sqrt(dx * dx + dz * dz);
-            const falloff = Math.max(0, 1 - dist / maxDist);
-            const smoothFalloff = falloff * falloff * (3 - 2 * falloff); // Smoothstep
-            data.heightmap[z * res + x] *= smoothFalloff;
-        }
-    }
-    terrain.setData(data);
-    return terrain;
+  const terrain = new TerrainSystem(config);
+  const res = terrain.getData().config.heightmapResolution;
+  const data = terrain.getData();
+  terrain.generatePerlinTerrain(8e-3, 5, 0.5);
+  const centerX = res / 2;
+  const centerZ = res / 2;
+  const maxDist = Math.min(centerX, centerZ) * 0.9;
+  for (let z = 0; z < res; z++) {
+    for (let x = 0; x < res; x++) {
+      const dx = x - centerX;
+      const dz = z - centerZ;
+      const dist = Math.sqrt(dx * dx + dz * dz);
+      const falloff = Math.max(0, 1 - dist / maxDist);
+      const smoothFalloff = falloff * falloff * (3 - 2 * falloff);
+      data.heightmap[z * res + x] *= smoothFalloff;
+    }
+  }
+  terrain.setData(data);
+  return terrain;
 }
-
-export { DEFAULT_BRUSH, DEFAULT_TERRAIN_CONFIG, TerrainSystem, createFlatTerrain, createGrassDetail, createHillyTerrain, createIslandTerrain, createMountainousTerrain, createTerrain, createTerrainLayer, createTreePrototype };
+export {
+  DEFAULT_BRUSH,
+  DEFAULT_TERRAIN_CONFIG,
+  TerrainSystem,
+  createFlatTerrain,
+  createGrassDetail,
+  createHillyTerrain,
+  createIslandTerrain,
+  createMountainousTerrain,
+  createTerrain,
+  createTerrainLayer,
+  createTreePrototype
+};