@woosh/meep-engine 2.33.24 → 2.33.28

package/engine/ecs/foliage/InstancedFoliage.js

@@ -17,6 +17,7 @@ import { deserializeBinaryNodeFromBinaryBuffer } from "../../../core/bvh2/serial
 import { computeGeometryBoundingSphereMiniball } from "../../graphics/geometry/buffered/computeGeometryBoundingSphereMiniball.js";
 import { serializeRowFirstTable } from "../../../core/collection/table/serializeRowFirstTable.js";
 import { deserializeRowFirstTable } from "../../../core/collection/table/deserializeRowFirstTable.js";
+import { assert } from "../../../core/assert.js";
 
 /**
  * @readonly
@@ -28,364 +29,374 @@ const dataSpec = new RowFirstTableSpec([
     DataType.Float32, DataType.Float32, DataType.Float32 //scale
 ]);
 
-/**
- *
- * @constructor
- */
-function InstancedFoliage() {
-    /**
-     * Minimum area on the screen to be occupied by an instance, if instance bounding sphere occupies less than this - it will be culled
-     * Measured in pixels
-     * @type {number}
-     */
-    this.minScreenArea = 32;
-
+export class InstancedFoliage {
     /**
      *
-     * @type {BinaryNode}
+     * @constructor
      */
-    this.bvh = new BinaryNode();
-    this.bvh.setNegativelyInfiniteBounds();
+    constructor() {
+        /**
+         * Minimum area on the screen to be occupied by an instance, if instance bounding sphere occupies less than this - it will be culled
+         * Measured in pixels
+         * @type {number}
+         */
+        this.minScreenArea = 32;
+
+        /**
+         *
+         * @type {BinaryNode}
+         */
+        this.bvh = new BinaryNode();
+        this.bvh.setNegativelyInfiniteBounds();
+
+        /**
+         *
+         * @type {RowFirstTable}
+         */
+        this.data = new RowFirstTable(dataSpec);
+
+        /**
+         *
+         * @type {InstancedMeshGroup}
+         */
+        this.instances = new InstancedMeshGroup();
+
+        this.geometry = null;
+        this.instanceBoundingSphere = new Vector4(0, 0, 0, 0);
+
+
+        this.bvhVisibilityVisitor = new ThreeFrustumsIntersectionBVHVisitor();
+
+        this.visibilitySetBuilder = new FoliageVisibilitySetBuilder();
+        this.bvhVisibilityVisitor.collector = this.visibilitySetBuilder;
+
+        /**
+         *
+         * @type {*[]}
+         * @private
+         */
+        this.__garbage = [];
+        /**
+         *
+         * @type {number}
+         * @private
+         */
+        this.__garbagePointer = 0;
+    }
 
-    /**
-     *
-     * @type {RowFirstTable}
-     */
-    this.data = new RowFirstTable(dataSpec);
+    hash() {
+        return this.data.hash();
+    }
 
-    /**
-     *
-     * @type {InstancedMeshGroup}
-     */
-    this.instances = new InstancedMeshGroup();
+    clear() {
 
-    this.geometry = null;
-    this.instanceBoundingSphere = new Vector4(0, 0, 0, 0);
+        this.data.clear();
+        this.bvh.reset();
 
+    }
 
-    this.bvhVisibilityVisitor = new ThreeFrustumsIntersectionBVHVisitor();
+    dispose() {
+        this.instances.dispose();
+    }
 
-    this.visibilitySetBuilder = new FoliageVisibilitySetBuilder();
-    this.bvhVisibilityVisitor.collector = this.visibilitySetBuilder;
+    initialize() {
+
+    }
 
     /**
      *
-     * @type {*[]}
-     * @private
-     */
-    this.__garbage = [];
-    /**
-     *
-     * @type {number}
-     * @private
+     * @param {Vector3} position
+     * @param {Quaternion} rotation
+     * @param {Vector3} scale
      */
-    this.__garbagePointer = 0;
-}
+    add(position, rotation, scale) {
+        const index = this.data.length;
 
-InstancedFoliage.prototype.hash = function () {
-    return this.data.hash();
-};
+        const encodedRotation = rotation.encodeToUint32();
 
-InstancedFoliage.prototype.clear = function () {
+        //update data
+        this.data.addRow([
+            position.x, position.y, position.z,
+            encodedRotation,
+            scale.x, scale.y, scale.z
+        ]);
 
-    this.data.clear();
-    this.bvh.reset();
+        const leaf = new LeafNode(
+            index,
+            Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY,
+            Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY
+        );
 
-};
+        //compute bounding box for this instance
+        this.expandBoundingBoxForInstance(position, rotation, scale, leaf);
 
-InstancedFoliage.prototype.dispose = function () {
-    this.instances.dispose();
-};
+        //insert bounding box into the spatial index
+        this.bvh.insertNode(leaf);
+    }
 
-InstancedFoliage.prototype.initialize = function () {
+    /**
+     *
+     * @param {int} index Instance index
+     * @param {Vector3} position Position of instance will be read into this vector
+     * @param {Quaternion} rotation Rotation of instance will be read into this quaternion
+     * @param {Vector3} scale Scale of the instance will be read into this Vector
+     */
+    read(index, position, rotation, scale) {
+        const elementData = [];
+        //read transform data for instance
+        this.data.getRow(index, elementData);
 
-};
+        const positionX = elementData[0];
+        const positionY = elementData[1];
+        const positionZ = elementData[2];
 
-/**
- *
- * @param {Vector3} position
- * @param {Quaternion} rotation
- * @param {Vector3} scale
- */
-InstancedFoliage.prototype.add = function (position, rotation, scale) {
-    const index = this.data.length;
+        const encodedRotation = elementData[3];
 
-    const encodedRotation = rotation.encodeToUint32();
+        const scaleX = elementData[4];
+        const scaleY = elementData[5];
+        const scaleZ = elementData[6];
 
-    //update data
-    this.data.addRow([
-        position.x, position.y, position.z,
-        encodedRotation,
-        scale.x, scale.y, scale.z
-    ]);
+        position.set(positionX, positionY, positionZ);
 
-    const leaf = new LeafNode(
-        index,
-        Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY,
-        Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY
-    );
+        rotation.decodeFromUint32(encodedRotation);
 
-    //compute bounding box for this instance
-    this.expandBoundingBoxForInstance(position, rotation, scale, leaf);
+        scale.set(scaleX, scaleY, scaleZ);
+    }
 
-    //insert bounding box into the spatial index
-    this.bvh.insertNode(leaf);
-};
+    /**
+     *
+     * @param {AABB3} result
+     * @param {Vector3} position
+     * @param {Quaternion} rotation
+     * @param {Vector3} scale
+     */
+    expandBoundingBoxForInstance(position, rotation, scale, result) {
 
-/**
- *
- * @param {int} index Instance index
- * @param {Vector3} position Position of instance will be read into this vector
- * @param {Quaternion} rotation Rotation of instance will be read into this quaternion
- * @param {Vector3} scale Scale of the instance will be read into this Vector
- */
-InstancedFoliage.prototype.read = function (index, position, rotation, scale) {
-    const elementData = [];
-    //read transform data for instance
-    this.data.getRow(index, elementData);
+        const vertexData = this.geometry.attributes.position.array;
 
-    const positionX = elementData[0];
-    const positionY = elementData[1];
-    const positionZ = elementData[2];
+        const rXYZ = new Vector3(rotation.x, rotation.y, rotation.z);
 
-    const encodedRotation = elementData[3];
+        const v = new Vector3(0, 0, 0);
 
-    const scaleX = elementData[4];
-    const scaleY = elementData[5];
-    const scaleZ = elementData[6];
+        const c0 = new Vector3(0, 0, 0);
+        const c1 = new Vector3(0, 0, 0);
+        const c2 = new Vector3(0, 0, 0);
 
-    position.set(positionX, positionY, positionZ);
+        for (let i = 0, l = vertexData.length; i < l; i += 3) {
+            const x = vertexData[i];
+            const y = vertexData[i + 1];
+            const z = vertexData[i + 2];
 
-    rotation.decodeFromUint32(encodedRotation);
+            v.set(x, y, z);
 
-    scale.set(scaleX, scaleY, scaleZ);
-};
+            //transform point
 
-/**
- *
- * @param {AABB3} result
- * @param {Vector3} position
- * @param {Quaternion} rotation
- * @param {Vector3} scale
- */
-InstancedFoliage.prototype.expandBoundingBoxForInstance = function (position, rotation, scale, result) {
+            //apply scale
+            v.multiply(scale);
 
-    const vertexData = this.geometry.attributes.position.array;
+            //apply rotation
+            c1.copy(v).multiplyScalar(rotation.w);
+            c0.copy(rXYZ).cross(v).add(c1);
+            c2.copy(rXYZ).cross(c0).multiplyScalar(2);
 
-    const rXYZ = new Vector3(rotation.x, rotation.y, rotation.z);
+            v.add(c2);
 
-    const v = new Vector3(0, 0, 0);
+            //apply translation
+            v.add(position);
 
-    const c0 = new Vector3(0, 0, 0);
-    const c1 = new Vector3(0, 0, 0);
-    const c2 = new Vector3(0, 0, 0);
+            result._expandToFitPoint(v.x, v.y, v.z);
+        }
+    }
 
-    for (let i = 0, l = vertexData.length; i < l; i += 3) {
-        const x = vertexData[i];
-        const y = vertexData[i + 1];
-        const z = vertexData[i + 2];
+    computeInstanceBoundingSphere() {
+        this.instanceBoundingSphere = computeGeometryBoundingSphereMiniball(this.geometry);
+    }
 
-        v.set(x, y, z);
+    setInstance(geometry, material) {
+        if (material === undefined) {
+            throw new Error(`Material is undefined`);
+        }
 
-        //transform point
+        if (geometry === undefined) {
+            throw new Error(`Geometry is undefined`);
+        }
 
-        //apply scale
-        v.multiply(scale);
 
-        //apply rotation
-        c1.copy(v).multiplyScalar(rotation.w);
-        c0.copy(rXYZ).cross(v).add(c1);
-        c2.copy(rXYZ).cross(c0).multiplyScalar(2);
+        let bufferGeometry;
+        if ((geometry instanceof BufferGeometry)) {
+            bufferGeometry = geometry;
+        } else {
+            bufferGeometry = new BufferGeometry();
+            bufferGeometry.fromGeometry(geometry);
+        }
 
-        v.add(c2);
 
-        //apply translation
-        v.add(position);
+        this.geometry = bufferGeometry;
 
-        result._expandToFitPoint(v.x, v.y, v.z);
-    }
-};
+        this.instances.setMaterial(material);
+        this.instances.setGeometry(bufferGeometry);
 
-InstancedFoliage.prototype.computeInstanceBoundingSphere = function () {
-    this.instanceBoundingSphere = computeGeometryBoundingSphereMiniball(this.geometry);
-};
+        this.computeInstanceBoundingSphere();
 
-InstancedFoliage.prototype.setInstance = function (geometry, material) {
-    if (material === undefined) {
-        throw new Error(`Material is undefined`);
-    }
+        //TODO: compute haul for the mesh, to use for fast AABB computation
 
-    if (geometry === undefined) {
-        throw new Error(`Geometry is undefined`);
     }
 
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     */
+    deserialize(buffer) {
+        deserializeRowFirstTable(buffer, this.data);
 
-    let bufferGeometry;
-    if ((geometry instanceof BufferGeometry)) {
-        bufferGeometry = geometry;
-    } else {
-        bufferGeometry = new BufferGeometry();
-        bufferGeometry.fromGeometry(geometry);
+        deserializeBinaryNodeFromBinaryBuffer(this.bvh, buffer, deserializeLeafValueUintVar);
     }
 
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     */
+    serialize(buffer) {
 
-    this.geometry = bufferGeometry;
-
-    this.instances.setMaterial(material);
-    this.instances.setGeometry(bufferGeometry);
+        //serialize data
+        serializeRowFirstTable(buffer, this.data);
 
-    this.computeInstanceBoundingSphere();
+        const numRows = this.data.length;
 
-    //TODO: compute haul for the mesh, to use for fast AABB computation
+        if (numRows > 2147483647) {
+            throw new Error(`Data is too large to be written (length=${numRows})`);
+        }
 
-};
 
-/**
- *
- * @param {BinaryBuffer} buffer
- * @returns {number}
- */
-function deserializeLeafValueUintVar(buffer) {
-    return buffer.readUintVar();
-}
+        serializeBinaryNodeToBinaryBuffer(this.bvh, buffer, serializeLeafValueUintVar);
+    }
 
-InstancedFoliage.prototype.deserialize = function (buffer) {
-    deserializeRowFirstTable(buffer, this.data);
+    /**
+     *
+     * @param index
+     * @param {int} ref
+     */
+    __updateVisibility(index, ref) {
+        assert.isNonNegativeInteger(ref, 'ref');
+
+        /**
+         *
+         * @type {FoliageVisibilitySetBuilder}
+         */
+        const builder = this.visibilitySetBuilder;
+
+        /**
+         *
+         * @type {BitSet}
+         */
+        const visibleElementSet = builder.visibleSet;
+
+        if (!visibleElementSet.get(ref)) {
+            //no longer visible
+            this.__garbage[this.__garbagePointer++] = ref;
+        } else {
+            //visible, and is already in the group, update the set
+            visibleElementSet.set(ref, false);
+        }
+    }
 
-    deserializeBinaryNodeFromBinaryBuffer(this.bvh, buffer, deserializeLeafValueUintVar);
-};
+    __removeGarbage() {
 
-/**
- *
- * @param {BinaryBuffer} buffer
- * @param {number} value
- */
-function serializeLeafValueUintVar(buffer, value) {
-    buffer.writeUintVar(value);
-}
+        const garbagePointer = this.__garbagePointer;
+        const instances = this.instances;
 
-InstancedFoliage.prototype.serialize = function (buffer) {
 
-    //serialize data
-    serializeRowFirstTable(buffer, this.data);
+        const garbage = this.__garbage;
 
-    const numRows = this.data.length;
+        for (let i = 0; i < garbagePointer; i++) {
+            const ref = garbage[i];
+            instances.remove(ref);
+        }
 
-    if (numRows > 2147483647) {
-        throw new Error(`Data is too large to be written (length=${numRows})`);
     }
 
-
-    serializeBinaryNodeToBinaryBuffer(this.bvh, buffer, serializeLeafValueUintVar);
-};
-
-
-const tempQuaternion = new Quaternion();
-const rowData = [];
-
-/**
- *
- * @param index
- * @param {int} ref
- */
-InstancedFoliage.prototype.__updateVisibility = function (index, ref) {
     /**
      *
-     * @type {FoliageVisibilitySetBuilder}
+     * @param {Frustum[]} frustums
+     * @param {function[]} [visibilityFilters]
      */
-    const builder = this.visibilitySetBuilder;
-
-    /**
-     *
-     * @type {BitSet}
-     */
-    const visibleElementSet = builder.visibleSet;
-
-    if (!visibleElementSet.get(ref)) {
-        //no longer visible
-        this.__garbage[this.__garbagePointer++] = ref;
-    } else {
-        //visible, and is already in the group, update the set
-        visibleElementSet.set(ref, false);
-    }
-};
-
-InstancedFoliage.prototype.__removeGarbage = function () {
+    update(frustums, visibilityFilters = []) {
+        const instances = this.instances;
 
-    const garbagePointer = this.__garbagePointer;
-    const instances = this.instances;
+        this.bvhVisibilityVisitor.setFrustums(frustums);
 
+        const visibilitySetBuilder = this.visibilitySetBuilder;
+        visibilitySetBuilder.setFilters(visibilityFilters);
+        visibilitySetBuilder.initialize();
 
-    const garbage = this.__garbage;
+        const visibleElementSet = visibilitySetBuilder.visibleSet;
 
-    for (let i = 0; i < garbagePointer; i++) {
-        const ref = garbage[i];
-        instances.remove(ref);
-    }
-
-};
-
-/**
- *
- * @param {Frustum[]} frustums
- * @param {function[]} [visibilityFilters]
- */
-InstancedFoliage.prototype.update = function (frustums, visibilityFilters = []) {
-    const instances = this.instances;
+        //build visible set
+        traverseBinaryNodeUsingVisitor(this.bvh, this.bvhVisibilityVisitor);
 
-    this.bvhVisibilityVisitor.setFrustums(frustums);
+        visibilitySetBuilder.finalize();
 
-    const visibilitySetBuilder = this.visibilitySetBuilder;
-    visibilitySetBuilder.setFilters(visibilityFilters);
-    visibilitySetBuilder.initialize();
+        // console.log(`Visible: `, elementsToAdd.size);
 
-    const visibleElementSet = visibilitySetBuilder.visibleSet;
+        //reset garbage pointer
+        this.__garbagePointer = 0;
 
-    //build visible set
-    traverseBinaryNodeUsingVisitor(this.bvh, this.bvhVisibilityVisitor);
+        //remove those that are no longer visible
+        instances.traverseReferences(this.__updateVisibility, this);
 
-    visibilitySetBuilder.finalize();
+        //cull instances that are no longer visible
+        this.__removeGarbage();
 
-    // console.log(`Visible: `, elementsToAdd.size);
 
-    //reset garbage pointer
-    this.__garbagePointer = 0;
+        const data = this.data;
 
-    //remove those that are no longer visible
-    instances.traverseReferences(this.__updateVisibility, this);
+        //process entities that have become newly visible
+        for (let index = visibleElementSet.nextSetBit(0); index !== -1; index = visibleElementSet.nextSetBit(index + 1)) {
+            //read transform data for instance
+            data.getRow(index, rowData);
 
-    //cull instances that are no longer visible
-    this.__removeGarbage();
+            const positionX = rowData[0];
+            const positionY = rowData[1];
+            const positionZ = rowData[2];
 
+            const encodedRotation = rowData[3];
 
-    const data = this.data;
-
-    //process entities that have become newly visible
-    for (let index = visibleElementSet.nextSetBit(0); index !== -1; index = visibleElementSet.nextSetBit(index + 1)) {
-        //read transform data for instance
-        data.getRow(index, rowData);
 
-        const positionX = rowData[0];
-        const positionY = rowData[1];
-        const positionZ = rowData[2];
+            const scaleX = rowData[4];
+            const scaleY = rowData[5];
+            const scaleZ = rowData[6];
 
-        const encodedRotation = rowData[3];
+            const i = instances.add(index);
 
+            tempQuaternion.decodeFromUint32(encodedRotation);
 
-        const scaleX = rowData[4];
-        const scaleY = rowData[5];
-        const scaleZ = rowData[6];
+            //apply instance transforms
+            instances.setPositionAt(i, positionX, positionY, positionZ);
+            instances.setRotationAt(i, tempQuaternion.x, tempQuaternion.y, tempQuaternion.z, tempQuaternion.w);
+            instances.setScaleAt(i, scaleX, scaleY, scaleZ);
+        }
+    }
+}
 
-        const i = instances.add(index);
+/**
+ *
+ * @param {BinaryBuffer} buffer
+ * @returns {number}
+ */
+function deserializeLeafValueUintVar(buffer) {
+    return buffer.readUintVar();
+}
 
-        tempQuaternion.decodeFromUint32(encodedRotation);
+/**
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {number} value
+ */
+function serializeLeafValueUintVar(buffer, value) {
+    buffer.writeUintVar(value);
+}
 
-        //apply instance transforms
-        instances.setPositionAt(i, positionX, positionY, positionZ);
-        instances.setRotationAt(i, tempQuaternion.x, tempQuaternion.y, tempQuaternion.z, tempQuaternion.w);
-        instances.setScaleAt(i, scaleX, scaleY, scaleZ);
-    }
-};
 
+const tempQuaternion = new Quaternion();
+const rowData = [];
 
-export { InstancedFoliage };