@zephyr3d/scene 0.1.0

package/dist/scene/terrain/grass.js

@@ -0,0 +1,277 @@
+import { nextPowerOf2, Vector2 } from '@zephyr3d/base';
+import { Primitive } from '../../render/primitive.js';
+import '../../material/material.js';
+import '@zephyr3d/device';
+import '../../shaders/framework.js';
+import { Application } from '../../app.js';
+import '../../render/scatteringlut.js';
+import '../../material/lambert.js';
+import '../../material/blinn.js';
+import '../../material/unlit.js';
+import '../../material/lightmodel.js';
+import { GrassMaterial } from '../../material/grassmaterial.js';
+
+class GrassCluster {
+    _primitive;
+    _terrain;
+    _numInstances;
+    _material;
+    constructor(device, terrain, baseVertexBuffer, indexBuffer, material, grassData){
+        this._primitive = new Primitive();
+        const instanceVertexBuffer = device.createVertexBuffer('tex1_f32x4', grassData);
+        this._primitive.setVertexBuffer(baseVertexBuffer, 'vertex');
+        this._primitive.setVertexBuffer(instanceVertexBuffer, 'instance');
+        this._primitive.setIndexBuffer(indexBuffer);
+        this._primitive.primitiveType = 'triangle-list';
+        this._terrain = terrain;
+        this._numInstances = grassData.length >> 2;
+        this._material = material;
+        this._material.stateSet.useRasterizerState().setCullMode('none');
+    }
+    getName() {
+        return 'GrassCluster';
+    }
+    getXForm() {
+        return this._terrain;
+    }
+    getInstanceColor() {
+        return this._terrain.getInstanceColor();
+    }
+    getPickTarget() {
+        return this._terrain;
+    }
+    getBoneMatrices() {
+        return null;
+    }
+    getInvBindMatrix() {
+        return null;
+    }
+    getSortDistance(camera) {
+        return this._terrain.getSortDistance(camera);
+    }
+    isTransparency() {
+        return this._terrain.grassMaterial.isTransparent();
+    }
+    isUnlit() {
+        return !this._terrain.grassMaterial.supportLighting();
+    }
+    isBatchable() {
+        return false;
+    }
+    draw(ctx) {
+        this._material.alphaToCoverage = Application.instance.device.getFrameBufferSampleCount() > 1;
+        if (this._material.beginDraw(ctx)) {
+            this._primitive.drawInstanced(this._numInstances);
+            this._terrain.grassMaterial.endDraw();
+        }
+    }
+}
+class GrassManager {
+    _clusterSize;
+    _baseVertexBuffer;
+    _indexBuffer;
+    _layers;
+    constructor(clusterSize, density){
+        this._clusterSize = clusterSize;
+        this._baseVertexBuffer = new Map();
+        this._indexBuffer = null;
+        this._layers = [];
+    }
+    getBaseVertexBuffer(device, bladeWidth, bladeHeight) {
+        const hash = `${bladeWidth}-${bladeHeight}`;
+        let baseVertexBuffer = this._baseVertexBuffer.get(hash);
+        if (baseVertexBuffer) {
+            return baseVertexBuffer;
+        }
+        const r = bladeWidth * 0.5;
+        const t = bladeHeight;
+        const c = r * Math.cos(Math.PI / 3);
+        const s = r * Math.sin(Math.PI / 3);
+        const vertices = new Float32Array([
+            r,
+            0,
+            0,
+            0,
+            1,
+            r,
+            t,
+            0,
+            0,
+            0,
+            -r,
+            t,
+            0,
+            1,
+            0,
+            -r,
+            0,
+            0,
+            1,
+            1,
+            c,
+            0,
+            s,
+            0,
+            1,
+            -c,
+            0,
+            -s,
+            1,
+            1,
+            -c,
+            t,
+            -s,
+            1,
+            0,
+            c,
+            t,
+            s,
+            0,
+            0,
+            -c,
+            0,
+            s,
+            0,
+            1,
+            c,
+            0,
+            -s,
+            1,
+            1,
+            c,
+            t,
+            -s,
+            1,
+            0,
+            -c,
+            t,
+            s,
+            0,
+            0
+        ]);
+        baseVertexBuffer = device.createInterleavedVertexBuffer([
+            'position_f32x3',
+            'tex0_f32x2'
+        ], vertices);
+        this._baseVertexBuffer.set(hash, baseVertexBuffer);
+        return baseVertexBuffer;
+    }
+    getIndexBuffer(device) {
+        if (!this._indexBuffer) {
+            this._indexBuffer = device.createIndexBuffer(new Uint16Array([
+                0,
+                1,
+                2,
+                0,
+                2,
+                3,
+                4,
+                5,
+                6,
+                4,
+                6,
+                7,
+                8,
+                9,
+                10,
+                8,
+                10,
+                11
+            ]));
+        }
+        return this._indexBuffer;
+    }
+    addGrassLayer(device, terrain, density, bladeWidth, bladeHeigh, offset, grassTexture) {
+        const densityHeight = density.length;
+        const densityWidth = density[0].length;
+        const hfScale = terrain.heightFieldScale;
+        this._clusterSize = Math.min(nextPowerOf2(this._clusterSize), terrain.width - 1, terrain.height - 1);
+        let layer = null;
+        terrain.traverseQuadtree((node)=>{
+            const size = node.getPatch().getStep() * (terrain.patchSize - 1);
+            if (size === this._clusterSize) {
+                const bbox = node.getPatch().getBoundingBox();
+                const grassData = [];
+                const minX = bbox.minPoint.x;
+                const minZ = bbox.minPoint.z;
+                let index = 0;
+                for(let i = 0; i < this._clusterSize; i++){
+                    for(let j = 0; j < this._clusterSize; j++){
+                        const x0 = minX + j * hfScale.x;
+                        const z0 = minZ + i * hfScale.z;
+                        const x1 = x0 + hfScale.x;
+                        const z1 = z0 + hfScale.z;
+                        const u = x0 / terrain.scaledWidth;
+                        const v = z0 / terrain.scaledHeight;
+                        const du = densityWidth * u >> 0;
+                        const dv = densityHeight * v >> 0;
+                        const val = density[dv][du] * hfScale.x * hfScale.z;
+                        let grassCount = 0;
+                        if (val > 0) {
+                            if (val < 1) {
+                                grassCount = Math.random() <= val ? 1 : 0;
+                            } else {
+                                grassCount = val >> 0;
+                            }
+                        }
+                        //const grassCount = (this._density[dv][du] * hfScale.x * hfScale.z) >> 0;
+                        for(let k = 0; k < grassCount; k++){
+                            const x = Math.random() * (x1 - x0) + x0;
+                            const z = Math.random() * (z1 - z0) + z0;
+                            const y = terrain.getElevation(x, z);
+                            const rot = Math.random() * Math.PI * 2;
+                            grassData[index++] = x;
+                            grassData[index++] = y + offset;
+                            grassData[index++] = z;
+                            grassData[index++] = rot;
+                        }
+                    }
+                }
+                if (grassData.length > 0) {
+                    if (!layer) {
+                        layer = {
+                            material: new GrassMaterial(new Vector2(terrain.scaledWidth, terrain.scaledHeight), terrain.quadtree.normalMap, grassTexture),
+                            clusters: new Map()
+                        };
+                        this._layers.push(layer);
+                    }
+                    const cluster = new GrassCluster(device, terrain, this.getBaseVertexBuffer(device, bladeWidth, bladeHeigh), this.getIndexBuffer(device), layer.material, new Float32Array(grassData));
+                    layer.clusters.set(node, cluster);
+                    //const cluster = new GrassCluster(device, terrain, this.getBaseVertexBuffer(device, bladeWidth, bladeHeigh), this.getIndexBuffer(device), grassTexture, new Float32Array(grassData));
+                    node.grassClusters.push(cluster);
+                }
+            }
+        });
+        return layer;
+    }
+} /*
+function interpolate(val: number, oldMin: number, oldMax: number, newMin: number, newMax: number) {
+  return ((val - oldMin) * (newMax - newMin)) / (oldMax - oldMin) + newMin
+}
+
+function createGrassBladePrimitive(device: AbstractDevice) {
+  const p = new Primitive();
+  const positions: number[] = [];
+  const uvs: number[] = [];
+  const indices: number[] = [];
+}
+
+function getPrimitive(device: AbstractDevice): Primitive {
+  if (!primitive) {
+    primitive = new Primitive();
+    const vertices: number[] = [-0.1, 0, 0, 0.1, 0, 0, 0.1, 0.8, 0, -0.1, 0.8, 0];
+    const indices: number[] = [0, 1, 2, 0, 2, 3, 0, 2, 1, 0, 3, 2];
+    const vb = device.createInterleavedVertexBuffer(['position_f32x3', 'normal_f32x3', 'tex0_f32x2'], new Float32Array(vertices));
+    const ib = device.createIndexBuffer(new Uint16Array(indices));
+    primitive.setVertexBuffer(vb);
+    primitive.setIndexBuffer(ib)
+    primitive.indexStart = 0;
+    primitive.indexCount = indices.length;
+    primitive.primitiveType = 'triangle-list';
+  }
+  return primitive;
+}
+*/
+
+export { GrassCluster, GrassManager };
+//# sourceMappingURL=grass.js.map

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

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

