@zephyr3d/scene 0.1.0

package/dist/scene/terrain/quadtree.js

@@ -0,0 +1,430 @@
+import { isPowerOf2, nextPowerOf2, Vector3, Frustum, Matrix4x4, ClipState } from '@zephyr3d/base';
+import { BoundingBox } from '../../utility/bounding_volume.js';
+import { TerrainPatch } from './patch.js';
+import { HeightField } from './heightfield.js';
+import { Application } from '../../app.js';
+import { RENDER_PASS_TYPE_SHADOWMAP } from '../../values.js';
+
+/** @internal */ class QuadtreeNode {
+    _patch;
+    _grassClusters;
+    _parent;
+    _children;
+    constructor(){
+        this._patch = null;
+        this._grassClusters = [];
+        this._parent = null;
+        this._children = null;
+    }
+    get grassClusters() {
+        return this._grassClusters;
+    }
+    addGrassCluster(grassCluster) {
+        this._grassClusters.push(grassCluster);
+    }
+    initialize(quadtree, parent, rowIndex, colIndex, baseVertices, normals, heightScale, elevations) {
+        this._parent = parent;
+        this._children = [];
+        this._patch = new TerrainPatch(quadtree.terrain);
+        //const rowIndex = position === PatchPosition.LeftBottom || position === PatchPosition.LeftTop ? 0 : 1;
+        //const colIndex = position === PatchPosition.LeftTop || position === PatchPosition.RightTop ? 0 : 1;
+        if (!this._patch.initialize(quadtree, this._parent?._patch || null, rowIndex, colIndex, baseVertices, normals, heightScale, elevations)) {
+            return false;
+        }
+        if (this._patch.getStep() > 1) {
+            let bbox = null;
+            const size = (quadtree.getPatchSize() - 1) * (this._patch.getStep() >> 1);
+            const offsetX = this._patch.getOffsetX();
+            const offsetZ = this._patch.getOffsetZ();
+            const offsets = [
+                [
+                    offsetX,
+                    offsetZ
+                ],
+                [
+                    offsetX + size,
+                    offsetZ
+                ],
+                [
+                    offsetX,
+                    offsetZ + size
+                ],
+                [
+                    offsetX + size,
+                    offsetZ + size
+                ]
+            ];
+            const rootSizeX = quadtree.getRootSizeX() - 1;
+            const rootSizeZ = quadtree.getRootSizeZ() - 1;
+            for(let i = 0; i < 4; ++i){
+                if (offsets[i][0] >= rootSizeX || offsets[i][1] >= rootSizeZ) {
+                    this._children[i] = null;
+                } else {
+                    this._children[i] = new QuadtreeNode();
+                    if (!this._children[i].initialize(quadtree, this, i & 1, i >> 1, baseVertices, normals, heightScale, elevations)) {
+                        return false;
+                    }
+                    const childBBox = this._children[i]._patch.getBoundingBox();
+                    if (childBBox) {
+                        if (!bbox) {
+                            bbox = new BoundingBox();
+                            bbox.beginExtend();
+                        }
+                        bbox.extend(childBBox.minPoint);
+                        bbox.extend(childBBox.maxPoint);
+                    }
+                }
+            }
+            this._patch.setBoundingBox(bbox);
+        }
+        return true;
+    }
+    setupCamera(viewportH, tanHalfFovy, maxPixelError) {
+        if (this._patch && !this._patch.isDummy()) {
+            this._patch.setupCamera(viewportH, tanHalfFovy, maxPixelError);
+        }
+        for(let i = 0; i < 4; ++i){
+            if (this._children[i]) {
+                this._children[i].setupCamera(viewportH, tanHalfFovy, maxPixelError);
+            }
+        }
+    }
+    getBoundingbox() {
+        return this._patch.getBoundingBox();
+    }
+    getPatch() {
+        return this._patch;
+    }
+    getParent() {
+        return this._parent;
+    }
+    getChild(index) {
+        return this._children[index];
+    }
+}
+/** @internal */ class Quadtree {
+    _baseVertices;
+    _indices;
+    _indicesWireframe;
+    _normalMap;
+    _scaleX;
+    _scaleZ;
+    _patchSize;
+    _rootSizeX;
+    _rootSizeZ;
+    _rootSize;
+    _primitiveCount;
+    _primitiveType;
+    _rootNode;
+    _terrain;
+    _heightField;
+    constructor(terrain){
+        this._terrain = terrain;
+        this._baseVertices = null;
+        this._indices = null;
+        this._indicesWireframe = null;
+        this._normalMap = null;
+        this._scaleX = 1;
+        this._scaleZ = 1;
+        this._patchSize = 0;
+        this._rootSizeX = 0;
+        this._rootSizeZ = 0;
+        this._rootSize = 0;
+        this._heightField = null;
+        this._rootNode = null;
+        this._primitiveCount = 0;
+        this._primitiveType = 'triangle-strip';
+    }
+    get normalMap() {
+        return this._normalMap;
+    }
+    get rootNode() {
+        return this._rootNode;
+    }
+    get terrain() {
+        return this._terrain;
+    }
+    build(patchSize, rootSizeX, rootSizeZ, elevations, scaleX, scaleY, scaleZ, vertexCacheSize) {
+        if (!isPowerOf2(patchSize - 1) || !!((rootSizeX - 1) % (patchSize - 1)) || !!((rootSizeZ - 1) % (patchSize - 1)) || !elevations) {
+            return false;
+        }
+        this._heightField = new HeightField();
+        if (!this._heightField.init(rootSizeX, rootSizeZ, 0, 0, scaleX, scaleY, scaleZ, elevations)) {
+            this._heightField = null;
+            return false;
+        }
+        const device = Application.instance.device;
+        this._patchSize = patchSize;
+        this._rootSizeX = rootSizeX;
+        this._rootSizeZ = rootSizeZ;
+        this._rootSize = nextPowerOf2(Math.max(rootSizeX - 1, rootSizeZ - 1)) + 1;
+        this._scaleX = scaleX;
+        this._scaleZ = scaleZ;
+        // Create base vertex buffer
+        const dimension = patchSize + 2; // with "skirts"
+        const vertices = new Float32Array(dimension * dimension * 3);
+        let offset = 0;
+        // top skirt
+        vertices[0] = 0;
+        vertices[1] = 0;
+        vertices[2] = 0;
+        for(let i = 1; i < dimension - 1; ++i){
+            vertices[3 * i + 0] = i - 1;
+            vertices[3 * i + 1] = 0;
+            vertices[3 * i + 2] = 0;
+        }
+        vertices[3 * (dimension - 1) + 0] = dimension - 3;
+        vertices[3 * (dimension - 1) + 1] = 0;
+        vertices[3 * (dimension - 1) + 2] = 0;
+        offset += dimension * 3;
+        for(let i = 1; i < dimension - 1; ++i, offset += dimension * 3){
+            // left skirt
+            vertices[offset + 0] = 0;
+            vertices[offset + 1] = 0;
+            vertices[offset + 2] = i - 1;
+            // height
+            for(let j = 1; j < dimension - 1; ++j){
+                vertices[offset + 3 * j + 0] = j - 1;
+                vertices[offset + 3 * j + 1] = 0;
+                vertices[offset + 3 * j + 2] = i - 1;
+            }
+            // right skirt
+            vertices[offset + (dimension - 1) * 3 + 0] = dimension - 3;
+            vertices[offset + (dimension - 1) * 3 + 1] = 0;
+            vertices[offset + (dimension - 1) * 3 + 2] = i - 1;
+        }
+        // bottom skirt
+        vertices[offset + 0] = 0;
+        vertices[offset + 1] = 0;
+        vertices[offset + 2] = dimension - 3;
+        for(let i = 1; i < dimension - 1; ++i){
+            vertices[offset + 3 * i + 0] = i - 1;
+            vertices[offset + 3 * i + 1] = 0;
+            vertices[offset + 3 * i + 2] = dimension - 3;
+        }
+        vertices[offset + (dimension - 1) * 3 + 0] = dimension - 3;
+        vertices[offset + (dimension - 1) * 3 + 1] = 0;
+        vertices[offset + (dimension - 1) * 3 + 2] = dimension - 3;
+        this._baseVertices = vertices;
+        // Create base index buffer
+        const indices = this.strip(vertexCacheSize);
+        this._indices = device.createIndexBuffer(indices, {
+            managed: true
+        });
+        const lineIndices = this.line(indices);
+        this._indicesWireframe = device.createIndexBuffer(lineIndices, {
+            managed: true
+        });
+        this._primitiveCount = indices.length - 2;
+        this._primitiveType = 'triangle-strip';
+        this._rootNode = new QuadtreeNode();
+        const normals = this._heightField.normals;
+        const normalMapBytes = new Uint8Array(normals.length * 4);
+        for(let i = 0; i < normals.length; i++){
+            const normal = normals[i];
+            normalMapBytes[i * 4 + 0] = Math.floor((normal.x * 0.5 + 0.5) * 255);
+            normalMapBytes[i * 4 + 1] = Math.floor((normal.y * 0.5 + 0.5) * 255);
+            normalMapBytes[i * 4 + 2] = Math.floor((normal.z * 0.5 + 0.5) * 255);
+            normalMapBytes[i * 4 + 3] = 255;
+        }
+        this._normalMap = device.createTexture2D('rgba8unorm', rootSizeX, rootSizeZ, {
+            samplerOptions: {
+                mipFilter: 'none'
+            }
+        });
+        this._normalMap.name = `TerrainNormalMap-${this._normalMap.uid}`;
+        this._normalMap.update(normalMapBytes, 0, 0, this._normalMap.width, this._normalMap.height);
+        return this._rootNode.initialize(this, null, 0, 0, this._baseVertices, normals, scaleY, elevations);
+    }
+    strip(vertexCacheSize) {
+        const dimension = this._patchSize + 2;
+        const step = (vertexCacheSize >> 1) - 1;
+        const indices = [];
+        for(let i = 0; i < dimension - 1; i += step){
+            const start = i;
+            const end = i + step > dimension - 1 ? dimension - 1 : i + step;
+            for(let j = 0; j < dimension - 1; ++j){
+                for(let k = start; k <= end; ++k){
+                    indices.push((dimension - 1 - k) * dimension + j);
+                    indices.push((dimension - 1 - k) * dimension + j + 1);
+                }
+                indices.push((dimension - 1 - end) * dimension + j + 1);
+                indices.push(j == dimension - 2 ? (dimension - 1 - end) * dimension : (dimension - 1 - start) * dimension + j + 1);
+            }
+        }
+        indices.length = indices.length - 2;
+        return new Uint16Array(indices);
+    }
+    line(strip) {
+        const numTris = strip.length - 2;
+        const lineIndices = [];
+        let lastSkipped = true;
+        let a, b, c;
+        for(let i = 0; i < numTris; i++){
+            if (i % 2 === 0) {
+                a = strip[i];
+                b = strip[i + 1];
+                c = strip[i + 2];
+            } else {
+                a = strip[i + 1];
+                b = strip[i];
+                c = strip[i + 2];
+            }
+            const thisSkipped = a === b || a === c || b === c;
+            if (!thisSkipped) {
+                if (lastSkipped) {
+                    lineIndices.push(a, b);
+                }
+                lineIndices.push(b, c, c, a);
+            }
+            lastSkipped = thisSkipped;
+        }
+        return new Uint16Array(lineIndices);
+    }
+    setupCamera(viewportH, tanHalfFovy, maxPixelError) {
+        this._rootNode?.setupCamera(viewportH, tanHalfFovy, maxPixelError);
+    }
+    getBoundingBox(bbox) {
+        if (this._heightField) {
+            bbox.minPoint = this._heightField.getBoundingbox().minPoint;
+            bbox.maxPoint = this._heightField.getBoundingbox().maxPoint;
+        } else {
+            bbox.minPoint = Vector3.zero();
+            bbox.maxPoint = Vector3.zero();
+        }
+    }
+    getPatchSize() {
+        return this._patchSize;
+    }
+    getRootSize() {
+        return this._rootSize;
+    }
+    getRootSizeX() {
+        return this._rootSizeX;
+    }
+    getRootSizeZ() {
+        return this._rootSizeZ;
+    }
+    getTerrain() {
+        return this._terrain;
+    }
+    getElevations() {
+        return this._heightField?.getHeights() || null;
+    }
+    getScaleX() {
+        return this._scaleX;
+    }
+    getScaleZ() {
+        return this._scaleZ;
+    }
+    getIndices() {
+        return this._indices;
+    }
+    getIndicesWireframe() {
+        return this._indicesWireframe;
+    }
+    getPrimitiveCount() {
+        return this._primitiveCount;
+    }
+    getPrimitiveType() {
+        return this._primitiveType;
+    }
+    getHeightField() {
+        return this._heightField;
+    }
+    /** @internal */ cull(visitor, viewPoint, worldMatrix) {
+        if (this._rootNode && this._terrain) {
+            const frustum = new Frustum(Matrix4x4.multiply(visitor.camera.viewProjectionMatrix, worldMatrix));
+            return this.cull_r(visitor, this._rootNode, viewPoint, worldMatrix, frustum, true, false);
+        }
+        return 0;
+    }
+    /** @internal */ cull_r(visitor, node, viewPoint, worldMatrix, frustum, cliptest, ignorePatch) {
+        const camera = visitor.camera;
+        const bbox = node.getBoundingbox();
+        let ret = 0;
+        let clipState;
+        if (cliptest) {
+            clipState = camera.clipMask ? bbox.getClipStateWithFrustumMask(frustum, camera.clipMask) : bbox.getClipStateWithFrustum(frustum);
+            if (clipState === ClipState.NOT_CLIPPED) {
+                return ret;
+            } else if (clipState === ClipState.A_INSIDE_B) {
+                cliptest = false;
+            }
+        } else {
+            clipState = ClipState.A_INSIDE_B;
+        }
+        if (!ignorePatch) {
+            const ld = node.getPatch().isDummy() ? -1 : node.getPatch().getLODDistance();
+            const lodDistance = ld >= 0 ? ld * ld : Number.MAX_VALUE;
+            const eyeDistSq = ld >= 0 ? node.getPatch().sqrDistanceToPoint(viewPoint) : 0;
+            if (eyeDistSq >= lodDistance || !node.getChild(0)) {
+                if (!node.getPatch().isDummy()) {
+                    visitor.push(camera, node.getPatch(), this._terrain.renderOrder);
+                    ignorePatch = true;
+                    ret = 1;
+                }
+            }
+        }
+        if (node.grassClusters.length > 0 && visitor.renderPass.type !== RENDER_PASS_TYPE_SHADOWMAP) {
+            for (const grass of node.grassClusters){
+                visitor.push(camera, grass, this._terrain.renderOrder);
+            }
+        }
+        for(let i = 0; i < 4; i++){
+            const child = node.getChild(i);
+            if (child) {
+                ret += this.cull_r(visitor, child, viewPoint, worldMatrix, frustum, cliptest, ignorePatch);
+            }
+        }
+        /*
+    if (eyeDistSq < lodDistance && node.getChild(0)) {
+      for (let i = 0; i < 4; i++) {
+        const child = node.getChild(i);
+        if (child) {
+          ret += this.cull_r(visitor, child, viewPoint, worldMatrix, frustum, cliptest, ignorePatch);
+        }
+      }
+    } else if (!node.getPatch().isDummy()) {
+      visitor.push(camera, node.getPatch(), this._terrain.renderOrder, this._terrain.castShadow, clipState, bbox);
+      return 1;
+    }
+    */ /*
+    if ((!node.getChild(0) || eyeDistSq >= lodDistance) && !node.getPatch().isDummy()) {
+      visitor.push(camera, node.getPatch(), this._terrain.renderOrder, this._terrain.castShadow, clipState, bbox);
+      ret = 1;
+      ignorePatch = true;
+    }
+    if (node.grassCluster) {
+      visitor.push(camera, node.grassCluster, this._terrain.renderOrder, this._terrain.castShadow, clipState, bbox);
+    } else if (!ignorePatch) {
+      for (let i = 0; i < 4; i++) {
+        const child = node.getChild(i);
+        if (child) {
+          ret += this.cull_r(visitor, child, viewPoint, worldMatrix, frustum, cliptest, ignorePatch);
+        }
+      }
+    }
+    */ /*
+    const drawPatch = !(eyeDistSq < lodDistance && node.getChild(0))
+    if (
+      eyeDistSq < lodDistance
+      && node.getChild(0)
+      && (lodLevel === 0 || node.getPatch().getMipLevel() < lodLevel)
+    ) {
+      for (let i = 0; i < 4; i++) {
+        const child = node.getChild(i);
+        if (child) {
+          ret += this.cull_r(visitor, child, viewPoint, worldMatrix, frustum, cliptest);
+        }
+      }
+    } else if (!node.getPatch().isDummy()) {
+      visitor.push(camera, node.getPatch(), this._terrain.renderOrder, this._terrain.castShadow, clipState, bbox);
+      return 1;
+    }
+    */ return ret;
+    }
+}
+
+export { Quadtree, QuadtreeNode };
+//# sourceMappingURL=quadtree.js.map

