@woosh/meep-engine 2.33.21 → 2.33.25

package/engine/graphics/particles/particular/engine/emitter/ParticlePool.js

@@ -1,9 +1,12 @@
 import { BitSet } from "../../../../../../core/binary/BitSet.js";
 import { max3 } from "../../../../../../core/math/max3.js";
-import { itemSizeFromAttributeType, typedArrayConstructorFromDataType } from "../../group/ParticleGroup.js";
-import { BufferAttribute, BufferGeometry, DynamicDrawUsage } from 'three';
+import { BufferAttribute, BufferGeometry, StreamDrawUsage } from 'three';
 import ObservedValue from "../../../../../../core/model/ObservedValue.js";
 import { typed_array_copy } from "../../../../../../core/collection/array/typed/typed_array_copy.js";
+import { assert } from "../../../../../../core/assert.js";
+import { compute_typed_array_constructor_from_data_type } from "../../../../../../core/collection/table/DataType2TypedArrayConstructorMapping.js";
+import { min2 } from "../../../../../../core/math/min2.js";
+import { max2 } from "../../../../../../core/math/max2.js";
 
 const SHRINK_THRESHOLD = 64;
 const GROW_MIN_STEP = 32;
@@ -11,13 +14,15 @@ const GROW_MIN_STEP = 32;
 export class ParticlePool {
     /**
      *
-     * @param {ParticleSpecification} spec
+     * @param {VertexDataSpec} spec
      * @constructor
      */
     constructor(spec) {
+        assert.equal(spec.isVertexDataSpec, true, 'spec.VertexDataSpec !== true');
+
         /**
          *
-         * @type {ParticleSpecification}
+         * @type {VertexDataSpec}
          */
         this.spec = spec;
 
@@ -215,15 +220,50 @@ export class ParticlePool {
                 const addressA = offsetA + j;
                 const addressB = offsetB + j;
 
-                const elementA = array[addressA];
+                const temp = array[addressA];
 
                 array[addressA] = array[addressB];
 
-                array[addressB] = elementA;
+                array[addressB] = temp;
             }
         }
     }
 
