@woosh/meep-engine 2.33.36 → 2.33.40

package/engine/graphics/geometry/instancing/InstancedMeshGroup.js

@@ -11,390 +11,415 @@ import { composeCompile } from "../../material/composeCompile.js";
 import { typed_array_copy } from "../../../../core/collection/array/typed/typed_array_copy.js";
 import { rewriteMaterial } from "./rewriteMaterial.js";
 
-/**
- *
- * @constructor
- */
-function InstancedMeshGroup() {
-    this.__threeGeometry = null;
-    this.__threeInstanceGeometry = null;
-
-    /**
-     * @private
-     * @type {number}
-     */
-    this.count = 0;
-    this.capacity = 0;
-
-    this.growFactor = 1.1;
+export class InstancedMeshGroup {
     /**
-     * Minimum spare capacity increase during growing
-     * @type {number}
+     *
+     * @constructor
      */
-    this.growConstant = 4;
+    constructor() {
+        /**
+         * Instanced geometry
+         * @type {THREE.InstancedBufferGeometry|null}
+         * @private
+         */
+        this.__threeGeometry = null;
+
+        /**
+         * Geometry of a single instance
+         * @type {THREE.BufferGeometry|null}
+         * @private
+         */
+        this.__threeInstanceGeometry = null;
+
+        /**
+         * @private
+         * @type {number}
+         */
+        this.count = 0;
+
+        /**
+         *
+         * @type {number}
+         */
+        this.capacity = 0;
+
+        /**
+         *
+         * @type {number}
+         */
+        this.growFactor = 1.1;
+        /**
+         * Minimum spare capacity increase during growing
+         * @type {number}
+         */
+        this.growConstant = 4;
+
+        this.shrinkFactor = 0.5;
+        /**
+         * Minimum capacity reduction for shrinkage to occur
+         * @type {number}
+         */
+        this.shrinkConstant = 64;
+
+        /**
+         *
+         * @type {InstancedBufferAttribute}
+         * @private
+         */
+        this.__attributePosition = null;
+
+        /**
+         *
+         * @type {InstancedBufferAttribute}
+         * @private
+         */
+        this.__attributeRotation = null;
+
+        /**
+         *
+         * @type {InstancedBufferAttribute}
+         * @private
+         */
+        this.__attributeScale = null;
+
+        /**
+         *
+         * @type {Material}
+         * @private
+         */
+        this.__material = null;
+
+        this.indices = [];
+        this.references = [];
+
+        this.mesh = ThreeFactory.createMesh();
+    }
 
-    this.shrinkFactor = 0.5;
-    /**
-     * Minimum capacity reduction for shrinkage to occur
-     * @type {number}
-     */
-    this.shrinkConstant = 64;
+    dispose() {
+        if (this.__threeGeometry !== null) {
+            this.__threeGeometry.dispose();
+        }
+    }
 
     /**
      *
-     * @type {InstancedBufferAttribute}
-     * @private
+     * @param {THREE.BufferGeometry} geometry
      */
-    this.__attributePosition = null;
+    setGeometry(geometry) {
+        if (geometry.isBufferGeometry !== true) {
+            throw new Error(`Expected THREE.BufferedGeometry, got something else instead.`);
+        }
 
-    /**
-     *
-     * @type {InstancedBufferAttribute}
-     * @private
-     */
-    this.__attributeRotation = null;
+        this.__threeInstanceGeometry = geometry;
 
-    /**
-     *
-     * @type {InstancedBufferAttribute}
-     * @private
-     */
-    this.__attributeScale = null;
+        this.build();
+    }
 
     /**
      *
-     * @type {Material}
-     * @private
+     * @param {THREE.Material|THREE.ShaderMaterial} sourceMaterial
      */
-    this.__material = null;
+    setMaterial(sourceMaterial) {
+        const material = sourceMaterial.clone();
+
+        if (material.isShaderMaterial) {
+            // transfer source material uniforms
+            for (const uniformsKey in material.uniforms) {
+                material.uniforms[uniformsKey] = sourceMaterial.uniforms[uniformsKey];
+            }
+        }
 
-    this.indices = [];
-    this.references = [];
 
-    this.mesh = ThreeFactory.createMesh();
-}
+        material.onBeforeCompile = composeCompile(sourceMaterial.onBeforeCompile, rewriteMaterial);
 
-InstancedMeshGroup.prototype.dispose = function () {
-    if (this.__threeGeometry !== null) {
-        this.__threeGeometry.dispose();
-    }
-}
+        //we need a custom depth material to ensure shadows will be drawn correctly
+        const depthMaterial = new MeshDepthMaterial({
+            depthPacking: RGBADepthPacking,
+        });
 
-/**
- *
- * @param {THREE.BufferGeometry} geometry
- */
-InstancedMeshGroup.prototype.setGeometry = function (geometry) {
-    if (!(geometry instanceof BufferGeometry)) {
-        throw new Error(`Expected THREE.BufferedGeometry, got something else instead.`);
-    }
+        //if the source material uses alpha testing - enable it on the depth material
+        if (material.alphaTest !== 0) {
+            depthMaterial.alphaTest = material.alphaTest;
+            depthMaterial.map = material.map;
+        }
 
-    this.__threeInstanceGeometry = geometry;
+        depthMaterial.onBeforeCompile = rewriteMaterial;
 
-    this.build();
-};
 
+        const cachedMaterial = StaticMaterialCache.Global.acquire(material);
 
-/**
- *
- * @param {THREE.Material} sourceMaterial
- */
-InstancedMeshGroup.prototype.setMaterial = function (sourceMaterial) {
-    const material = sourceMaterial.clone();
+        this.__material = cachedMaterial;
 
-    if (material.isShaderMaterial) {
-        // transfer source material uniforms
-        for (const uniformsKey in material.uniforms) {
-            material.uniforms[uniformsKey] = sourceMaterial.uniforms[uniformsKey];
-        }
+        this.mesh.material = cachedMaterial;
+        this.mesh.customDepthMaterial = StaticMaterialCache.Global.acquire(depthMaterial);
     }
 
+    /**
+     *
+     * @param {number} size
+     */
+    setCapacity(size) {
+        if (this.capacity === size) {
+            // no change
+            return;
+        }
 
-    material.onBeforeCompile = composeCompile(sourceMaterial.onBeforeCompile, rewriteMaterial);
-
-    //we need a custom depth material to ensure shadows will be drawn correctly
-    const depthMaterial = new MeshDepthMaterial({
-        depthPacking: RGBADepthPacking,
-    });
+        this.capacity = size;
 
-    //if the source material uses alpha testing - enable it on the depth material
-    if (material.alphaTest !== 0) {
-        depthMaterial.alphaTest = material.alphaTest;
-        depthMaterial.map = material.map;
+        this.build();
     }
 
-    depthMaterial.onBeforeCompile = rewriteMaterial;
-
-
-    const cachedMaterial = StaticMaterialCache.Global.acquire(material);
+    /**
+     *
+     * @param {number} size
+     */
+    ensureCapacity(size) {
 
-    this.__material = cachedMaterial;
+        const currentCapacity = this.capacity;
 
-    this.mesh.material = cachedMaterial;
-    this.mesh.customDepthMaterial = StaticMaterialCache.Global.acquire(depthMaterial);
-};
+        if (currentCapacity < size) {
+            // grow
 
-/**
- *
- * @param {number} size
- */
-InstancedMeshGroup.prototype.setCapacity = function (size) {
-    this.capacity = size;
-    this.build();
-};
+            const newCapacityRaw = Math.max(
+                size,
+                currentCapacity * this.growFactor,
+                currentCapacity + this.growConstant
+            );
 
-/**
- *
- * @param {number} size
- */
-InstancedMeshGroup.prototype.ensureCapacity = function (size) {
+            const newCapacityInteger = Math.ceil(newCapacityRaw);
 
-    const currentCapacity = this.capacity;
+            this.setCapacity(newCapacityInteger);
 
-    if (currentCapacity < size) {
-        // grow
+        } else if (
+            currentCapacity * this.shrinkFactor > size
+            && currentCapacity - this.shrinkConstant > size
+        ) {
+            // shrink
+            this.setCapacity(size);
+        }
 
-        const newCapacityRaw = Math.max(
-            size,
-            currentCapacity * this.growFactor,
-            currentCapacity + this.growConstant
-        );
+    }
 
-        const newCapacityInteger = Math.ceil(newCapacityRaw);
+    /**
+     *
+     * @param {number} index
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     */
+    setPositionAt(index, x, y, z) {
+        this.__attributePosition.setXYZ(index, x, y, z);
+        this.__attributePosition.needsUpdate = true;
+    }
 
-        this.setCapacity(newCapacityInteger);
+    /**
+     *
+     * @param {number} index
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @param {number} w
+     */
+    setRotationAt(index, x, y, z, w) {
+        this.__attributeRotation.setXYZW(index, x, y, z, w);
+        this.__attributeRotation.needsUpdate = true;
+    }
 
-    } else if (
-        currentCapacity * this.shrinkFactor > size
-        && currentCapacity - this.shrinkConstant > size
-    ) {
-        // shrink
-        this.setCapacity(size);
+    /**
+     *
+     * @param {number} index
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     */
+    setScaleAt(index, x, y, z) {
+        this.__attributeScale.setXYZ(index, x, y, z);
+        this.__attributeScale.needsUpdate = true;
     }
 
-};
-
-/**
- *
- * @param {number} index
- * @param {number} x
- * @param {number} y
- * @param {number} z
- */
-InstancedMeshGroup.prototype.setPositionAt = function (index, x, y, z) {
-    this.__attributePosition.setXYZ(index, x, y, z);
-    this.__attributePosition.needsUpdate = true;
-};
-
-/**
- *
- * @param {number} index
- * @param {number} x
- * @param {number} y
- * @param {number} z
- * @param {number} w
- */
-InstancedMeshGroup.prototype.setRotationAt = function (index, x, y, z, w) {
-    this.__attributeRotation.setXYZW(index, x, y, z, w);
-    this.__attributeRotation.needsUpdate = true;
-};
-
-/**
- *
- * @param {number} index
- * @param {number} x
- * @param {number} y
- * @param {number} z
- */
-InstancedMeshGroup.prototype.setScaleAt = function (index, x, y, z) {
-    this.__attributeScale.setXYZ(index, x, y, z);
-    this.__attributeScale.needsUpdate = true;
-};
-
-/**
- * Swap position in attribute arrays of two elements
- * @param {int} indexA
- * @param {int} indexB
- */
-InstancedMeshGroup.prototype.swap = function (indexA, indexB) {
-    throw new Error('Not Implemented Yet');
-};
-
-/**
- *
- * @param {int} size
- */
-InstancedMeshGroup.prototype.setCount = function (size) {
-    this.ensureCapacity(size);
-
-    this.count = size;
-    this.__threeGeometry.instanceCount = size;
-};
-
-/**
- *
- * @return {number|int}
- */
-InstancedMeshGroup.prototype.getCount = function () {
-    return this.count;
-};
-
-/**
- *
- * @param {int} reference
- * @returns {int}
- */
-InstancedMeshGroup.prototype.add = function (reference) {
-    //get index
-    const index = this.count;
-    //grow
-    this.setCount(this.count + 1);
-
-    this.indices[reference] = index;
-    this.references[index] = reference;
-
-    return index;
-};
-
-/**
- *
- * @param {function(index:int,reference:int)} visitor
- * @param {*} [thisArg]
- */
-InstancedMeshGroup.prototype.traverseReferences = function (visitor, thisArg) {
-    const indices = this.indices;
-    const index_count = indices.length;
-
-    for (let i = 0; i < index_count; i++) {
-        const index = indices[i];
+    /**
+     * Swap position in attribute arrays of two elements
+     * @param {int} indexA
+     * @param {int} indexB
+     */
+    swap(indexA, indexB) {
+        throw new Error('Not Implemented Yet');
+    }
 
-        if (index === undefined) {
-            // unoccupied
-            continue;
-        }
+    /**
+     *
+     * @param {int} size
+     */
+    setCount(size) {
+        this.ensureCapacity(size);
 
-        visitor.call(thisArg, index, i);
+        this.count = size;
+        this.__threeGeometry.instanceCount = size;
     }
-};
-
-/**
- *
- * @param {int} reference
- */
-InstancedMeshGroup.prototype.remove = function (reference) {
-    //dereference
-    const index = this.indices[reference];
-
-    if (index === undefined) {
-        //reference is not known
-        throw new Error(`Reference '${reference}' was not found`);
+
+    /**
+     *
+     * @return {number|int}
+     */
+    getCount() {
+        return this.count;
     }
 
-    delete this.indices[reference];
+    /**
+     *
+     * @param {int} reference
+     * @returns {int}
+     */
+    add(reference) {
+        //get index
+        const index = this.count;
+        //grow
+        this.setCount(this.count + 1);
 
-    const lastIndex = this.count - 1;
+        this.indices[reference] = index;
+        this.references[index] = reference;
 
-    if (index === lastIndex) {
-        //easy case, reference is placed at the end, no swap needed, we can just forget about it
-        delete this.references[index];
-    } else {
-        //not at the end, move end reference to this place
-        const index3 = index * 3;
-        const start3 = lastIndex * 3;
-        const end3 = start3 + 3;
+        return index;
+    }
 
-        const index4 = index * 4;
-        const start4 = lastIndex * 4;
-        const end4 = start4 + 4;
+    /**
+     *
+     * @param {function(index:int,reference:int)} visitor
+     * @param {*} [thisArg]
+     */
+    traverseReferences(visitor, thisArg) {
+        const indices = this.indices;
+        const index_count = indices.length;
 
-        this.__attributePosition.array.copyWithin(index3, start3, end3);
-        this.__attributeRotation.array.copyWithin(index4, start4, end4);
-        this.__attributeScale.array.copyWithin(index3, start3, end3);
+        for (let i = 0; i < index_count; i++) {
+            const index = indices[i];
 
-        this.__attributePosition.needsUpdate = true;
-        this.__attributeRotation.needsUpdate = true;
-        this.__attributeScale.needsUpdate = true;
+            if (index === undefined) {
+                // unoccupied
+                continue;
+            }
 
-        //update moved reference index
-        const movedReference = this.references[lastIndex];
+            visitor.call(thisArg, index, i);
+        }
+    }
+
+    /**
+     *
+     * @param {int} reference
+     */
+    remove(reference) {
+        //dereference
+        const index = this.indices[reference];
 
-        if (movedReference === undefined) {
-            //moved reference not found
-            throw new Error(`Moved reference was not found`);
+        if (index === undefined) {
+            //reference is not known
+            throw new Error(`Reference '${reference}' was not found`);
         }
 
-        delete this.references[lastIndex];
+        delete this.indices[reference];
 
-        //assume the place of removed reference
-        this.references[index] = movedReference;
-        this.indices[movedReference] = index;
-    }
+        const lastIndex = this.count - 1;
 
-    //update size
-    this.setCount(this.count - 1);
-};
+        if (index === lastIndex) {
+            //easy case, reference is placed at the end, no swap needed, we can just forget about it
+            delete this.references[index];
+        } else {
+            //not at the end, move end reference to this place
+            const index3 = index * 3;
+            const start3 = lastIndex * 3;
+            const end3 = start3 + 3;
 
-InstancedMeshGroup.prototype.build = function () {
-    if (this.__threeGeometry !== null) {
-        // dispose old geometry's GPU memory
-        this.__threeGeometry.dispose();
-    }
+            const index4 = index * 4;
+            const start4 = lastIndex * 4;
+            const end4 = start4 + 4;
 
-    this.__threeGeometry = new InstancedBufferGeometry();
+            this.__attributePosition.array.copyWithin(index3, start3, end3);
+            this.__attributeRotation.array.copyWithin(index4, start4, end4);
+            this.__attributeScale.array.copyWithin(index3, start3, end3);
 
-    const instance = this.__threeInstanceGeometry;
-    const geometry = this.__threeGeometry;
+            this.__attributePosition.needsUpdate = true;
+            this.__attributeRotation.needsUpdate = true;
+            this.__attributeScale.needsUpdate = true;
 
-    geometry.instanceCount = this.count;
-    geometry.dynamic = true;
+            //update moved reference index
+            const movedReference = this.references[lastIndex];
 
-    //copy instance attributes
-    geometry.index = instance.index;
-    for (let attributeName in instance.attributes) {
-        if (!instance.attributes.hasOwnProperty(attributeName)) {
-            continue;
+            if (movedReference === undefined) {
+                //moved reference not found
+                throw new Error(`Moved reference was not found`);
+            }
+
+            delete this.references[lastIndex];
+
+            //assume the place of removed reference
+            this.references[index] = movedReference;
+            this.indices[movedReference] = index;
         }
 
-        geometry.attributes[attributeName] = instance.attributes[attributeName];
+        //update size
+        this.setCount(this.count - 1);
     }
 
-    //build instanced attributes
-    const newPositionArray = new Float32Array(this.capacity * 3);
-    const newRotationArray = new Float32Array(this.capacity * 4);
-    const newScaleArray = new Float32Array(this.capacity * 3);
+    build() {
+        if (this.__threeGeometry !== null) {
+            // dispose old geometry's GPU memory
+            this.__threeGeometry.dispose();
+        }
+
+        this.__threeGeometry = new InstancedBufferGeometry();
 
-    if (this.__attributePosition !== null) {
-        //copy old data
-        const oldPositionArray = this.__attributePosition.array;
-        typed_array_copy(oldPositionArray, newPositionArray);
-    }
-    if (this.__attributeRotation !== null) {
-        //copy old data
-        const oldRotationArray = this.__attributeRotation.array;
-        typed_array_copy(oldRotationArray, newRotationArray);
-    }
-    if (this.__attributeScale !== null) {
-        const oldScaleArray = this.__attributeScale.array;
-        typed_array_copy(oldScaleArray, newScaleArray);
+        const instance = this.__threeInstanceGeometry;
+        const geometry = this.__threeGeometry;
 
-        if (newScaleArray.length > oldScaleArray.length) {
-            //fill the rest of the array with scale factor of 1 as a default
-            newScaleArray.fill(1, oldScaleArray.length);
+        geometry.instanceCount = this.count;
+        geometry.dynamic = true;
+
+        //copy instance attributes
+        geometry.index = instance.index;
+        for (let attributeName in instance.attributes) {
+            if (!instance.attributes.hasOwnProperty(attributeName)) {
+                continue;
+            }
+
+            geometry.attributes[attributeName] = instance.attributes[attributeName];
         }
-    }
 
-    //rewrite old attributes
-    this.__attributePosition = new InstancedBufferAttribute(newPositionArray, 3);
-    this.__attributeRotation = new InstancedBufferAttribute(newRotationArray, 4);
-    this.__attributeScale = new InstancedBufferAttribute(newScaleArray, 3);
+        //build instanced attributes
+        const newPositionArray = new Float32Array(this.capacity * 3);
+        const newRotationArray = new Float32Array(this.capacity * 4);
+        const newScaleArray = new Float32Array(this.capacity * 3);
 
-    //add attributes to newly created geometry
-    geometry.setAttribute("instancePosition", this.__attributePosition);
-    geometry.setAttribute("instanceRotation", this.__attributeRotation);
-    geometry.setAttribute("instanceScale", this.__attributeScale);
+        if (this.__attributePosition !== null) {
+            //copy old data
+            const oldPositionArray = this.__attributePosition.array;
+            typed_array_copy(oldPositionArray, newPositionArray);
+        }
+        if (this.__attributeRotation !== null) {
+            //copy old data
+            const oldRotationArray = this.__attributeRotation.array;
+            typed_array_copy(oldRotationArray, newRotationArray);
+        }
+        if (this.__attributeScale !== null) {
+            const oldScaleArray = this.__attributeScale.array;
+            typed_array_copy(oldScaleArray, newScaleArray);
+
+            if (newScaleArray.length > oldScaleArray.length) {
+                //fill the rest of the array with scale factor of 1 as a default
+                newScaleArray.fill(1, oldScaleArray.length);
+            }
+        }
 
+        //rewrite old attributes
+        this.__attributePosition = new InstancedBufferAttribute(newPositionArray, 3);
+        this.__attributeRotation = new InstancedBufferAttribute(newRotationArray, 4);
+        this.__attributeScale = new InstancedBufferAttribute(newScaleArray, 3);
 
-    this.mesh.geometry = geometry;
-};
+        //add attributes to newly created geometry
+        geometry.setAttribute("instancePosition", this.__attributePosition);
+        geometry.setAttribute("instanceRotation", this.__attributeRotation);
+        geometry.setAttribute("instanceScale", this.__attributeScale);
 
-export { InstancedMeshGroup };
+
+        this.mesh.geometry = geometry;
+    }
+}