package/dist/scene/terrain/quadtree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"quadtree.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/scene/terrain/terrain.js

@@ -0,0 +1,258 @@
+import { Vector3, Vector4, Vector2 } from '@zephyr3d/base';
+import { Quadtree } from './quadtree.js';
+import { MAX_DETAIL_TEXTURE_LEVELS, TerrainMaterial } from '../../material/terrainmaterial.js';
+import { GraphNode } from '../graph_node.js';
+import { Application } from '../../app.js';
+import { GrassManager } from './grass.js';
+import { GrassMaterial } from '../../material/grassmaterial.js';
+
+/**
+ * Terrain node
+ * @public
+ */ class Terrain extends GraphNode {
+    /** @internal */ _quadtree;
+    /** @internal */ _grassManager;
+    /** @internal */ _maxPixelError;
+    /** @internal */ _maxPixelErrorDirty;
+    /** @internal */ _lodCamera;
+    /** @internal */ _heightFieldScale;
+    /** @internal */ _patchSize;
+    /** @internal */ _lastTanHalfFOVY;
+    /** @internal */ _width;
+    /** @internal */ _height;
+    /** @internal */ _material;
+    /** @internal */ _grassMaterial;
+    /** @internal */ _maxDetailTextureLevels;
+    /** @internal */ _wireframe;
+    /** @internal */ _viewPoint;
+    /** @internal */ _castShadow;
+    /** @internal */ _instanceColor;
+    /** @internal */ _overridenStateSet;
+    /**
+   * Creates an instance of Terrain
+   * @param scene - The scene to which the terrain belongs
+   */ constructor(scene){
+        super(scene);
+        this._quadtree = null;
+        this._grassManager = null;
+        this._maxPixelError = 10;
+        this._maxPixelErrorDirty = true;
+        this._lodCamera = null;
+        this._heightFieldScale = Vector3.one();
+        this._patchSize = 33;
+        this._lastTanHalfFOVY = 0;
+        this._width = 0;
+        this._height = 0;
+        this._material = null;
+        this._grassMaterial = null;
+        this._maxDetailTextureLevels = MAX_DETAIL_TEXTURE_LEVELS;
+        this._wireframe = false;
+        this._viewPoint = null;
+        this._castShadow = true;
+        this._instanceColor = Vector4.zero();
+        this._overridenStateSet = null;
+    }
+    /** @internal */ get quadtree() {
+        return this._quadtree;
+    }
+    /**
+   * {@inheritDoc Drawable.getName}
+   */ getName() {
+        return this._name;
+    }
+    /**
+   * {@inheritDoc Drawable.getInstanceColor}
+   */ getInstanceColor() {
+        return this._instanceColor;
+    }
+    /** Wether the mesh node casts shadows */ get castShadow() {
+        return this._castShadow;
+    }
+    set castShadow(val) {
+        this._castShadow = !!val;
+    }
+    /** The maximum value of detail texture levels */ get maxDetailTextureLevels() {
+        return this._maxDetailTextureLevels;
+    }
+    /** The maximum pixel error for terrain LOD */ get maxPixelError() {
+        return this._maxPixelError;
+    }
+    set maxPixelError(val) {
+        if (val !== this._maxPixelError) {
+            this._maxPixelError = val;
+            this._maxPixelErrorDirty = true;
+        }
+    }
+    /** Camera that will be used to compute LOD level of terrain patches */ get LODCamera() {
+        return this._lodCamera;
+    }
+    set LODCamera(camera) {
+        this._lodCamera = camera;
+    }
+    /** Scaled terrain width */ get scaledWidth() {
+        return this._width * this._heightFieldScale.x;
+    }
+    /** Scaled terrain height */ get scaledHeight() {
+        return this._height * this._heightFieldScale.z;
+    }
+    /** Scale value of the height field */ get heightFieldScale() {
+        return this._heightFieldScale;
+    }
+    /** @internal */ get patchSize() {
+        return this._patchSize;
+    }
+    /** Width of the terrain */ get width() {
+        return this._width;
+    }
+    /** Height of the terrain */ get height() {
+        return this._height;
+    }
+    /** Material of the terrain */ get material() {
+        return this._material;
+    }
+    /** Grass material */ get grassMaterial() {
+        return this._grassMaterial;
+    }
+    /** Whether the terrain should be rendered in wireframe mode */ get wireframe() {
+        return this._wireframe;
+    }
+    set wireframe(b) {
+        this._wireframe = !!b;
+    }
+    /** Normal map of the terrain */ get normalMap() {
+        return this._quadtree.normalMap;
+    }
+    /** @internal */ get overridenStateSet() {
+        return this._overridenStateSet;
+    }
+    /**
+   * Creates the terrain
+   *
+   * @param sizeX - Terrain size in X axis
+   * @param sizeZ - Terrain size in Z axis
+   * @param elevations - Elevation data of the terrain
+   * @param scale - Scale of the terrain
+   * @param patchSize - Patch size of the terrain
+   * @returns true if succeeded
+   */ create(sizeX, sizeZ, elevations, scale, patchSize, options) {
+        this._quadtree = new Quadtree(this);
+        if (options?.splatMap && options.splatMap.format !== 'rgba8unorm') {
+            throw new Error('SplatMap must be rgba8unorm format');
+        }
+        this._material = new TerrainMaterial(options);
+        if (!this._quadtree.build(patchSize, sizeX, sizeZ, elevations, scale.x, scale.y, scale.z, 24)) {
+            this._quadtree = null;
+            return false;
+        }
+        this._patchSize = patchSize;
+        this._heightFieldScale.set(scale);
+        this._width = sizeX;
+        this._height = sizeZ;
+        this._material.lightModel.setNormalMap(this._quadtree.normalMap, null, -1);
+        this._material.terrainInfo = new Vector4(this.scaledWidth, this.scaledHeight, 0, 0);
+        this._overridenStateSet = Application.instance.device.createRenderStateSet();
+        this._overridenStateSet.useRasterizerState().setCullMode('front');
+        this.invalidateBoundingVolume();
+        // create grass layers
+        if (options?.splatMap && options?.detailMaps?.grass) {
+            if (options.detailMaps.grass.findIndex((a)=>a && a.findIndex((b)=>!!b) >= 0) >= 0) {
+                const splatMap = options.splatMap;
+                const data = new Uint8Array(splatMap.width * splatMap.height * 4);
+                splatMap.readPixels(0, 0, splatMap.width, splatMap.height, 0, 0, data).then(()=>{
+                    for(let detail = 0; detail < 4; detail++){
+                        if (options.detailMaps.grass[detail]) {
+                            for (const grass of options.detailMaps.grass[detail]){
+                                if (grass) {
+                                    const d = grass.density ?? 1;
+                                    const bladeWidth = grass.bladeWidth ?? 4;
+                                    const bladeHeight = grass.bladeHeigh ?? 2;
+                                    const offset = grass.offset ?? 0;
+                                    const grassTexture = grass.texture ?? null;
+                                    const density = [];
+                                    for(let i = 0; i < splatMap.height; i++){
+                                        const row = [];
+                                        for(let j = 0; j < splatMap.width; j++){
+                                            const val = data[i * 4 * splatMap.width + j * 4 + detail] / 255;
+                                            row.push(val * d);
+                                        }
+                                        density.push(row);
+                                    }
+                                    this.createGrass(density, bladeWidth, bladeHeight, offset, grassTexture);
+                                }
+                            }
+                        }
+                    }
+                });
+            }
+        }
+        return true;
+    }
+    /**
+   * Create grass fields
+   * @param maxGrassPerCell - Maximum number of grasses in a cell (world space 1x1)
+   * @param density - The density map
+   */ createGrass(density, bladeWidth, bladeHeight, offset, grassTexture) {
+        if (!this._grassManager) {
+            this._grassManager = new GrassManager(64, density);
+        }
+        if (!this._grassMaterial) {
+            this._grassMaterial = new GrassMaterial(new Vector2(this.scaledWidth, this.scaledHeight), this._quadtree.normalMap);
+        }
+        this._grassMaterial = new GrassMaterial(new Vector2(this.scaledWidth, this.scaledHeight), this._quadtree.normalMap, grassTexture);
+        this._grassMaterial.stateSet.useRasterizerState().setCullMode('none');
+        this._grassManager.addGrassLayer(Application.instance.device, this, density, bladeWidth, bladeHeight, offset, grassTexture);
+    }
+    /** Get elevation at specified position in terrain coordinate space */ getElevation(x, z) {
+        return this._quadtree.getHeightField().getRealHeight(x, z);
+    }
+    /** Get normal at specified position in terrain coordinate space */ getNormal(x, z, normal) {
+        return this._quadtree.getHeightField().getRealNormal(x, z, normal);
+    }
+    /** Get intersection distance by a ray in terrain coordinate space */ rayIntersect(ray) {
+        return this._quadtree.getHeightField().rayIntersect(ray);
+    }
+    /**
+   * {@inheritDoc SceneNode.computeBoundingVolume}
+   * @override
+   */ computeBoundingVolume(bv) {
+        return this._quadtree ? this._quadtree.getHeightField().getBBoxTree().getRootNode().bbox : null;
+    }
+    /**
+   * Traverse quadtree node top down
+   * @param callback - the callback function
+   */ traverseQuadtree(callback) {
+        function visitQuadtreeNode_r(node) {
+            callback(node);
+            for(let i = 0; i < 4; i++){
+                const child = node.getChild(i);
+                if (child) {
+                    visitQuadtreeNode_r(child);
+                }
+            }
+        }
+        const rootNode = this._quadtree.rootNode;
+        if (rootNode) {
+            visitQuadtreeNode_r(this._quadtree.rootNode);
+        }
+    }
+    /** @internal */ cull(cullVisitor) {
+        const tanHalfFovy = cullVisitor.primaryCamera.getTanHalfFovy();
+        if (tanHalfFovy !== this._lastTanHalfFOVY || this._maxPixelErrorDirty) {
+            this._maxPixelErrorDirty = false;
+            this._lastTanHalfFOVY = tanHalfFovy;
+            this._quadtree.setupCamera(1024, tanHalfFovy, this._maxPixelError);
+        }
+        const worldEyePos = cullVisitor.primaryCamera.getWorldPosition();
+        this._viewPoint = this.invWorldMatrix.transformPointAffine(worldEyePos);
+        return this._quadtree.cull(cullVisitor, this._viewPoint, this.worldMatrix);
+    }
+    /**
+   * {@inheritDoc SceneNode.isTerrain}
+   * @override
+   */ isTerrain() {
+        return true;
+    }
+}
+
+export { Terrain };
+//# sourceMappingURL=terrain.js.map

package/dist/scene/terrain/terrain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"terrain.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}