+    /**
+     *
+     * @param {AttributeSpec} spec
+     * @return {number}
+     * @private
+     */
+    __compute_attribute_byte_size(spec) {
+
+        const item_size = spec.itemSize;
+
+        const TypedArrayConstructor = compute_typed_array_constructor_from_data_type(spec.type);
+
+        const element_byte_size = TypedArrayConstructor.BYTES_PER_ELEMENT;
+
+        return item_size * element_byte_size * this.capacity;
+    }
+
+    /**
+     *
+     * @return {number}
+     * @private
+     */
+    __compute_attribute_byte_size_total() {
+
+        const spec_attributes = this.spec.attributes;
+        const l = spec_attributes.length;
+
+        let r = 0;
+        for (let i = 0; i < l; i++) {
+            r += this.__compute_attribute_byte_size(spec_attributes[i]);
+        }
+
+        return r;
+    }
+
     build() {
         const geometry = new BufferGeometry();
         geometry.dynamic = true;
@@ -234,25 +274,26 @@ export class ParticlePool {
         for (let i = 0; i < l; i++) {
 
             /**
-             * @type {ParticleAttribute}
+             * @type {AttributeSpec}
              */
             const attributeSpec = spec_attributes[i];
 
-            const itemSize = itemSizeFromAttributeType(attributeSpec.type);
-            const TypedArrayConstructor = typedArrayConstructorFromDataType(attributeSpec.dataType);
+            const itemSize = attributeSpec.itemSize;
+            const TypedArrayConstructor = compute_typed_array_constructor_from_data_type(attributeSpec.type);
 
             const newArrayLength = itemSize * this.capacity;
             const newArray = new TypedArrayConstructor(newArrayLength);
 
-            const attribute = this.attributes[i];
-            if (attribute !== undefined && attribute.count !== 0) {
+            const old_attribute = this.attributes[i];
+
+            if (old_attribute !== undefined && old_attribute.count !== 0) {
                 //copy old data
-                typed_array_copy(attribute.array, newArray);
+                typed_array_copy(old_attribute.array, newArray);
             }
 
-            const newAttribute = new BufferAttribute(newArray, itemSize);
+            const newAttribute = new BufferAttribute(newArray, itemSize, attributeSpec.normalized);
 
-            newAttribute.setUsage(DynamicDrawUsage);
+            newAttribute.setUsage(StreamDrawUsage);
             newAttribute.name = attributeSpec.name;
 
             this.attributes[i] = newAttribute;
@@ -466,6 +507,92 @@ export class ParticlePool {
         array[address + 3] = w;
     }
 
+    /**
+     * Write the same attribute value for every particle.
+     * Assumes particles are packed (no holes).
+     * @param {number} attribute_index
+     * @param {number[]|Float32Array|Uint8Array|Uint16Array|Int8Array|Int32Array} value
+     */
+    writeAttributeForAllArray(attribute_index, value) {
+        const attribute = this.attributes[attribute_index];
+
+        const itemSize = attribute.itemSize;
+
+        if (value.length < itemSize) {
+            throw new Error(`Argument underflow, attribute.itemSize is '${itemSize}', but supplier argument's length is '${value.length}'`);
+        }
+
+        const n = this.size();
+
+        const destination = attribute.array;
+
+        let k;
+        for (let i = 0; i < n; i++) {
+            const offset = i * itemSize;
+
+            for (k = 0; k < itemSize; k++) {
+                destination[offset + k] = value[k];
+            }
+        }
+
+        // mark for update
+        attribute.needsUpdate = true;
+        attribute.updateRange.count = n;
+        attribute.updateRange.offset = 0;
+    }
+
+    /**
+     *
+     * @param {number} attribute_index
+     * @param {number[]} result
+     */
+    computeAttributeVector3AxisAlignedBoundingBox(attribute_index, result) {
+        const attribute = this.attributes[attribute_index];
+        const item_size = attribute.itemSize;
+
+        if (item_size !== 3) {
+            throw new Error(`Attribute item_size is expected to be 3, instead was '${item_size}'`);
+        }
+
+        let bounds_x0 = Infinity;
+        let bounds_y0 = Infinity;
+        let bounds_z0 = Infinity;
+
+        let bounds_x1 = -Infinity;
+        let bounds_y1 = -Infinity;
+        let bounds_z1 = -Infinity;
+
+        const particle_count = this.size();
+
+        const data = attribute.array;
+
+        for (let i = 0; i < particle_count; i++) {
+            const particle_address = i * 3;
+
+            const x = data[particle_address];
+            const y = data[particle_address + 1];
+            const z = data[particle_address + 2];
+
+            bounds_x0 = min2(bounds_x0, x);
+            bounds_y0 = min2(bounds_y0, y);
+            bounds_z0 = min2(bounds_z0, z);
+
+            bounds_x1 = max2(bounds_x1, x);
+            bounds_y1 = max2(bounds_y1, y);
+            bounds_z1 = max2(bounds_z1, z);
+        }
+
+        // read out
+        result[0] = bounds_x0;
+        result[1] = bounds_y0;
+        result[2] = bounds_z0;
+
+        result[3] = bounds_x1;
+        result[4] = bounds_y1;
+        result[5] = bounds_z1;
+
+    }
+
     dispose() {
         const bufferGeometry = this.geometry.getValue();
 

package/engine/graphics/particles/particular/engine/emitter/ParticlePool.spec.js

@@ -1,16 +1,17 @@
 import { ParticlePool } from "./ParticlePool.js";
-import { ParticleAttributeType, ParticleDataType, } from "../../group/ParticleGroup.js";
-import { ParticleSpecification } from "../../group/ParticleSpecification.js";
-import { ParticleAttribute } from "../../group/ParticleAttribute.js";
+import { VertexDataSpec } from "../../../../geometry/VertexDataSpec.js";
+import { DataType } from "../../../../../../core/collection/table/DataType.js";
+import { AttributeSpec } from "../../../../geometry/AttributeSpec.js";
 
 /**
  *
  * @returns {ParticlePool}
  */
 function samplePool() {
-    const specification = new ParticleSpecification();
-    specification.add(new ParticleAttribute('a', ParticleAttributeType.Scalar, ParticleDataType.Float32));
-    specification.add(new ParticleAttribute('b', ParticleAttributeType.Vector4, ParticleDataType.Float32));
+    const specification = new VertexDataSpec();
+
+    specification.add(AttributeSpec.fromJSON({name:'a', type:DataType.Float32, itemSize:1}));
+    specification.add(AttributeSpec.fromJSON({name:'b', type:DataType.Float32, itemSize:4}));
 
     const pool = new ParticlePool(specification);
 
@@ -184,4 +185,4 @@ test('read/write scalar attribute', () => {
     pool.writeAttributeScalar(1, 0, 42);
 
     expect(pool.readAttributeScalar(1, 0)).toBe(42);
-});
+});

package/engine/graphics/particles/particular/engine/emitter/computeEmissionFunction.js

@@ -0,0 +1,37 @@
+import { EmissionShapeType } from "./EmissionShapeType.js";
+import { randomPointInPoint } from "../../../../../../core/geom/random/randomPointInPoint.js";
+import { EmissionFromType } from "./EmissionFromType.js";
+import { randomPointInSphere } from "../../../../../../core/geom/random/randomPointInSphere.js";
+import { randomPointOnSphere } from "../../../../../../core/geom/random/randomPointOnSphere.js";
+import { randomPointInBox } from "../../../../../../core/geom/random/randomPointInBox.js";
+import { randomPointOnBox } from "../../../../../../core/geom/random/randomPointOnBox.js";
+
+/**
+ *
+ * @param {EmissionFromType} emissionType
+ * @param {EmissionShapeType} emissionShape
+ * @returns {function(random: function, result:(number[]|Float32Array|Float64Array), result_offset:number):void}
+ */
+export function computeEmissionFunction(emissionType, emissionShape) {
+    if (emissionShape === EmissionShapeType.Point) {
+        return randomPointInPoint;
+    } else if (emissionShape === EmissionShapeType.Sphere) {
+        if (emissionType === EmissionFromType.Volume) {
+            return randomPointInSphere;
+        } else if (emissionType === EmissionFromType.Shell) {
+            return randomPointOnSphere;
+        } else {
+            throw new TypeError('Unsupported EmissionFrom Type');
+        }
+    } else if (emissionShape === EmissionShapeType.Box) {
+        if (emissionType === EmissionFromType.Volume) {
+            return randomPointInBox;
+        } else if (emissionType === EmissionFromType.Shell) {
+            return randomPointOnBox;
+        } else {
+            throw new TypeError('Unsupported EmissionFrom Type');
+        }
+    } else {
+        throw new TypeError('Unsupported emission shape');
+    }
+}

package/engine/graphics/particles/particular/engine/emitter/distance_to_camera.js

@@ -0,0 +1,25 @@
+/**
+ *
+ * @param {number} index
+ * @param {number[]|Float32Array} positionArray
+ * @param {Vector3} planeNormal
+ * @return {number}
+ */
+export function distance_to_camera(index, positionArray, planeNormal) {
+    const address = index * 3;
+
+    // extract position components of the particle
+    const x = positionArray[address];
+    const y = positionArray[address + 1];
+    const z = positionArray[address + 2];
+
+    const planeNormalX = planeNormal.x;
+    const planeNormalY = planeNormal.y;
+    const planeNormalZ = planeNormal.z;
+
+    // compute dot product
+    const dot = x * planeNormalX + y * planeNormalY + z * planeNormalZ;
+
+    // use dot product instead of the actual distance to save computation. Difference is going to be constant
+    return dot;
+}

package/engine/graphics/particles/particular/engine/emitter/serde/ParameterLookupTableSerializationAdapter.js

@@ -86,10 +86,16 @@ export class ParameterLookupTableSerializationAdapter extends BinaryClassSeriali
 
         const dataLength = itemCount * value.itemSize;
 
-        const data = new Float32Array(dataLength);
+        /**
+         * Reserve a continuous chunk of memory for faster access
+         * @type {ArrayBuffer}
+         */
+        const array_buffer = new ArrayBuffer((dataLength + itemCount) * 4);
+
+        const data = new Float32Array(array_buffer, itemCount * 4, dataLength);
         buffer.readFloat32Array(data, 0, dataLength);
 
-        const positions = new Float32Array(itemCount);
+        const positions = new Float32Array(array_buffer, 0, itemCount);
         buffer.readFloat32Array(positions, 0, itemCount);
 
         value.write(data, positions);

package/engine/graphics/particles/particular/engine/parameter/ParameterLookupTable.js

@@ -1,11 +1,12 @@
 import { inverseLerp } from "../../../../../../core/math/inverseLerp.js";
-import { computeHashFloatArray, computeHashIntegerArray } from "../../../../../../core/math/MathUtils.js";
 import { assert } from "../../../../../../core/assert.js";
 import { max2 } from "../../../../../../core/math/max2.js";
 import { min2 } from "../../../../../../core/math/min2.js";
 import { mix } from "../../../../../../core/math/mix.js";
 import { ParameterLookupTableFlags } from "./ParameterLookupTableFlags.js";
 import { ParameterLookupTableSerializationAdapter } from "../emitter/serde/ParameterLookupTableSerializationAdapter.js";
+import { computeHashIntegerArray } from "../../../../../../core/collection/array/computeHashIntegerArray.js";
+import { computeHashFloatArray } from "../../../../../../core/math/hash/computeHashFloatArray.js";
 
 
 export class ParameterLookupTable {

package/engine/graphics/particles/particular/engine/parameter/ParameterTrack.js

@@ -5,8 +5,8 @@
  * @constructor
  */
 import { ParameterLookupTable } from "./ParameterLookupTable.js";
-import { computeHashIntegerArray } from "../../../../../../core/math/MathUtils.js";
 import { computeStringHash } from "../../../../../../core/primitives/strings/computeStringHash.js";
+import { computeHashIntegerArray } from "../../../../../../core/collection/array/computeHashIntegerArray.js";
 
 export class ParameterTrack {
     constructor(name, lut) {

package/engine/graphics/particles/particular/engine/parameter/ParticleParameter.js

@@ -1,10 +1,10 @@
-import { computeHashIntegerArray} from "../../../../../../core/math/MathUtils.js";
 import { assert } from "../../../../../../core/assert.js";
 import { max2 } from "../../../../../../core/math/max2.js";
 import { min2 } from "../../../../../../core/math/min2.js";
 import { ParameterLookupTable } from "./ParameterLookupTable.js";
 import List from "../../../../../../core/collection/list/List.js";
 import { computeStringHash } from "../../../../../../core/primitives/strings/computeStringHash.js";
+import { computeHashIntegerArray } from "../../../../../../core/collection/array/computeHashIntegerArray.js";
 
 
 export class ParticleParameter {

package/engine/graphics/particles/particular/engine/renderers/billboard/BILLBOARD_PARTICLE_SPECIFICATION.js

@@ -0,0 +1,24 @@
+import { VertexDataSpec } from "../../../../../geometry/VertexDataSpec.js";
+import { AttributeSpec } from "../../../../../geometry/AttributeSpec.js";
+import { DataType } from "../../../../../../../core/collection/table/DataType.js";
+
+export const BILLBOARD_PARTICLE_ATTRIBUTE_POSITION = 0;
+export const BILLBOARD_PARTICLE_ATTRIBUTE_UV = 1;
+export const BILLBOARD_PARTICLE_ATTRIBUTE_SIZE = 2;
+export const BILLBOARD_PARTICLE_ATTRIBUTE_VELOCITY = 3;
+export const BILLBOARD_PARTICLE_ATTRIBUTE_COLOR = 5;
+export const BILLBOARD_PARTICLE_ATTRIBUTE_BLEND = 6;
+
+export const BILLBOARD_PARTICLE_SPECIFICATION = new VertexDataSpec();
+
+BILLBOARD_PARTICLE_SPECIFICATION.add(AttributeSpec.fromJSON({ name: 'position', itemSize: 3, type: DataType.Float32 }));
+BILLBOARD_PARTICLE_SPECIFICATION.add(AttributeSpec.fromJSON({
+    name: 'atlasPatch',
+    itemSize: 4,
+    type: DataType.Float32
+}));
+BILLBOARD_PARTICLE_SPECIFICATION.add(AttributeSpec.fromJSON({ name: 'size', itemSize: 1, type: DataType.Float32 }));
+BILLBOARD_PARTICLE_SPECIFICATION.add(AttributeSpec.fromJSON({ name: 'velocity', itemSize: 3, type: DataType.Float32 }));
+BILLBOARD_PARTICLE_SPECIFICATION.add(AttributeSpec.fromJSON({ name: 'rotation', itemSize: 1, type: DataType.Float32 }));
+BILLBOARD_PARTICLE_SPECIFICATION.add(AttributeSpec.fromJSON({ name: 'color', itemSize: 1, type: DataType.Float32 }));
+BILLBOARD_PARTICLE_SPECIFICATION.add(AttributeSpec.fromJSON({ name: 'blending', itemSize: 1, type: DataType.Uint8 }));