@nice2dev/game-engine 1.0.4 → 1.0.10

package/dist/cjs/systems/TerrainSystem.js

@@ -0,0 +1,1137 @@
+'use strict';
+
+/**
+ * @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,
+};
+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 },
+    };
+}
+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,
+    };
+}
+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,
+    };
+}
+const DEFAULT_BRUSH = {
+    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 } = 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)),
+        });
+    }
+    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;
+            }
+        }
+        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);
+}
+function createFlatTerrain(config) {
+    const terrain = new TerrainSystem(config);
+    // Already flat (heights = 0)
+    return terrain;
+}
+function createHillyTerrain(config) {
+    const terrain = new TerrainSystem(config);
+    terrain.generatePerlinTerrain(0.005, 6, 0.5);
+    return terrain;
+}
+function createMountainousTerrain(config) {
+    const terrain = new TerrainSystem(config);
+    terrain.generateDiamondSquare(0.6);
+    terrain.applyHydraulicErosion(30000);
+    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;
+}
+
+exports.DEFAULT_BRUSH = DEFAULT_BRUSH;
+exports.DEFAULT_TERRAIN_CONFIG = DEFAULT_TERRAIN_CONFIG;
+exports.TerrainSystem = TerrainSystem;
+exports.createFlatTerrain = createFlatTerrain;
+exports.createGrassDetail = createGrassDetail;
+exports.createHillyTerrain = createHillyTerrain;
+exports.createIslandTerrain = createIslandTerrain;
+exports.createMountainousTerrain = createMountainousTerrain;
+exports.createTerrain = createTerrain;
+exports.createTerrainLayer = createTerrainLayer;
+exports.createTreePrototype = createTreePrototype;
+//# sourceMappingURL=TerrainSystem.js.map