@woosh/meep-engine 2.106.1 → 2.107.0

package/src/engine/graphics/particles/particular/group/ParticleGroup.js

@@ -2,7 +2,6 @@
  *
  * @enum {number}
  */
-import IdPool from "../../../../../core/IdPool.js";
 import {
     BufferAttribute,
     BufferGeometry,
@@ -10,628 +9,628 @@ import {
     InstancedBufferAttribute,
     InstancedBufferGeometry
 } from "three";
+import IdPool from "../../../../../core/IdPool.js";
 import ObservedValue from "../../../../../core/model/ObservedValue.js";
-import { typedArrayConstructorFromDataType } from "./typedArrayConstructorFromDataType.js";
 import { itemSizeFromAttributeType } from "./itemSizeFromAttributeType.js";
-import { OperationType } from "./OperationType.js";
 import { Operation } from "./Operation.js";
+import { OperationType } from "./OperationType.js";
 import { optimizeCommandQueue } from "./optimizeCommandQueue.js";
+import { typedArrayConstructorFromDataType } from "./typedArrayConstructorFromDataType.js";
 
 
-/**
- *
- * @param {ParticleSpecification} spec
- * @param {boolean} [instanced=false]
- * @constructor
- */
-function ParticleGroup(spec, instanced = false) {
-    this.instanced = instanced;
+export class ParticleGroup {
     /**
      *
-     * @type {ParticleSpecification}
+     * @param {ParticleSpecification} spec
+     * @param {boolean} [instanced=false]
+     * @constructor
      */
-    this.spec = spec;
+    constructor(spec, instanced = false) {
+        this.instanced = instanced;
+        /**
+         *
+         * @type {ParticleSpecification}
+         */
+        this.spec = spec;
 
-    this.attributes = [];
+        this.attributes = [];
 
-    /**
-     *
-     * @type {ObservedValue<BufferGeometry>}
-     */
-    this.geometry = new ObservedValue(null);
+        /**
+         *
+         * @type {ObservedValue<BufferGeometry>}
+         */
+        this.geometry = new ObservedValue(null);
 
-    /**
-     *
-     * @type {int}
-     */
-    this.size = 0;
+        /**
+         *
+         * @type {int}
+         */
+        this.size = 0;
 
-    /**
-     *
-     * @type {int}
-     */
-    this.capacity = 100;
+        /**
+         *
+         * @type {int}
+         */
+        this.capacity = 100;
 
-    this.growFactor = 1.1;
-    this.shrinkFactor = 0.9;
+        this.growFactor = 1.1;
+        this.shrinkFactor = 0.9;
 
-    this.referenceIndexLookup = new Map();
-    this.indexReferenceLookup = [];
+        this.referenceIndexLookup = new Map();
+        this.indexReferenceLookup = [];
 
-    /**
-     *
-     * @type {Array.<Operation>}
-     */
-    this.commandQueue = [];
+        /**
+         *
+         * @type {Array.<Operation>}
+         */
+        this.commandQueue = [];
 
-    this.referencePool = new IdPool();
+        this.referencePool = new IdPool();
 
-    this.build();
-}
+        this.build();
+    }
 
-/**
- *
- * @param {Float64Array|Float32Array|Uint32Array|Uint16Array|Uint8Array|Int32Array|Int16Array|Int8Array} array
- * @param {int} itemSize
- * @returns {InstancedBufferAttribute|BufferAttribute}
- */
-ParticleGroup.prototype.buildNewBufferAttribute = function (array, itemSize) {
-    if (this.instanced) {
-        return new InstancedBufferAttribute(array, itemSize);
-    } else {
-        return new BufferAttribute(array, itemSize);
+    /**
+     *
+     * @param {Float64Array|Float32Array|Uint32Array|Uint16Array|Uint8Array|Int32Array|Int16Array|Int8Array} array
+     * @param {int} itemSize
+     * @returns {InstancedBufferAttribute|BufferAttribute}
+     */
+    buildNewBufferAttribute(array, itemSize) {
+        if (this.instanced) {
+            return new InstancedBufferAttribute(array, itemSize);
+        } else {
+            return new BufferAttribute(array, itemSize);
+        }
     }
-};
 
-/**
- *
- * @returns {InstancedBufferGeometry|BufferGeometry}
- */
-ParticleGroup.prototype.buildNewGeometry = function () {
-    if (this.instanced) {
-        const result = new InstancedBufferGeometry();
-        result.maxInstanceCount = this.capacity;
-        return result;
-    } else {
-        return new BufferGeometry();
+    /**
+     *
+     * @returns {InstancedBufferGeometry|BufferGeometry}
+     */
+    buildNewGeometry() {
+        if (this.instanced) {
+            const result = new InstancedBufferGeometry();
+            result.maxInstanceCount = this.capacity;
+            return result;
+        } else {
+            return new BufferGeometry();
+        }
     }
-};
 
-ParticleGroup.prototype.build = function () {
-    const geometry = this.buildNewGeometry();
-    geometry.dynamic = true;
+    build() {
+        const geometry = this.buildNewGeometry();
+        geometry.dynamic = true;
 
-    const l = this.spec.attributes.length;
-    for (let i = 0; i < l; i++) {
+        const l = this.spec.attributes.length;
+        for (let i = 0; i < l; i++) {
 
-        /**
-         * @type {ParticleAttribute}
-         */
-        const attributeSpec = this.spec.attributes[i];
+            /**
+             * @type {ParticleAttribute}
+             */
+            const attributeSpec = this.spec.attributes[i];
 
-        const itemSize = itemSizeFromAttributeType(attributeSpec.type);
-        const TypedArrayConstructor = typedArrayConstructorFromDataType(attributeSpec.dataType);
+            const itemSize = itemSizeFromAttributeType(attributeSpec.type);
+            const TypedArrayConstructor = typedArrayConstructorFromDataType(attributeSpec.dataType);
 
-        const newArrayLength = itemSize * this.capacity;
-        const newArray = new TypedArrayConstructor(newArrayLength);
+            const newArrayLength = itemSize * this.capacity;
+            const newArray = new TypedArrayConstructor(newArrayLength);
 
-        const attribute = this.attributes[i];
-        if (attribute !== undefined && attribute.count !== 0) {
-            //copy old data
-            newArray.set(attribute.array.subarray(0, Math.min(newArrayLength, attribute.array.length)));
-        }
+            const attribute = this.attributes[i];
+            if (attribute !== undefined && attribute.count !== 0) {
+                //copy old data
+                newArray.set(attribute.array.subarray(0, Math.min(newArrayLength, attribute.array.length)));
+            }
+
+            const newAttribute = this.buildNewBufferAttribute(newArray, itemSize);
 
-        const newAttribute = this.buildNewBufferAttribute(newArray, itemSize);
+            newAttribute.setUsage(DynamicDrawUsage);
+            newAttribute.name = attributeSpec.name;
 
-        newAttribute.setUsage(DynamicDrawUsage);
-        newAttribute.name = attributeSpec.name;
+            this.attributes[i] = newAttribute;
 
-        this.attributes[i] = newAttribute;
+            geometry.setAttribute(attributeSpec.name, newAttribute);
+        }
 
-        geometry.setAttribute(attributeSpec.name, newAttribute);
+        this.geometry.set(geometry);
     }
 
-    this.geometry.set(geometry);
-};
+    /**
+     * attributes can not grow, this means that we need to rebuild entire geometry if we want to make that happen
+     */
+    setCapacity(maxSize) {
+        if (this.capacity === maxSize) {
+            //do nothing
+            return;
+        }
 
-/**
- * attributes can not grow, this means that we need to rebuild entire geometry if we want to make that happen
- */
-ParticleGroup.prototype.setCapacity = function (maxSize) {
-    if (this.capacity === maxSize) {
-        //do nothing
-        return;
-    }
+        if (this.size > maxSize) {
+            throw new Error(`Attempted to resize capacity to ${maxSize}. Can't set capacity below current size(=${this.size}).`);
+        }
+
+        // console.log(`capacity resized from ${this.capacity} to ${maxSize}`);
 
-    if (this.size > maxSize) {
-        throw new Error(`Attempted to resize capacity to ${maxSize}. Can't set capacity below current size(=${this.size}).`);
+        this.capacity = maxSize;
+        this.build();
     }
 
-    // console.log(`capacity resized from ${this.capacity} to ${maxSize}`);
+    reset() {
+        this.commandQueue = [];
+        this.size = 0;
 
-    this.capacity = maxSize;
-    this.build();
-};
+        this.referenceIndexLookup.clear();
+        this.indexReferenceLookup = [];
+        this.referencePool.reset();
 
-ParticleGroup.prototype.reset = function () {
-    this.commandQueue = [];
-    this.size = 0;
+        this.setCapacity(100);
+    }
 
-    this.referenceIndexLookup.clear();
-    this.indexReferenceLookup = [];
-    this.referencePool.reset();
+    /**
+     * Flush command queue
+     * @returns {boolean} true if some operations were executed, false otherwise
+     */
+    update() {
+        this.optimizeCommandQueue();
+        const numOperations = this.commandQueue.length;
+        for (let i = 0; i < numOperations; i++) {
+            const operation = this.commandQueue[i];
+            this.executeOperation(operation);
+        }
+        //clear out the queue
+        this.commandQueue = [];
 
-    this.setCapacity(100);
-};
+        return numOperations > 0;
+    }
 
-/**
- * Flush command queue
- * @returns {boolean} true if some operations were executed, false otherwise
- */
-ParticleGroup.prototype.update = function () {
-    this.optimizeCommandQueue();
-    const numOperations = this.commandQueue.length;
-    for (let i = 0; i < numOperations; i++) {
-        const operation = this.commandQueue[i];
-        this.executeOperation(operation);
+    optimizeCommandQueue() {
+        optimizeCommandQueue(this.commandQueue);
     }
-    //clear out the queue
-    this.commandQueue = [];
 
-    return numOperations > 0;
-};
+    /**
+     *
+     * @param {number} id
+     */
+    createSpecific(id) {
+        const reference = this.referencePool.getSpecific(id);
 
-ParticleGroup.prototype.optimizeCommandQueue = function () {
-    optimizeCommandQueue(this.commandQueue);
-};
+        this.commandQueue.push(new Operation(OperationType.Add, [reference]));
+    }
 
-/**
- *
- * @param {number} id
- */
-ParticleGroup.prototype.createSpecific = function (id) {
-    const reference = this.referencePool.getSpecific(id);
+    /**
+     * NOTE: Deferred operation, required update before results can be observed
+     * @returns {number} particle reference
+     */
+    create() {
+        //reserve reference
+        const reference = this.referencePool.get();
 
-    this.commandQueue.push(new Operation(OperationType.Add, [reference]));
-};
+        this.commandQueue.push(new Operation(OperationType.Add, [reference]));
 
-/**
- * NOTE: Deferred operation, required update before results can be observed
- * @returns {number} particle reference
- */
-ParticleGroup.prototype.create = function () {
-    //reserve reference
-    const reference = this.referencePool.get();
+        return reference;
+    }
 
-    this.commandQueue.push(new Operation(OperationType.Add, [reference]));
+    /**
+     * NOTE: Deferred operation, required update before results can be observed
+     */
+    remove(reference) {
+        this.commandQueue.push(new Operation(OperationType.Remove, [reference]));
+    }
 
-    return reference;
-};
+    /**
+     * NOTE: this method does not take pending operations into account
+     * @param reference
+     */
+    contains(reference) {
+        return this.referenceIndexLookup.has(reference);
+    }
 
-/**
- * NOTE: Deferred operation, required update before results can be observed
- */
-ParticleGroup.prototype.remove = function (reference) {
-    this.commandQueue.push(new Operation(OperationType.Remove, [reference]));
-};
+    traverseReferences(visitor) {
+        this.referenceIndexLookup.forEach(function (value, key) {
+            visitor(key);
+        });
+    }
 
-/**
- * NOTE: this method does not take pending operations into account
- * @param reference
- */
-ParticleGroup.prototype.contains = function (reference) {
-    return this.referenceIndexLookup.has(reference);
-};
+    /**
+     * NOTE: Deferred operation, required update before results can be observed
+     * @param {int} reference
+     * @param {int} attributeIndex Index of attribute to be written
+     * @param {Array.<number>} value
+     */
+    writeAttribute(reference, attributeIndex, value) {
+        this.commandQueue.push(new Operation(OperationType.WriteAttribute, [reference, attributeIndex, value]));
+    }
 
-ParticleGroup.prototype.traverseReferences = function (visitor) {
-    this.referenceIndexLookup.forEach(function (value, key) {
-        visitor(key);
-    });
-};
+    /**
+     *
+     * @param {number} index
+     * @param {number} attributeIndex
+     * @param {Array|Float32Array|Float64Array|Uint8Array} result
+     */
+    readAttributeByIndex(index, attributeIndex, result) {
+        const attribute = this.attributes[attributeIndex];
 
-/**
- * NOTE: Deferred operation, required update before results can be observed
- * @param {int} reference
- * @param {int} attributeIndex Index of attribute to be written
- * @param {Array.<number>} value
- */
-ParticleGroup.prototype.writeAttribute = function (reference, attributeIndex, value) {
-    this.commandQueue.push(new Operation(OperationType.WriteAttribute, [reference, attributeIndex, value]));
-};
+        const itemSize = attribute.itemSize;
 
-/**
- *
- * @param {number} index
- * @param {number} attributeIndex
- * @param {Array|Float32Array|Float64Array|Uint8Array} result
- */
-ParticleGroup.prototype.readAttributeByIndex = function (index, attributeIndex, result) {
-    const attribute = this.attributes[attributeIndex];
+        const offset = index * itemSize;
 
-    const itemSize = attribute.itemSize;
+        for (let i = 0; i < itemSize; i++) {
+            const element = attribute.array[offset + i];
+            result[i] = element;
+        }
+    }
 
-    const offset = index * itemSize;
+    readAttribute(reference, attributeIndex, result) {
+        //dereference
+        const index = this.referenceIndexLookup.get(reference);
 
-    for (let i = 0; i < itemSize; i++) {
-        const element = attribute.array[offset + i];
-        result[i] = element;
+        this.readAttributeByIndex(index, attributeIndex, result);
     }
-};
 
-ParticleGroup.prototype.readAttribute = function (reference, attributeIndex, result) {
-    //dereference
-    const index = this.referenceIndexLookup.get(reference);
+    /**
+     * Produces reference of a particle by its index
+     * @param {number} index
+     * @returns {number}
+     */
+    referenceByIndex(index) {
+        return this.indexReferenceLookup[index];
+    }
 
-    this.readAttributeByIndex(index, attributeIndex, result);
-};
-/**
- * Produces reference of a particle by its index
- * @param {number} index
- * @returns {number}
- */
-ParticleGroup.prototype.referenceByIndex = function (index) {
-    return this.indexReferenceLookup[index];
-};
+    createImmediate() {
+        const reference = this.referencePool.get();
+        this.executeOperationAdd([reference]);
 
-ParticleGroup.prototype.createImmediate = function () {
-    const reference = this.referencePool.get();
-    this.executeOperationAdd([reference]);
+        return reference;
+    }
 
-    return reference;
-};
+    executeOperationAdd(references) {
 
-ParticleGroup.prototype.executeOperationAdd = function (references) {
+        const numAdded = references.length;
 
-    const numAdded = references.length;
+        for (let i = 0; i < numAdded; i++) {
+            const reference = references[i];
+            const index = this.size + i;
 
-    for (let i = 0; i < numAdded; i++) {
-        const reference = references[i];
-        const index = this.size + i;
+            this.referenceIndexLookup.set(reference, index);
+            this.indexReferenceLookup[index] = reference;
+        }
 
-        this.referenceIndexLookup.set(reference, index);
-        this.indexReferenceLookup[index] = reference;
+        this.grow(numAdded);
     }
 
-    this.grow(numAdded);
-};
+    executeOperationRemove(references) {
+        const numRemoved = references.length;
 
-ParticleGroup.prototype.executeOperationRemove = function (references) {
-    const numRemoved = references.length;
+        const deleteIndices = [];
 
-    const deleteIndices = [];
+        for (let i = 0; i < numRemoved; i++) {
+            const reference = references[i];
+            const index = this.referenceIndexLookup.get(reference);
 
-    for (let i = 0; i < numRemoved; i++) {
-        const reference = references[i];
-        const index = this.referenceIndexLookup.get(reference);
+            this.referenceIndexLookup.delete(reference);
 
-        this.referenceIndexLookup.delete(reference);
+            deleteIndices.push(index);
 
-        deleteIndices.push(index);
+            //release reference
+            this.referencePool.release(reference);
+        }
 
-        //release reference
-        this.referencePool.release(reference);
+        this.deleteIndices(deleteIndices);
     }
 
-    this.deleteIndices(deleteIndices);
-};
-
-/**
- *
- * @param reference
- * @param attributeIndex
- * @param {number[]} value
- */
-ParticleGroup.prototype.executeOperationWriteAttribute = function (reference, attributeIndex, value) {
+    /**
+     *
+     * @param reference
+     * @param attributeIndex
+     * @param {number[]} value
+     */
+    executeOperationWriteAttribute(reference, attributeIndex, value) {
 
-    //de-reference
-    const index = this.referenceIndexLookup.get(reference);
+        //de-reference
+        const index = this.referenceIndexLookup.get(reference);
 
-    //bind attribute
-    const attribute = this.attributes[attributeIndex];
+        //bind attribute
+        const attribute = this.attributes[attributeIndex];
 
-    attribute.array.set(value, index * attribute.itemSize);
+        attribute.array.set(value, index * attribute.itemSize);
 
-    attribute.needsUpdate = true;
-    //TODO: set update range on the attribute
-};
+        attribute.needsUpdate = true;
+        //TODO: set update range on the attribute
+    }
 
-/**
- *
- * @param reference
- * @param attributeIndex
- * @param {number} value
- */
-ParticleGroup.prototype.executeOperationWriteAttribute_Scalar = function (reference, attributeIndex, value) {
-    //de-reference
-    const index = this.referenceIndexLookup.get(reference);
+    /**
+     *
+     * @param reference
+     * @param attributeIndex
+     * @param {number} value
+     */
+    executeOperationWriteAttribute_Scalar(reference, attributeIndex, value) {
+        //de-reference
+        const index = this.referenceIndexLookup.get(reference);
 
-    //bind attribute
-    const attribute = this.attributes[attributeIndex];
+        //bind attribute
+        const attribute = this.attributes[attributeIndex];
 
-    attribute.array[index] = value;
+        attribute.array[index] = value;
 
-    attribute.needsUpdate = true;
-    //TODO: set update range on the attribute
-};
+        attribute.needsUpdate = true;
+        //TODO: set update range on the attribute
+    }
 
-/**
- *
- * @param reference
- * @param attributeIndex
- * @param x
- * @param y
- * @param z
- */
-ParticleGroup.prototype.executeOperationWriteAttribute_Vector3 = function (reference, attributeIndex, x, y, z) {
-    //de-reference
-    const index = this.referenceIndexLookup.get(reference);
+    /**
+     *
+     * @param reference
+     * @param attributeIndex
+     * @param x
+     * @param y
+     * @param z
+     */
+    executeOperationWriteAttribute_Vector3(reference, attributeIndex, x, y, z) {
+        //de-reference
+        const index = this.referenceIndexLookup.get(reference);
 
-    //bind attribute
-    const attribute = this.attributes[attributeIndex];
+        //bind attribute
+        const attribute = this.attributes[attributeIndex];
 
-    const address = index * 3;
+        const address = index * 3;
 
-    const array = attribute.array;
+        const array = attribute.array;
 
-    array[address] = x;
-    array[address + 1] = y;
-    array[address + 2] = z;
+        array[address] = x;
+        array[address + 1] = y;
+        array[address + 2] = z;
 
-    attribute.needsUpdate = true;
-    //TODO: set update range on the attribute
-};
+        attribute.needsUpdate = true;
+        //TODO: set update range on the attribute
+    }
 
-/**
- *
- * @param reference
- * @param attributeIndex
- * @param x
- * @param y
- * @param z
- * @param w
- */
-ParticleGroup.prototype.executeOperationWriteAttribute_Vector4 = function (reference, attributeIndex, x, y, z, w) {
-    //de-reference
-    const index = this.referenceIndexLookup.get(reference);
+    /**
+     *
+     * @param reference
+     * @param attributeIndex
+     * @param x
+     * @param y
+     * @param z
+     * @param w
+     */
+    executeOperationWriteAttribute_Vector4(reference, attributeIndex, x, y, z, w) {
+        //de-reference
+        const index = this.referenceIndexLookup.get(reference);
 
-    //bind attribute
-    const attribute = this.attributes[attributeIndex];
+        //bind attribute
+        const attribute = this.attributes[attributeIndex];
 
-    const address = index * 4;
+        const address = index * 4;
 
-    const array = attribute.array;
+        const array = attribute.array;
 
-    array[address] = x;
-    array[address + 1] = y;
-    array[address + 2] = z;
-    array[address + 3] = w;
+        array[address] = x;
+        array[address + 1] = y;
+        array[address + 2] = z;
+        array[address + 3] = w;
 
-    attribute.needsUpdate = true;
-    //TODO: set update range on the attribute
-};
+        attribute.needsUpdate = true;
+        //TODO: set update range on the attribute
+    }
 
-/**
- *
- * @param {Operation} operation
- */
-ParticleGroup.prototype.executeOperation = function (operation) {
-    const operands = operation.operands;
+    /**
+     *
+     * @param {Operation} operation
+     */
+    executeOperation(operation) {
+        const operands = operation.operands;
 
-    const self = this;
+        const self = this;
 
-    function _writeAttribute(operands) {
-        const reference = operands[0];
-        const attributeIndex = operands[1];
-        const value = operands[2];
+        function _writeAttribute(operands) {
+            const reference = operands[0];
+            const attributeIndex = operands[1];
+            const value = operands[2];
 
-        self.executeOperationWriteAttribute(reference, attributeIndex, value);
-    }
+            self.executeOperationWriteAttribute(reference, attributeIndex, value);
+        }
 
-    switch (operation.operator) {
-        case OperationType.Add:
-            this.executeOperationAdd(operands);
-            break;
+        switch (operation.operator) {
+            case OperationType.Add:
+                this.executeOperationAdd(operands);
+                break;
 
-        case OperationType.Remove:
-            this.executeOperationRemove(operands);
-            break;
+            case OperationType.Remove:
+                this.executeOperationRemove(operands);
+                break;
 
-        case OperationType.WriteAttribute:
-            _writeAttribute(operands);
-            break;
+            case OperationType.WriteAttribute:
+                _writeAttribute(operands);
+                break;
 
-        default:
-            throw new Error(`Unsupported operator: ${operation.operator}`);
+            default:
+                throw new Error(`Unsupported operator: ${operation.operator}`);
+        }
     }
-};
 
-/**
- *
- * @param {Array.<int>} indices
- */
-ParticleGroup.prototype.deleteIndices = function (indices) {
-    const deleteCount = indices.length;
+    /**
+     *
+     * @param {Array.<int>} indices
+     */
+    deleteIndices(indices) {
+        const deleteCount = indices.length;
 
-    if (deleteCount <= 0) {
-        //nothing to do
-        return;
-    }
+        if (deleteCount <= 0) {
+            //nothing to do
+            return;
+        }
 
-    const oldSize = this.size;
-    const newSize = oldSize - deleteCount;
+        const oldSize = this.size;
+        const newSize = oldSize - deleteCount;
 
-    //sort indices
-    indices.sort();
+        //sort indices
+        indices.sort();
 
-    const specAttributes = this.spec.attributes;
-    const numAttributes = specAttributes.length;
+        const specAttributes = this.spec.attributes;
+        const numAttributes = specAttributes.length;
 
-    let numSwapElements = 0;
-    const swaps = [];
-    let swapDestination = this.size - 1;
+        let numSwapElements = 0;
+        const swaps = [];
+        let swapDestination = this.size - 1;
 
-    let i, j;
+        let i, j;
 
-    for (i = deleteCount - 1; i >= 0; i--) {
-        const victim = indices[i];
+        for (i = deleteCount - 1; i >= 0; i--) {
+            const victim = indices[i];
 
-        if (swapDestination === victim) {
-            swapDestination--;
-        }
+            if (swapDestination === victim) {
+                swapDestination--;
+            }
+
+            if (victim >= newSize) {
+                //is beyond the end of the new array and will be removed anyway, no need to swap
+                continue;
+            }
 
-        if (victim >= newSize) {
-            //is beyond the end of the new array and will be removed anyway, no need to swap
-            continue;
+            swaps.push(victim, swapDestination);
+            numSwapElements += 2;
         }
 
-        swaps.push(victim, swapDestination);
-        numSwapElements += 2;
-    }
 
+        for (i = 0; i < numAttributes; i++) {
+            const attribute = this.attributes[i];
 
-    for (i = 0; i < numAttributes; i++) {
-        const attribute = this.attributes[i];
+            const itemSize = attribute.itemSize;
 
-        const itemSize = attribute.itemSize;
+            const oldArray = attribute.array;
 
-        const oldArray = attribute.array;
+            //do swaps in the old array
+            for (j = 0; j < numSwapElements; j += 2) {
+                const targetIndex = swaps[j] * itemSize;
+                const sourceIndex = swaps[j + 1] * itemSize;
 
-        //do swaps in the old array
-        for (j = 0; j < numSwapElements; j += 2) {
-            const targetIndex = swaps[j] * itemSize;
-            const sourceIndex = swaps[j + 1] * itemSize;
+                oldArray.copyWithin(targetIndex, sourceIndex, sourceIndex + itemSize);
+            }
 
-            oldArray.copyWithin(targetIndex, sourceIndex, sourceIndex + itemSize);
+            attribute.needsUpdate = true;
         }
 
-        attribute.needsUpdate = true;
-    }
+        //update references
 
-    //update references
-
-    for (j = 0; j < numSwapElements; j += 2) {
-        const targetIndex = swaps[j];
-        const sourceIndex = swaps[j + 1];
+        for (j = 0; j < numSwapElements; j += 2) {
+            const targetIndex = swaps[j];
+            const sourceIndex = swaps[j + 1];
+
+            const ref = this.indexReferenceLookup[sourceIndex];
+            //move reference
+            this.indexReferenceLookup[targetIndex] = ref;
+            //this reference will be getting a new index
+            this.referenceIndexLookup.set(ref, targetIndex);
+        }
 
-        const ref = this.indexReferenceLookup[sourceIndex];
-        //move reference
-        this.indexReferenceLookup[targetIndex] = ref;
-        //this reference will be getting a new index
-        this.referenceIndexLookup.set(ref, targetIndex);
-    }
+        //cut tail of index lookup
+        for (i = 0; i < deleteCount; i++) {
+            this.indexReferenceLookup.pop();
+        }
 
-    //cut tail of index lookup
-    for (i = 0; i < deleteCount; i++) {
-        this.indexReferenceLookup.pop();
+        this.setSize(newSize);
     }
 
-    this.setSize(newSize);
-};
+    /**
+     * Swap two particles identified by index
+     * @param {number} indexA
+     * @param {number} indexB
+     */
+    swapAttributeValues(indexA, indexB) {
+        const attributes = this.attributes;
+        const numAttributes = attributes.length;
 
-/**
- * Swap two particles identified by index
- * @param {number} indexA
- * @param {number} indexB
- */
-ParticleGroup.prototype.swapAttributeValues = function (indexA, indexB) {
-    const attributes = this.attributes;
-    const numAttributes = attributes.length;
+        let i, j;
 
-    let i, j;
+        for (i = 0; i < numAttributes; i++) {
+            const attribute = attributes[i];
 
-    for (i = 0; i < numAttributes; i++) {
-        const attribute = attributes[i];
+            const itemSize = attribute.itemSize;
 
-        const itemSize = attribute.itemSize;
+            const offsetA = indexA * itemSize;
+            const offsetB = indexB * itemSize;
 
-        const offsetA = indexA * itemSize;
-        const offsetB = indexB * itemSize;
+            const array = attribute.array;
 
-        const array = attribute.array;
+            for (j = 0; j < itemSize; j++) {
+                const addressA = offsetA + j;
+                const addressB = offsetB + j;
 
-        for (j = 0; j < itemSize; j++) {
-            const addressA = offsetA + j;
-            const addressB = offsetB + j;
+                const elementA = array[addressA];
 
-            const elementA = array[addressA];
+                array[addressA] = array[addressB];
 
-            array[addressA] = array[addressB];
+                array[addressB] = elementA;
+            }
 
-            array[addressB] = elementA;
+            attribute.needsUpdate = true;
         }
 
-        attribute.needsUpdate = true;
+
     }
 
+    /**
+     *
+     * @param {number} indexA
+     * @param {number} indexB
+     */
+    swap(indexA, indexB) {
+        this.swapAttributeValues(indexA, indexB);
 
-};
+        const refA = this.indexReferenceLookup[indexA];
+        const refB = this.indexReferenceLookup[indexB];
 
-/**
- *
- * @param {number} indexA
- * @param {number} indexB
- */
-ParticleGroup.prototype.swap = function (indexA, indexB) {
-    this.swapAttributeValues(indexA, indexB);
+        this.referenceIndexLookup.set(refA, indexB);
+        this.referenceIndexLookup.set(refB, indexA);
 
-    const refA = this.indexReferenceLookup[indexA];
-    const refB = this.indexReferenceLookup[indexB];
-
-    this.referenceIndexLookup.set(refA, indexB);
-    this.referenceIndexLookup.set(refB, indexA);
+        this.indexReferenceLookup[indexA] = refB;
+        this.indexReferenceLookup[indexB] = refA;
+    }
 
-    this.indexReferenceLookup[indexA] = refB;
-    this.indexReferenceLookup[indexB] = refA;
-};
+    /**
+     *
+     * @param {int} numAdded
+     */
+    grow(numAdded) {
+        const oldSize = this.size;
+        const newSize = oldSize + numAdded;
 
-/**
- *
- * @param {int} numAdded
- */
-ParticleGroup.prototype.grow = function (numAdded) {
-    const oldSize = this.size;
-    const newSize = oldSize + numAdded;
+        this.setSize(newSize);
+    }
 
-    this.setSize(newSize);
-};
+    preAllocate(itemCount) {
+        const newSize = this.size + itemCount;
 
+        if (this.capacity < newSize) {
+            this.updateCapacity(newSize);
+        }
+    }
 
-const SHRINK_THRESHOLD = 64;
-const GROW_MIN_STEP = 16;
+    updateCapacity(newSize) {
 
-ParticleGroup.prototype.preAllocate = function (itemCount) {
-    const newSize = this.size + itemCount;
+        if (newSize > this.capacity) {
+            //grow
+            const newCapacity = Math.floor(Math.max(newSize, this.capacity * this.growFactor, this.capacity + GROW_MIN_STEP));
+            this.setCapacity(newCapacity);
+        } else if (newSize < this.capacity * this.shrinkFactor && newSize < this.capacity - SHRINK_THRESHOLD) {
+            //shrink
+            this.setCapacity(newSize);
+        }
 
-    if (this.capacity < newSize) {
-        this.updateCapacity(newSize);
+        const geometry = this.geometry.getValue();
+        geometry.setDrawRange(0, newSize);
     }
-};
 
-ParticleGroup.prototype.updateCapacity = function (newSize) {
+    /**
+     *
+     * @param {int} newSize
+     */
+    setSize(newSize) {
+        this.size = newSize;
 
-    if (newSize > this.capacity) {
-        //grow
-        const newCapacity = Math.floor(Math.max(newSize, this.capacity * this.growFactor, this.capacity + GROW_MIN_STEP));
-        this.setCapacity(newCapacity);
-    } else if (newSize < this.capacity * this.shrinkFactor && newSize < this.capacity - SHRINK_THRESHOLD) {
-        //shrink
-        this.setCapacity(newSize);
+        this.updateCapacity(newSize);
     }
+}
 
-    const geometry = this.geometry.getValue();
-    geometry.setDrawRange(0, newSize);
-};
-
-/**
- *
- * @param {int} newSize
- */
-ParticleGroup.prototype.setSize = function (newSize) {
-    this.size = newSize;
-
-    this.updateCapacity(newSize);
-};
 
-export {
-    ParticleGroup
-};
+const SHRINK_THRESHOLD = 64;
+const GROW_MIN_STEP = 16;