package/dist/scene/terrain/heightfield.js

@@ -0,0 +1,391 @@
+import { Vector3, Vector4 } from '@zephyr3d/base';
+import { BoundingBox } from '../../utility/bounding_volume.js';
+
+/** @internal */ class HeightfieldBBoxTree {
+    _resX;
+    _resY;
+    _spacingX;
+    _spacingZ;
+    _heights;
+    _rootNode;
+    constructor(res_x, res_y, spacing_x, spacing_z, vertices){
+        this._rootNode = null;
+        this._heights = null;
+        this._spacingX = spacing_x;
+        this._spacingZ = spacing_z;
+        this.create(res_x, res_y, vertices);
+    }
+    create(res_x, res_y, vertices) {
+        this._resX = res_x;
+        this._resY = res_y;
+        this._rootNode = this.allocNode();
+        this._heights = new Float32Array(res_x * res_y);
+        for(let i = 0; i < this._heights.length; i++){
+            this._heights[i] = vertices[i].y;
+        }
+        this.createChildNode(this._rootNode, 0, 0, res_x, res_y, vertices);
+        return true;
+    }
+    getHeight(x, y) {
+        return this._heights[(this._resY - 1 - y) * this._resX + x];
+    }
+    getNormal(x, y, normal) {
+        normal = normal ?? new Vector3();
+        x = Math.max(0, Math.min(x, this._resX - 2));
+        y = Math.max(0, Math.min(y, this._resY - 2));
+        const h00 = this._heights[x + y * this._resX];
+        const h01 = this._heights[x + (y + 1) * this._resX];
+        const h11 = this._heights[x + 1 + (y + 1) * this._resX];
+        const h10 = this._heights[x + 1 + y * this._resX];
+        const sx = (h00 + h01 - h11 - h10) * 0.5;
+        const sy = (h00 + h10 - h01 - h11) * 0.5;
+        const tileSizeX = (this._rootNode.bbox.maxPoint.x - this._rootNode.bbox.minPoint.x) / (this._resX - 1);
+        const tileSizeY = (this._rootNode.bbox.maxPoint.z - this._rootNode.bbox.minPoint.z) / (this._resY - 1);
+        normal.setXYZ(sx * tileSizeY, 2 * tileSizeX * tileSizeY, -sy * tileSizeX).inplaceNormalize();
+        return normal;
+    }
+    getRealNormal(x, y, normal) {
+        normal = normal ?? new Vector3();
+        x -= this._rootNode.bbox.minPoint.x;
+        y -= this._rootNode.bbox.minPoint.z;
+        const tileSizeX = (this._rootNode.bbox.maxPoint.x - this._rootNode.bbox.minPoint.x) / (this._resX - 1);
+        const tileSizeY = (this._rootNode.bbox.maxPoint.z - this._rootNode.bbox.minPoint.z) / (this._resY - 1);
+        const x_unscale = x / tileSizeX;
+        const y_unscale = y / tileSizeY;
+        let l = Math.floor(x_unscale);
+        let t = Math.floor(y_unscale);
+        let r = l + 1;
+        let b = t + 1;
+        if (l < 0) {
+            l = 0;
+        }
+        if (t < 0) {
+            t = 0;
+        }
+        if (r >= this._resX) {
+            r = this._resX - 1;
+        }
+        if (b >= this._resY) {
+            b = this._resY - 1;
+        }
+        const ltNormal = this.getNormal(l, t);
+        const lbNormal = this.getNormal(l, b);
+        const rtNormal = this.getNormal(r, t);
+        const rbNormal = this.getNormal(r, b);
+        ltNormal.addBy(lbNormal).addBy(rtNormal).addBy(rbNormal).scaleBy(0.25).inplaceNormalize();
+        normal.set(ltNormal);
+        return normal;
+    }
+    getRealHeight(x, y) {
+        x -= this._rootNode.bbox.minPoint.x;
+        y -= this._rootNode.bbox.minPoint.z;
+        const tileSizeX = (this._rootNode.bbox.maxPoint.x - this._rootNode.bbox.minPoint.x) / (this._resX - 1);
+        const tileSizeY = (this._rootNode.bbox.maxPoint.z - this._rootNode.bbox.minPoint.z) / (this._resY - 1);
+        const x_unscale = x / tileSizeX;
+        const y_unscale = y / tileSizeY;
+        const l = Math.floor(x_unscale);
+        const t = Math.floor(y_unscale);
+        const r = l + 1;
+        const b = t + 1;
+        if (l < 0 || t < 0 || r >= this._resX || b >= this._resY) {
+            return 0;
+        }
+        if (l === r) {
+            if (t === b) {
+                return this.getHeight(l, t);
+            } else {
+                const ht = this.getHeight(l, t);
+                const hb = this.getHeight(l, b);
+                return ht + (hb - ht) * (y_unscale - t);
+            }
+        } else {
+            const hlt = this.getHeight(l, t);
+            const hrt = this.getHeight(r, t);
+            const ht = hlt + (hrt - hlt) * (x_unscale - l);
+            if (t === b) {
+                return ht;
+            } else {
+                const hlb = this.getHeight(l, b);
+                const hrb = this.getHeight(r, b);
+                const hb = hlb + (hrb - hlb) * (x_unscale - l);
+                return ht + (hb - ht) * (y_unscale - t);
+            }
+        }
+    }
+    getRootNode() {
+        return this._rootNode;
+    }
+    getHeights() {
+        return this._heights;
+    }
+    allocNode() {
+        return {
+            bbox: new BoundingBox(),
+            h: [
+                0,
+                0,
+                0,
+                0
+            ],
+            rc: {
+                x: 0,
+                y: 0,
+                w: 0,
+                h: 0
+            },
+            left: null,
+            right: null
+        };
+    }
+    computeNodeBoundingBox(node, bbox, vertices) {
+        bbox.beginExtend();
+        for(let i = 0; i < node.rc.w; i++){
+            for(let j = 0; j < node.rc.h; j++){
+                const index = node.rc.x + i + (node.rc.y + j) * this._resX;
+                const vert = vertices[index];
+                bbox.extend3(vert.x, vert.y, vert.z);
+            }
+        }
+    }
+    createChildNode(node, x, y, w, h, vertices) {
+        node.rc.x = x;
+        node.rc.y = y;
+        node.rc.w = w;
+        node.rc.h = h;
+        if (w <= 2 && h <= 2) {
+            node.left = null;
+            node.right = null;
+            node.h[0] = this.getHeight(x, y);
+            node.h[1] = this.getHeight(x + 1, y);
+            node.h[2] = this.getHeight(x + 1, y + 1);
+            node.h[3] = this.getHeight(x, y + 1);
+            const hMin = Math.min(...node.h);
+            const hMax = Math.max(...node.h);
+            node.bbox = new BoundingBox(new Vector3(x * this._spacingX, hMin, y * this._spacingZ), new Vector3((x + 1) * this._spacingX, hMax, (y + 1) * this._spacingZ));
+        } else {
+            if (w >= h) {
+                const w1 = w + 1 >> 1;
+                const w2 = w - w1 + 1;
+                node.left = this.allocNode();
+                this.createChildNode(node.left, x, y, w1, h, vertices);
+                node.right = this.allocNode();
+                this.createChildNode(node.right, x + w1 - 1, y, w2, h, vertices);
+            } else {
+                const h1 = h + 1 >> 1;
+                const h2 = h - h1 + 1;
+                node.left = this.allocNode();
+                this.createChildNode(node.left, x, y, w, h1, vertices);
+                node.right = this.allocNode();
+                this.createChildNode(node.right, x, y + h1 - 1, w, h2, vertices);
+            }
+            node.bbox.beginExtend();
+            node.bbox.extend(node.left.bbox.minPoint);
+            node.bbox.extend(node.left.bbox.maxPoint);
+            node.bbox.extend(node.right.bbox.minPoint);
+            node.bbox.extend(node.right.bbox.maxPoint);
+        }
+        return true;
+    }
+    rayIntersect(ray) {
+        return this.rayIntersectR(ray, this._rootNode);
+    }
+    rayIntersectR(ray, node) {
+        const d = ray.bboxIntersectionTestEx(node.bbox);
+        if (d === null) {
+            return null;
+        }
+        if (node.left && node.right) {
+            const l = this.rayIntersectR(ray, node.left);
+            const r = this.rayIntersectR(ray, node.right);
+            if (l !== null && r !== null) {
+                return l < r ? l : r;
+            } else {
+                return l === null ? r : l;
+            }
+        } else {
+            const v00 = new Vector3(node.bbox.minPoint.x, node.h[0], node.bbox.minPoint.z);
+            const v01 = new Vector3(node.bbox.maxPoint.x, node.h[1], node.bbox.minPoint.z);
+            const v11 = new Vector3(node.bbox.maxPoint.x, node.h[2], node.bbox.maxPoint.z);
+            const v10 = new Vector3(node.bbox.minPoint.x, node.h[3], node.bbox.maxPoint.z);
+            let intersected = false;
+            let dist1 = ray.intersectionTestTriangle(v00, v01, v10, false);
+            if (dist1 !== null && dist1 > 0) {
+                intersected = true;
+            } else {
+                dist1 = Number.MAX_VALUE;
+            }
+            let dist2 = ray.intersectionTestTriangle(v10, v01, v11, false);
+            if (dist2 !== null && dist2 > 0) {
+                intersected = true;
+            } else {
+                dist2 = Number.MAX_VALUE;
+            }
+            if (!intersected) {
+                return null;
+            } else {
+                return dist1 < dist2 ? dist1 : dist2;
+            }
+        }
+    }
+}
+/** @internal */ class HeightField {
+    m_v4Range;
+    m_scale;
+    m_sizeX;
+    m_sizeZ;
+    m_bboxTree;
+    m_normals;
+    constructor(){
+        this.m_v4Range = Vector4.zero();
+        this.m_bboxTree = null;
+        this.m_scale = Vector3.one();
+        this.m_sizeX = 0;
+        this.m_sizeZ = 0;
+        this.m_normals = null;
+    }
+    init(sizeX, sizeZ, offsetX, offsetZ, scaleX, scaleY, scaleZ, heights) {
+        const v = [];
+        for(let i = 0; i < sizeZ; ++i){
+            const srcOffset = i * sizeX;
+            const dstOffset = (sizeZ - i - 1) * sizeX;
+            for(let j = 0; j < sizeX; ++j){
+                v[dstOffset + j] = new Vector4(offsetX + j * scaleX, heights[srcOffset + j] * scaleY, offsetZ + i * scaleZ, 1);
+            }
+        }
+        this.m_bboxTree = new HeightfieldBBoxTree(sizeX, sizeZ, scaleX, scaleZ, v);
+        this.m_v4Range.setXYZW(this.m_bboxTree.getRootNode().bbox.minPoint.x, this.m_bboxTree.getRootNode().bbox.minPoint.z, this.m_bboxTree.getRootNode().bbox.extents.x * 2, this.m_bboxTree.getRootNode().bbox.extents.z * 2);
+        this.m_scale.setXYZ(scaleX, scaleY, scaleZ);
+        this.m_sizeX = sizeX;
+        this.m_sizeZ = sizeZ;
+        this.m_normals = this.computeNormalVectors();
+        return true;
+    }
+    get normals() {
+        return this.m_normals;
+    }
+    clear() {
+        this.m_bboxTree = null;
+        this.m_v4Range.setXYZW(0, 0, 0, 0);
+        this.m_scale.setXYZ(1, 1, 1);
+        this.m_sizeX = 0;
+        this.m_sizeZ = 0;
+    }
+    rayIntersect(ray) {
+        return this.m_bboxTree.rayIntersect(ray);
+    }
+    computeNormals() {
+        const scaleX = this.m_scale.x;
+        const scaleZ = this.m_scale.z;
+        const heights = this.getHeights();
+        const v = new Vector3();
+        const normals = new Uint8Array((this.m_sizeZ - 1) * (this.m_sizeX - 1) * 4);
+        for(let y = 0; y < this.m_sizeZ - 1; ++y){
+            for(let x = 0; x < this.m_sizeX - 1; ++x){
+                const h00 = heights[x + y * this.m_sizeX];
+                const h01 = heights[x + (y + 1) * this.m_sizeX];
+                const h11 = heights[x + 1 + (y + 1) * this.m_sizeX];
+                const h10 = heights[x + 1 + y * this.m_sizeX];
+                const sx = (h00 + h01 - h11 - h10) * 0.5;
+                const sy = (h00 + h10 - h01 - h11) * 0.5;
+                const index = x + (this.m_sizeZ - 2 - y) * (this.m_sizeX - 1);
+                v.setXYZ(sx * scaleZ, 2 * scaleX * scaleZ, -sy * scaleX).inplaceNormalize();
+                normals[index * 4 + 0] = Math.floor((v.x * 0.5 + 0.5) * 255);
+                normals[index * 4 + 1] = Math.floor((v.y * 0.5 + 0.5) * 255);
+                normals[index * 4 + 2] = Math.floor((v.z * 0.5 + 0.5) * 255);
+                normals[index * 4 + 3] = 255;
+            }
+        }
+        return normals;
+    }
+    computeNormalVectors() {
+        const scaleX = this.m_scale.x;
+        const scaleZ = this.m_scale.z;
+        const heights = this.getHeights();
+        const normals = [];
+        for(let y = 0; y < this.m_sizeZ; ++y){
+            for(let x = 0; x < this.m_sizeX; ++x){
+                const h = heights[x + y * this.m_sizeX];
+                const h00 = x > 0 && y > 0 ? heights[x - 1 + (y - 1) * this.m_sizeX] : h;
+                const h01 = y > 0 && y < this.m_sizeZ - 1 ? heights[x - 1 + (y + 1) * this.m_sizeX] : h;
+                const h11 = x < this.m_sizeX - 1 && y < this.m_sizeZ - 1 ? heights[x + 1 + (y + 1) * this.m_sizeX] : h;
+                const h10 = x < this.m_sizeX - 1 && y > 0 ? heights[x + 1 + (y - 1) * this.m_sizeX] : h;
+                const sx = (h00 + h01 - h11 - h10) * 0.5;
+                const sy = (h00 + h10 - h01 - h11) * 0.5;
+                const index = x + (this.m_sizeZ - 1 - y) * this.m_sizeX;
+                normals[index] = new Vector3(sx * scaleZ, 2 * scaleX * scaleZ, -sy * scaleX).inplaceNormalize();
+            }
+        }
+        return normals;
+    }
+    getBBoxTree() {
+        return this.m_bboxTree;
+    }
+    getSpacingX() {
+        return this.m_scale.x;
+    }
+    getSpacingZ() {
+        return this.m_scale.z;
+    }
+    getVerticalScale() {
+        return this.m_scale.y;
+    }
+    getSizeX() {
+        return this.m_sizeX;
+    }
+    getSizeZ() {
+        return this.m_sizeZ;
+    }
+    getOffsetX() {
+        return this.m_v4Range.x;
+    }
+    getOffsetZ() {
+        return this.m_v4Range.y;
+    }
+    getBoundingbox() {
+        return this.m_bboxTree?.getRootNode()?.bbox || null;
+    }
+    getHeights() {
+        return this.m_bboxTree?.getHeights() || null;
+    }
+    getHeight(x, z) {
+        return this.m_bboxTree ? this.m_bboxTree.getHeight(x, z) : 0;
+    }
+    getRealHeight(x, z) {
+        return this.m_bboxTree ? this.m_bboxTree.getRealHeight(x, z) : 0;
+    }
+    getRealNormal(x, z, normal) {
+        normal = normal ?? new Vector3();
+        const bboxRootNode = this.m_bboxTree.getRootNode();
+        x -= bboxRootNode.bbox.minPoint.x;
+        z -= bboxRootNode.bbox.minPoint.z;
+        const tileSizeX = (bboxRootNode.bbox.maxPoint.x - bboxRootNode.bbox.minPoint.x) / (this.m_sizeX - 1);
+        const tileSizeY = (bboxRootNode.bbox.maxPoint.z - bboxRootNode.bbox.minPoint.z) / (this.m_sizeZ - 1);
+        const x_unscale = x / tileSizeX;
+        const y_unscale = z / tileSizeY;
+        let l = Math.floor(x_unscale);
+        let t = Math.floor(y_unscale);
+        let r = l + 1;
+        let b = t + 1;
+        if (l < 0) {
+            l = 0;
+        }
+        if (t < 0) {
+            t = 0;
+        }
+        if (r >= this.m_sizeX) {
+            r = this.m_sizeX - 1;
+        }
+        if (b >= this.m_sizeZ) {
+            b = this.m_sizeZ - 1;
+        }
+        normal.set(this.m_normals[l + t * this.m_sizeX]);
+        normal.addBy(this.m_normals[r + t * this.m_sizeX]);
+        normal.addBy(this.m_normals[r + b * this.m_sizeX]);
+        normal.addBy(this.m_normals[l + b * this.m_sizeX]);
+        normal.scaleBy(0.4).inplaceNormalize();
+        return normal;
+    }
+}
+
+export { HeightField, HeightfieldBBoxTree };
+//# sourceMappingURL=heightfield.js.map

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

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