@zephyr3d/scene 0.9.24 → 0.9.25

package/dist/scene/terrain-cm/grass.js

@@ -31,30 +31,40 @@ import '../../shaders/atmosphere.js';
 import '../../render/rendergraph/scene_render_context.js';
 import { ClipmapGrassMaterial } from './grassmaterial.js';
 
-const MAX_INSTANCES_PER_NODE = 2048;
 const INSTANCE_BYTES = 4 * 4;
+/** Number of placement cells along each axis of a grass tile */ const TILE_CELLS = 64;
+/** Default number of placement cells per density map texel along each axis */ const DEFAULT_CELLS_PER_TEXEL = 2;
+const MAX_CELLS_PER_TEXEL = 8;
 /**
- * Grass glade instance manager class
+ * Deterministic 2D integer hash, returns a value in [0, 1).
+ * Grass placement derives everything (jitter, survival threshold, rotation)
+ * from this hash so that blade positions are stable across edits and reloads.
+ */ function hashCell(x, z, seed) {
+    let h = Math.imul(x, 0x27d4eb2d) ^ Math.imul(z, 0x165667b1) ^ Math.imul(seed, 0x9e3779b9) | 0;
+    h = Math.imul(h ^ h >>> 15, 0x85ebca6b);
+    h = Math.imul(h ^ h >>> 13, 0xc2b2ae35);
+    h ^= h >>> 16;
+    return (h >>> 0) / 4294967296;
+}
+/**
+ * Grass blade instance buffer for a single tile
  * @internal
  */ class GrassInstances extends Disposable {
-    _instances;
+    _numInstances;
     _baseVertexBuffer;
     _indexBuffer;
     _instanceBuffer;
     _primitive;
     constructor(baseVertexBuffer, indexBuffer){
         super();
-        this._instances = [];
+        this._numInstances = 0;
         this._baseVertexBuffer = new DRef(baseVertexBuffer);
         this._indexBuffer = new DRef(indexBuffer);
         this._instanceBuffer = new DRef();
         this._primitive = new DRef();
     }
     get numInstances() {
-        return this._instances.length;
-    }
-    get instanceBuffer() {
-        return this._instanceBuffer.get();
+        return this._numInstances;
     }
     setBaseVertexBuffer(baseVertexBuffer) {
         if (baseVertexBuffer !== this._baseVertexBuffer.get()) {
@@ -62,8 +72,25 @@ const INSTANCE_BYTES = 4 * 4;
             this._primitive.dispose();
         }
     }
+    /**
+   * Sets the packed instance data (x, y, sin, cos per instance)
+   */ setData(data, count) {
+        this._numInstances = count;
+        if (count === 0) {
+            return;
+        }
+        const device = getDevice();
+        const bytesRequired = count * INSTANCE_BYTES;
+        let buffer = this._instanceBuffer.get();
+        if (!buffer || buffer.byteLength < bytesRequired) {
+            buffer = device.createVertexBuffer('tex1_f32x4', new Uint8Array(nextPowerOf2(bytesRequired)));
+            this._instanceBuffer.set(buffer);
+            this._primitive.dispose();
+        }
+        buffer.bufferSubData(0, data.subarray(0, count * 4));
+    }
     draw() {
-        if (this._instances.length > 0) {
+        if (this._numInstances > 0) {
             if (!this._primitive.get()) {
                 const primitive = new Primitive();
                 primitive.setVertexBuffer(this._baseVertexBuffer.get());
@@ -74,58 +101,8 @@ const INSTANCE_BYTES = 4 * 4;
                 primitive.indexCount = this._indexBuffer.get().length;
                 this._primitive.set(primitive);
             }
-            this._primitive.get().drawInstanced(this._instances.length);
-        }
-    }
-    updateBuffers() {
-        const device = getDevice();
-        if (this._instances.length === 0) {
-            this._instanceBuffer.set(null);
-            return;
-        }
-        if (this._instances.length > 0 && !this._instanceBuffer.get()) {
-            this._instanceBuffer.set(device.createVertexBuffer('tex1_f32x4', new Uint8Array(this._instances.length * INSTANCE_BYTES)));
-        }
-        let buffer = this._instanceBuffer.get();
-        const currentBytes = buffer.byteLength;
-        const bytesRequired = this._instances.length * INSTANCE_BYTES;
-        if (currentBytes < bytesRequired) {
-            buffer = device.createVertexBuffer('tex1_f32x4', new Uint8Array(nextPowerOf2(bytesRequired)));
-            this._instanceBuffer.set(buffer);
-            this._primitive.dispose();
-        }
-        const data = new Float32Array(4 * this._instances.length);
-        for(let i = 0; i < this._instances.length; i++){
-            data[i * 4 + 0] = this._instances[i].x;
-            data[i * 4 + 1] = this._instances[i].y;
-            data[i * 4 + 2] = Math.sin(this._instances[i].angle);
-            data[i * 4 + 3] = Math.cos(this._instances[i].angle);
-        }
-        buffer.bufferSubData(0, data);
-    }
-    removeInstances(minX, minZ, maxX, maxZ, num) {
-        if (num <= 0) {
-            return 0;
-        }
-        let removed = 0;
-        for(let i = this._instances.length - 1; i >= 0; i--){
-            const instance = this._instances[i];
-            if (instance.x >= minX && instance.x <= maxX && instance.y >= minZ && instance.y <= maxZ) {
-                this._instances.splice(i, 1);
-                removed++;
-                if (removed === num) {
-                    break;
-                }
-            }
-        }
-        if (removed > 0) {
-            this.updateBuffers();
+            this._primitive.get().drawInstanced(this._numInstances);
         }
-        return removed;
-    }
-    addInstances(instances) {
-        this._instances.push(...instances);
-        this.updateBuffers();
     }
     onDispose() {
         super.onDispose();
@@ -137,34 +114,53 @@ const INSTANCE_BYTES = 4 * 4;
 }
 /**
  * Grass layer class
+ *
  * @public
  */ class GrassLayer extends Disposable {
     static _indexBuffer = new DRef();
+    static _cullAABB = new AABB();
+    static _visibleTiles = [];
+    static _instanceData = new Float32Array(TILE_CELLS * TILE_CELLS * 4);
     _material;
-    _quadtree;
+    _seed;
     _bladeWidth;
     _bladeHeight;
     _baseVertexBuffer;
+    _densityWidth;
+    _densityHeight;
+    _cellsPerTexel;
+    _densityMap;
+    _tiles;
+    _tilesX;
+    _tilesZ;
+    _numBlades;
     /**
    * Creates an instance of GrassLayer
    * @param terrain - Clipmap terrain object
+   * @param seed - Seed for deterministic blade placement, usually the layer index
    * @param bladeWidth - Grass blade width
    * @param bladeHeight - Grass blade height
    * @param albedoMap - Albedo texture for the blade
-   */ constructor(terrain, bladeWidth, bladeHeight, albedoMap){
+   */ constructor(terrain, seed, bladeWidth, bladeHeight, albedoMap){
         super();
         this._material = new DRef(new ClipmapGrassMaterial(terrain));
         this._material.get().albedoTexture = albedoMap ?? null;
         if (albedoMap) {
             this._material.get().setTextureSize(albedoMap.width, albedoMap.height);
         }
+        this._seed = seed;
         this._bladeWidth = bladeWidth;
         this._bladeHeight = bladeHeight;
         this._baseVertexBuffer = new DRef(this.createBaseVertexBuffer(this._bladeWidth, this._bladeHeight));
-        this._quadtree = new DRef(new GrassQuadtreeNode(this._baseVertexBuffer.get(), GrassLayer._getIndexBuffer()));
-    }
-    /** @internal */ get quadtree() {
-        return this._quadtree.get();
+        this._densityWidth = Math.max(1, terrain.sizeX);
+        this._densityHeight = Math.max(1, terrain.sizeZ);
+        this._cellsPerTexel = DEFAULT_CELLS_PER_TEXEL;
+        this._densityMap = new Uint8Array(this._densityWidth * this._densityHeight);
+        this._tiles = new Map();
+        this._tilesX = 0;
+        this._tilesZ = 0;
+        this._numBlades = 0;
+        this.updateTileGrid();
     }
     /** @internal */ updateMaterial() {
         this._material.get().uniformChanged();
@@ -184,21 +180,93 @@ const INSTANCE_BYTES = 4 * 4;
    */ getAlbedoMap() {
         return this._material.get().albedoTexture;
     }
+    /** How many grass blades are currently generated in this layer */ get numBlades() {
+        return this._numBlades;
+    }
+    /**
+   * Density map of this layer, one byte per texel (0 = no grass, 255 = full density).
+   * Texel (x, z) covers the normalized terrain region [x/w..(x+1)/w, z/h..(z+1)/h].
+   * After modifying the data, call {@link GrassLayer.updateDensityRegion} to
+   * regenerate the affected blade instances.
+   */ get densityMap() {
+        return this._densityMap;
+    }
+    /** Width of the density map in texels */ get densityMapWidth() {
+        return this._densityWidth;
+    }
+    /** Height of the density map in texels */ get densityMapHeight() {
+        return this._densityHeight;
+    }
+    /**
+   * Number of placement cells per density map texel along each axis.
+   * The maximum blade count per texel is the square of this value.
+   */ get cellsPerTexel() {
+        return this._cellsPerTexel;
+    }
+    set cellsPerTexel(val) {
+        val = Math.max(1, Math.min(MAX_CELLS_PER_TEXEL, val | 0));
+        if (val !== this._cellsPerTexel) {
+            this._cellsPerTexel = val;
+            this.rebuild();
+        }
+    }
+    /**
+   * Replaces the density map and regenerates all blade instances
+   * @param width - Density map width in texels
+   * @param height - Density map height in texels
+   * @param cellsPerTexel - Placement cells per texel along each axis
+   * @param data - Density data, one byte per texel
+   */ setDensityData(width, height, cellsPerTexel, data) {
+        if (width < 1 || height < 1 || width * height !== data.length) {
+            console.error('Invalid grass density data');
+            return;
+        }
+        this._densityWidth = width;
+        this._densityHeight = height;
+        this._cellsPerTexel = Math.max(1, Math.min(MAX_CELLS_PER_TEXEL, cellsPerTexel | 0));
+        this._densityMap = data;
+        this.rebuild();
+    }
     /**
-   * Add grass blades to this layer in a region
-   * @param instances - Grass blade instances to add
-   */ addInstances(instances) {
-        return this._quadtree.get().addInstances(instances);
+   * Regenerates blade instances for all tiles overlapping a density map region
+   * @param minTexelX - Minimum x texel of the region (inclusive)
+   * @param minTexelZ - Minimum z texel of the region (inclusive)
+   * @param maxTexelX - Maximum x texel of the region (exclusive)
+   * @param maxTexelZ - Maximum z texel of the region (exclusive)
+   */ updateDensityRegion(minTexelX, minTexelZ, maxTexelX, maxTexelZ) {
+        const k = this._cellsPerTexel;
+        // expand by one texel to cover the bilinear sampling footprint
+        const cx0 = Math.max(0, (minTexelX - 1) * k);
+        const cz0 = Math.max(0, (minTexelZ - 1) * k);
+        const cx1 = Math.min(this._densityWidth * k, (maxTexelX + 1) * k);
+        const cz1 = Math.min(this._densityHeight * k, (maxTexelZ + 1) * k);
+        if (cx1 <= cx0 || cz1 <= cz0) {
+            return;
+        }
+        const tx0 = Math.floor(cx0 / TILE_CELLS);
+        const tz0 = Math.floor(cz0 / TILE_CELLS);
+        const tx1 = Math.min(this._tilesX, Math.ceil(cx1 / TILE_CELLS));
+        const tz1 = Math.min(this._tilesZ, Math.ceil(cz1 / TILE_CELLS));
+        for(let tz = tz0; tz < tz1; tz++){
+            for(let tx = tx0; tx < tx1; tx++){
+                this.generateTile(tx, tz);
+            }
+        }
     }
     /**
-   * Remove grass blades to this layer in a region
-   * @param minX - Minimum x position of the region
-   * @param minZ - Minimum z position of the region
-   * @param maxX - Maximum x position of the region
-   * @param maxZ - Maximum z position of the region
-   * @param numInstances - How many grass blades to add
-   */ removeInstances(minX, minZ, maxX, maxZ, numInstances) {
-        this._quadtree.get().removeInstances(minX, minZ, maxX, maxZ, numInstances);
+   * Regenerates blade instances for the entire layer
+   */ rebuild() {
+        for (const tile of this._tiles.values()){
+            tile.dispose();
+        }
+        this._tiles.clear();
+        this._numBlades = 0;
+        this.updateTileGrid();
+        for(let tz = 0; tz < this._tilesZ; tz++){
+            for(let tx = 0; tx < this._tilesX; tx++){
+                this.generateTile(tx, tz);
+            }
+        }
     }
     /** Grass blade width in this layer */ get bladeWidth() {
         return this._bladeWidth;
@@ -221,7 +289,92 @@ const INSTANCE_BYTES = 4 * 4;
             this._bladeWidth = width;
             this._bladeHeight = height;
             this._baseVertexBuffer.set(this.createBaseVertexBuffer(this._bladeWidth, this._bladeHeight));
-            this._quadtree.get().setBaseVertexBuffer(this._baseVertexBuffer.get());
+            for (const tile of this._tiles.values()){
+                tile.setBaseVertexBuffer(this._baseVertexBuffer.get());
+            }
+        }
+    }
+    /** @internal */ updateTileGrid() {
+        this._tilesX = Math.ceil(this._densityWidth * this._cellsPerTexel / TILE_CELLS);
+        this._tilesZ = Math.ceil(this._densityHeight * this._cellsPerTexel / TILE_CELLS);
+    }
+    /** @internal */ sampleDensity(u, v) {
+        const w = this._densityWidth;
+        const h = this._densityHeight;
+        const x = u * w - 0.5;
+        const z = v * h - 0.5;
+        const ix = Math.floor(x);
+        const iz = Math.floor(z);
+        const fx = x - ix;
+        const fz = z - iz;
+        const x0 = Math.min(Math.max(ix, 0), w - 1);
+        const x1 = Math.min(Math.max(ix + 1, 0), w - 1);
+        const z0 = Math.min(Math.max(iz, 0), h - 1);
+        const z1 = Math.min(Math.max(iz + 1, 0), h - 1);
+        const d = this._densityMap;
+        const a = d[z0 * w + x0] + (d[z0 * w + x1] - d[z0 * w + x0]) * fx;
+        const b = d[z1 * w + x0] + (d[z1 * w + x1] - d[z1 * w + x0]) * fx;
+        return (a + (b - a) * fz) * (1 / 255);
+    }
+    /** @internal */ regionIsEmpty(cx0, cz0, cx1, cz1) {
+        const k = this._cellsPerTexel;
+        const x0 = Math.max(0, Math.floor(cx0 / k) - 1);
+        const z0 = Math.max(0, Math.floor(cz0 / k) - 1);
+        const x1 = Math.min(this._densityWidth, Math.ceil(cx1 / k) + 1);
+        const z1 = Math.min(this._densityHeight, Math.ceil(cz1 / k) + 1);
+        for(let z = z0; z < z1; z++){
+            const rowBase = z * this._densityWidth;
+            for(let x = x0; x < x1; x++){
+                if (this._densityMap[rowBase + x] !== 0) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    /** @internal */ generateTile(tx, tz) {
+        const k = this._cellsPerTexel;
+        const cw = this._densityWidth * k;
+        const ch = this._densityHeight * k;
+        const cx0 = tx * TILE_CELLS;
+        const cz0 = tz * TILE_CELLS;
+        const cx1 = Math.min(cx0 + TILE_CELLS, cw);
+        const cz1 = Math.min(cz0 + TILE_CELLS, ch);
+        const key = tz * this._tilesX + tx;
+        let tile = this._tiles.get(key);
+        // fast path: nothing to generate if there is no tile yet and no density
+        if (!tile && this.regionIsEmpty(cx0, cz0, cx1, cz1)) {
+            return;
+        }
+        const data = GrassLayer._instanceData;
+        const seed = this._seed * 4;
+        let count = 0;
+        for(let cz = cz0; cz < cz1; cz++){
+            for(let cx = cx0; cx < cx1; cx++){
+                const u = (cx + hashCell(cx, cz, seed)) / cw;
+                const v = (cz + hashCell(cx, cz, seed + 1)) / ch;
+                if (this.sampleDensity(u, v) > hashCell(cx, cz, seed + 2)) {
+                    const angle = hashCell(cx, cz, seed + 3) * Math.PI * 2;
+                    data[count * 4 + 0] = u;
+                    data[count * 4 + 1] = v;
+                    data[count * 4 + 2] = Math.sin(angle);
+                    data[count * 4 + 3] = Math.cos(angle);
+                    count++;
+                }
+            }
+        }
+        this._numBlades += count - (tile?.numInstances ?? 0);
+        if (count === 0) {
+            if (tile) {
+                tile.dispose();
+                this._tiles.delete(key);
+            }
+        } else {
+            if (!tile) {
+                tile = new GrassInstances(this._baseVertexBuffer.get(), GrassLayer._getIndexBuffer());
+                this._tiles.set(key, tile);
+            }
+            tile.setData(data, count);
         }
     }
     /** @internal */ static _getIndexBuffer() {
@@ -323,16 +476,49 @@ const INSTANCE_BYTES = 4 * 4;
         ], vertices);
     }
     /** @internal */ draw(ctx, region, minY, maxY) {
+        const visible = GrassLayer._visibleTiles;
+        visible.length = 0;
+        const camera = ctx.camera;
+        const cullAABB = GrassLayer._cullAABB;
+        const cellsW = this._densityWidth * this._cellsPerTexel;
+        const cellsH = this._densityHeight * this._cellsPerTexel;
+        const rx = region.x;
+        const rz = region.y;
+        const rw = region.z - region.x;
+        const rh = region.w - region.y;
+        for (const [key, tile] of this._tiles){
+            const tx = key % this._tilesX;
+            const tz = (key - tx) / this._tilesX;
+            const u0 = tx * TILE_CELLS / cellsW;
+            const v0 = tz * TILE_CELLS / cellsH;
+            const u1 = Math.min(1, (tx + 1) * TILE_CELLS / cellsW);
+            const v1 = Math.min(1, (tz + 1) * TILE_CELLS / cellsH);
+            cullAABB.minPoint.setXYZ(rx + u0 * rw, minY, rz + v0 * rh);
+            cullAABB.maxPoint.setXYZ(rx + u1 * rw, maxY, rz + v1 * rh);
+            const clipState = camera.clipMask ? cullAABB.getClipStateWithFrustumMask(camera.frustum, camera.clipMask) : cullAABB.getClipStateWithFrustum(camera.frustum);
+            if (clipState !== ClipState.NOT_CLIPPED) {
+                visible.push(tile);
+            }
+        }
+        if (visible.length === 0) {
+            return;
+        }
         this._material.get().apply(ctx);
         for(let pass = 0; pass < this._material.get().numPasses; pass++){
             this._material.get().bind(ctx.device, pass);
-            this._quadtree.get().draw(ctx.camera, region, minY, maxY, false);
+            for (const tile of visible){
+                tile.draw();
+            }
         }
+        visible.length = 0;
     }
     /** @internal */ onDispose() {
         super.onDispose();
         this._material.dispose();
-        this._quadtree.dispose();
+        for (const tile of this._tiles.values()){
+            tile.dispose();
+        }
+        this._tiles.clear();
         this._baseVertexBuffer.dispose();
     }
 }
@@ -341,7 +527,6 @@ const INSTANCE_BYTES = 4 * 4;
  * @public
  */ class GrassRenderer extends Disposable {
     _terrain;
-    _numGrassBlades;
     _layers;
     /**
    * Creates an instance of GrassRenderer
@@ -349,7 +534,6 @@ const INSTANCE_BYTES = 4 * 4;
    */ constructor(terrain){
         super();
         this._terrain = new DWeakRef(terrain);
-        this._numGrassBlades = 0;
         this._layers = [];
     }
     /** @internal */ updateMaterial() {
@@ -358,7 +542,7 @@ const INSTANCE_BYTES = 4 * 4;
         }
     }
     /** How many grass blades */ get numGrassBlades() {
-        return this._numGrassBlades;
+        return this._layers.reduce((sum, layer)=>sum + layer.numBlades, 0);
     }
     /** How many grass layers */ get numLayers() {
         return this._layers.length;
@@ -377,7 +561,7 @@ const INSTANCE_BYTES = 4 * 4;
    * @param albedoMap - Albedo texture of grass blades in this layer
    * @returns Index of the added grass layer
    */ addLayer(bladeWidth, bladeHeight, albedoMap) {
-        const layer = new GrassLayer(this._terrain.get(), bladeWidth, bladeHeight, albedoMap);
+        const layer = new GrassLayer(this._terrain.get(), this._layers.length, bladeWidth, bladeHeight, albedoMap);
         this._layers.push(layer);
         return this._layers.length - 1;
     }
@@ -427,34 +611,6 @@ const INSTANCE_BYTES = 4 * 4;
             console.error(`Invalid grass layer: ${layer}`);
         }
     }
-    /**
-   * Add grass instances to the grass layer at given index
-   * @param layer - Index of the grass layer
-   * @param instances - Grass blade instances to add
-   */ addInstances(layer, instances) {
-        const grassLayer = this._layers[layer];
-        if (!grassLayer) {
-            console.error(`Invalid grass layer: ${layer}`);
-        } else {
-            this._numGrassBlades += grassLayer.addInstances(instances);
-        }
-    }
-    /**
-   * Remove grass instances from the grass layer at given index within a region
-   * @param layer - Index of the grass layer
-   * @param minX - Minimum x of the region
-   * @param minZ - Minimum z of the region
-   * @param maxX - Maximum x of the region
-   * @param maxZ - Maximum z of the region
-   * @param num - How many grass blades to remove
-   */ removeInstances(layer, minX, minZ, maxX, maxZ, num) {
-        const grassLayer = this._layers[layer];
-        if (!grassLayer) {
-            console.error(`Invalid grass layer: ${layer}`);
-        } else {
-            grassLayer.removeInstances(minX, minZ, maxX, maxZ, num);
-        }
-    }
     /** @internal */ draw(ctx) {
         const bv = this._terrain.get().getWorldBoundingVolume().toAABB();
         const minY = bv.minPoint.y;
@@ -471,141 +627,6 @@ const INSTANCE_BYTES = 4 * 4;
         }
     }
 }
-/** @internal */ class GrassQuadtreeNode extends Disposable {
-    static _cullAABB = new AABB();
-    _grassInstances;
-    _children;
-    _baseVertexBuffer;
-    _indexBuffer;
-    _minX;
-    _minZ;
-    _maxX;
-    _maxZ;
-    constructor(baseVertexBuffer, indexBuffer){
-        super();
-        this._baseVertexBuffer = new DRef(baseVertexBuffer);
-        this._indexBuffer = new DRef(indexBuffer);
-        this._grassInstances = new DRef(new GrassInstances(baseVertexBuffer, indexBuffer));
-        this._children = null;
-        this._minX = 0;
-        this._minZ = 0;
-        this._maxX = 1;
-        this._maxZ = 1;
-    }
-    get grassInstances() {
-        return this._grassInstances.get();
-    }
-    get children() {
-        return this._children;
-    }
-    draw(camera, region, minY, maxY, skipClipTest) {
-        if (!skipClipTest) {
-            const cullAABB = GrassQuadtreeNode._cullAABB;
-            const x = region.x;
-            const z = region.y;
-            const dx = region.z - x;
-            const dz = region.w - z;
-            cullAABB.minPoint.setXYZ(x + this._minX * dx, minY, z + this._minZ * dz);
-            cullAABB.maxPoint.setXYZ(x + this._maxX * dx, maxY, z + this._maxZ * dz);
-            const clipState = camera.clipMask ? cullAABB.getClipStateWithFrustumMask(camera.frustum, camera.clipMask) : cullAABB.getClipStateWithFrustum(camera.frustum);
-            if (clipState === ClipState.NOT_CLIPPED) {
-                return;
-            }
-            skipClipTest = clipState === ClipState.A_INSIDE_B;
-        }
-        if (this._grassInstances.get().numInstances > 0) {
-            this._grassInstances.get().draw();
-        }
-        if (this._children) {
-            for (const child of this._children){
-                child.draw(camera, region, minY, maxY, skipClipTest);
-            }
-        }
-    }
-    setBaseVertexBuffer(baseVertexBuffer) {
-        if (baseVertexBuffer !== this._baseVertexBuffer.get()) {
-            this._baseVertexBuffer.set(baseVertexBuffer);
-            this._grassInstances.get().setBaseVertexBuffer(baseVertexBuffer);
-            if (this._children) {
-                for (const child of this._children){
-                    child.setBaseVertexBuffer(baseVertexBuffer);
-                }
-            }
-        }
-    }
-    removeInstances(minX, minZ, maxX, maxZ, numInstances) {
-        let n = Math.min(this._grassInstances.get().numInstances, numInstances);
-        if (n <= 0) {
-            return 0;
-        }
-        let removed = 0;
-        if (this._children) {
-            for (const child of this._children){
-                if (child._minX < maxX && child._minZ < maxZ && child._maxX > minX && child._maxZ > minZ) {
-                    removed += child.removeInstances(minX, minZ, maxX, maxZ, n);
-                    n -= removed;
-                }
-            }
-        }
-        if (n > 0) {
-            removed += this._grassInstances.get().removeInstances(minX, minZ, maxX, maxZ, n);
-        }
-        return removed;
-    }
-    addInstances(instances) {
-        if (instances.length === 0) {
-            return 0;
-        }
-        let n = Math.min(instances.length, MAX_INSTANCES_PER_NODE - this._grassInstances.get().numInstances);
-        this._grassInstances.get().addInstances(instances.slice(0, n));
-        if (n < instances.length) {
-            if (!this._children) {
-                this._children = [
-                    new GrassQuadtreeNode(this._baseVertexBuffer.get(), this._indexBuffer.get()),
-                    new GrassQuadtreeNode(this._baseVertexBuffer.get(), this._indexBuffer.get()),
-                    new GrassQuadtreeNode(this._baseVertexBuffer.get(), this._indexBuffer.get()),
-                    new GrassQuadtreeNode(this._baseVertexBuffer.get(), this._indexBuffer.get())
-                ];
-                this._children[0]._minX = this._minX;
-                this._children[0]._minZ = this._minZ;
-                this._children[0]._maxX = (this._minX + this._maxX) * 0.5;
-                this._children[0]._maxZ = (this._minZ + this._maxZ) * 0.5;
-                this._children[1]._minX = this._children[0]._maxX;
-                this._children[1]._minZ = this._minZ;
-                this._children[1]._maxX = this._maxX;
-                this._children[1]._maxZ = this._children[0]._maxZ;
-                this._children[2]._minX = this._minX;
-                this._children[2]._minZ = this._children[0]._maxZ;
-                this._children[2]._maxX = this._children[0]._maxX;
-                this._children[2]._maxZ = this._maxZ;
-                this._children[3]._minX = this._children[0]._maxX;
-                this._children[3]._minZ = this._children[0]._maxZ;
-                this._children[3]._maxX = this._maxX;
-                this._children[3]._maxZ = this._maxZ;
-            }
-            instances = instances.slice(n);
-            for (const child of this._children){
-                if (instances.length > 0) {
-                    const childInstances = instances.filter((val)=>val.x >= child._minX && val.y >= child._minZ && val.x < child._maxX && val.y < child._maxZ);
-                    n += child.addInstances(childInstances);
-                    instances = instances.filter((val)=>!(val.x >= child._minX && val.y >= child._minZ && val.x < child._maxX && val.y < child._maxZ));
-                }
-            }
-        }
-        return n;
-    }
-    onDispose() {
-        super.onDispose();
-        this._baseVertexBuffer.dispose();
-        this._indexBuffer.dispose();
-        this._grassInstances.dispose();
-        if (this._children) {
-            for (const child of this._children){
-                child.dispose();
-            }
-        }
-    }
-}
 
-export { GrassInstances, GrassLayer, GrassQuadtreeNode, GrassRenderer };
+export { GrassInstances, GrassLayer, GrassRenderer };
 //# sourceMappingURL=grass.js.map