@woosh/meep-engine 2.29.0 → 2.30.0

package/core/process/worker/WorkerBuilder.js

@@ -125,7 +125,11 @@ WorkerBuilder.prototype.build = function () {
         '   if(method === undefined){',
         '       sendError(new Error("API named \'"+methodName+"\' was not found."));',
         '   }else{',
-        '       method.apply(null,parameters).then(sendResult, sendError);',
+        '       try{',
+        '           method.apply(null,parameters).then(sendResult, sendError);',
+        '       }catch(e){',
+        '           sendError(e);',
+        '       }',
         '   }',
         '};'
     ]);

package/engine/Engine.d.ts

@@ -9,8 +9,12 @@ import {EntityManager} from "./ecs/EntityManager";
 import View from "../view/View";
 import Ticker from "./simulation/Ticker";
 
+export interface IEngineInitializationOptions {
+    entityManager?: EntityManager
+}
+
 export default class Engine {
-    constructor(platform: EnginePlatform);
+    constructor(platform: EnginePlatform, options?: IEngineInitializationOptions);
 
     public get viewStack(): View
 

package/engine/Engine.js

@@ -52,9 +52,10 @@ class Engine {
     /**
      *
      * @param {EnginePlatform} platform
+     * @param {EntityManager} [entityManager]
      * @constructor
      */
-    constructor(platform) {
+    constructor(platform, { entityManager } = {}) {
         assert.defined(platform, 'platform');
 
         /**
@@ -81,6 +82,21 @@ class Engine {
          */
         this.performance = new MetricCollection();
 
+        const using_external_entity_manager = entityManager !== undefined;
+
+        //setup entity component system
+        if (using_external_entity_manager) {
+            // external entity manager provided
+            this.entityManager = entityManager;
+        } else {
+            this.entityManager = new EntityManager();
+        }
+
+        /**
+         *
+         * @type {Ticker}
+         */
+        this.ticker = new Ticker();
 
         this.__performacne_monitor = new PeriodicConsolePrinter(15, () => {
             const metrics = this.performance;
@@ -112,6 +128,22 @@ class Engine {
             return `FPS: ${v_fps}, RENDER: ${v_render}ms, SIMULATION: ${v_sim}ms`;
         });
 
+
+        if (!using_external_entity_manager) {
+            // subscribe simulator to common ticker
+            this.ticker.subscribe(timeDelta => {
+                const t0 = performance.now();
+                this.entityManager.simulate(timeDelta);
+
+                const t1 = performance.now();
+                const duration = (t1 - t0) / 1000;
+
+                // record frame time
+                this.performance.get(METRIC_ID_SIMULATION).record(duration);
+            });
+        }
+
+
         this.initialize();
     }
 
@@ -168,9 +200,6 @@ class Engine {
         this.localization = new Localization();
         this.localization.setAssetManager(this.assetManager);
 
-        //setup entity component system
-        const em = this.entityManager = new EntityManager();
-
 
         const innerWidth = window.innerWidth / 3;
         const innerHeight = window.innerHeight / 3;
@@ -182,7 +211,7 @@ class Engine {
          *
          * @type {GraphicsEngine}
          */
-        const ge = this.graphics = new GraphicsEngine(this.camera, em);
+        const ge = this.graphics = new GraphicsEngine(this.camera, this.entityManager);
 
         try {
             ge.start();
@@ -208,18 +237,6 @@ class Engine {
          */
         this.gui = new GUIEngine();
 
-        this.ticker = new Ticker();
-        this.ticker.subscribe(timeDelta => {
-            const t0 = performance.now();
-            this.entityManager.simulate(timeDelta);
-
-            const t1 = performance.now();
-            const duration = (t1 - t0) / 1000;
-
-            // record frame time
-            this.performance.get(METRIC_ID_SIMULATION).record(duration);
-        });
-
         /**
          * @readonly
          * @type {SceneManager}
@@ -492,6 +509,7 @@ class Engine {
 
                 const frame_delay = (t1 - t0) / 1000;
 
+                // swap variables
                 t0 = t1;
 
                 // record metric

package/engine/EngineHarness.js

@@ -24,6 +24,8 @@ import WaterSystem from "./graphics/ecs/water/WaterSystem.js";
 import KeyboardCameraController from "./input/ecs/controllers/KeyboardCameraController.js";
 import { EngineConfiguration } from "./EngineConfiguration.js";
 import { JsonAssetLoader } from "./asset/loaders/JsonAssetLoader.js";
+import { logger } from "./logging/GlobalLogger.js";
+import { ConsoleLoggerBackend } from "./logging/ConsoleLoggerBackend.js";
 
 /**
  *
@@ -77,6 +79,8 @@ export class EngineHarness {
 
         window.engine = this.engine;
 
+        logger.addBackend(new ConsoleLoggerBackend());
+
         this.p = null;
     }
 
@@ -321,7 +325,7 @@ export class EngineHarness {
 
     /**
      *
-     * @param {number} cameraEntity
+     * @param {number} [cameraEntity]
      * @param {Engine} engine
      * @param {number} [sensitivity]
      * @param {Element} domElement
@@ -335,6 +339,10 @@ export class EngineHarness {
                                                   sensitivity = 0.01
                                               }) {
 
+        if (cameraEntity === undefined) {
+            cameraEntity = ecd.getAnyComponent(Camera).entity;
+        }
+
         const em = engine.entityManager;
 
         if (em.getSystem(InputControllerSystem) === null) {

package/engine/asset/loaders/image/codec/CodecWithFallback.js

@@ -17,7 +17,7 @@ export class CodecWithFallback extends Codec {
     async decode(data) {
 
         try {
-            return this.main.decode(data);
+            return await this.main.decode(data);
         } catch (e) {
             logger.warn(`Main codec failed, will attempt fallback. Error: ${e}`);
 

package/engine/asset/loaders/image/png/PNGReader.js

@@ -7,19 +7,6 @@ import { PNG } from './PNG.js';
 import { BinaryBuffer } from "../../../../../core/binary/BinaryBuffer.js";
 import { isArrayEqualStrict } from "../../../../../core/collection/array/isArrayEqualStrict.js";
 
-var inflate = function (data, callback) {
-    let result;
-
-    try {
-        result = zlib.inflate(new Uint8Array(data));
-
-        callback(null, result);
-    } catch (e) {
-        callback(e);
-    }
-
-};
-
 function readUInt32(buffer, offset) {
     return (buffer[offset] << 24) +
         (buffer[offset + 1] << 16) +
@@ -294,11 +281,14 @@ PNGReader.prototype.unFilterNone = function (scanline, scanline_offset, pixels,
 PNGReader.prototype.unFilterSub = function (scanline, scanline_offset, pixels, bpp, of, length) {
     var i = 0;
 
-    for (; i < bpp; i++) pixels[of + i] = scanline[i + scanline_offset];
+    for (; i < bpp; i++) {
+        pixels[of + i] = scanline[i + scanline_offset];
+    }
 
     for (; i < length; i++) {
         // Raw(x) + Raw(x - bpp)
-        pixels[of + i] = (scanline[i + scanline_offset] + pixels[of + i - bpp]) & 0xFF;
+        const of_i = of + i;
+        pixels[of_i] = (scanline[i + scanline_offset] + pixels[of_i - bpp]) & 0xFF;
     }
 };
 
@@ -336,19 +326,26 @@ PNGReader.prototype.unFilterAverage = function (scanline, scanline_offset, pixel
         }
         // Prior(x) == 0 && Raw(x - bpp) != 0 (right shift, prevent doubles)
         for (; i < length; i++) {
-            pixels[of + i] = (scanline[i + scanline_offset] + (pixels[of + i - bpp] >> 1)) & 0xFF;
+            const of_i = of + i;
+            pixels[of_i] = (scanline[i + scanline_offset] + (pixels[of_i - bpp] >> 1)) & 0xFF;
         }
     } else {
         // Prior(x) != 0 && Raw(x - bpp) == 0
         for (; i < bpp; i++) {
-            pixels[of + i] = (scanline[i + scanline_offset] + (pixels[of - length + i] >> 1)) & 0xFF;
+            const of_i = of + i;
+
+            pixels[of_i] = (scanline[i + scanline_offset] + (pixels[of_i - length] >> 1)) & 0xFF;
         }
         // Prior(x) != 0 && Raw(x - bpp) != 0
         for (; i < length; i++) {
             byte = scanline[i + scanline_offset];
-            prev = pixels[of + i - bpp];
-            prior = pixels[of + i - length];
-            pixels[of + i] = (byte + (prev + prior >> 1)) & 0xFF;
+
+            const of_i = of + i;
+
+            prev = pixels[of_i - bpp];
+            prior = pixels[of_i - length];
+
+            pixels[of_i] = (byte + (prev + prior >> 1)) & 0xFF;
         }
     }
 };
@@ -387,10 +384,11 @@ PNGReader.prototype.unFilterPaeth = function (scanline, scanline_offset, pixels,
             pixels[of + i] = (scanline[i + scanline_offset] + pixels[of + i - bpp]) & 0xFF;
         }
     } else {
+        const of1 = of - length;
         // Prior(x) != 0 && Raw(x - bpp) == 0
         // paethPredictor(x, 0, 0) is always x
         for (; i < bpp; i++) {
-            pixels[of + i] = (scanline[i + scanline_offset] + pixels[of + i - length]) & 0xFF;
+            pixels[of + i] = (scanline[i + scanline_offset] + pixels[of1 + i]) & 0xFF;
         }
         // Prior(x) != 0 && Raw(x - bpp) != 0
         for (; i < length; i++) {

package/engine/ecs/EntityManager.js

@@ -699,6 +699,16 @@ EntityManager.prototype.startSystem = function (system, successCallback, errorCa
  * @param {function} errorCallback executed if entity manager encounters an error during startup
  */
 EntityManager.prototype.startup = function (readyCallback, errorCallback) {
+    if (this.state === EntityManagerState.Starting) {
+        throw new IllegalStateException(`System is currently in starting state`);
+    }
+
+    if (this.state === EntityManagerState.Running) {
+        // already running, do nothing
+        readyCallback();
+        return;
+    }
+
     assert.isFunction(readyCallback, 'readyCallback');
     assert.isFunction(errorCallback, 'errorCallback');
 

package/engine/graphics/ecs/camera/topdown/ComputeCameraFacingVector.js

@@ -0,0 +1,21 @@
+import Quaternion from "../../../../../core/geom/Quaternion.js";
+import Vector3 from "../../../../../core/geom/Vector3.js";
+
+const q = new Quaternion();
+
+/**
+ *
+ * @param {number} yaw
+ * @param {number} pitch
+ * @param roll
+ * @param {Vector3} result
+ */
+export function computeCameraFacingVector(yaw, pitch, roll, result) {
+    q.__setFromEuler(pitch, yaw, roll, 'ZYX');
+    q.normalize();
+
+    result.copy(Vector3.forward);
+    result.applyQuaternion(q);
+    result.normalize();
+
+}

package/engine/graphics/ecs/camera/topdown/TopDownCameraController.js

@@ -10,6 +10,7 @@ import { Euler, Matrix4 } from "three";
 
 const m4 = new Matrix4();
 const euler = new Euler();
+const scratch_vector3 = new Vector3();
 
 const panOffset = new Vector3();
 
@@ -21,25 +22,20 @@ const panOffset = new Vector3();
  * @param {TopDownCameraController} output rotation delta
  */
 export function rotate_from_view(displacement_x, displacement_y, input, output) {
-    const rotation_matrix = new Matrix4();
 
-    const euler = new Euler(-displacement_y, displacement_x, 0, 'ZYX');
-    rotation_matrix.makeRotationFromEuler(euler);
+    euler.set(input.pitch, input.yaw, input.roll)
+    m4.makeRotationFromEuler(euler);
 
-    // get rotation matrix from controller
-    const euler1 = new Euler(input.pitch, input.yaw, input.roll, 'ZYX');
+    const up = scratch_vector3;
+    scratch_vector3.copy(Vector3.up);
 
-    const m_original = new Matrix4();
-    m_original.makeRotationFromEuler(euler1);
+    up.applyMatrix4_three(m4);
 
-    rotation_matrix.multiplyMatrices(m_original, rotation_matrix);
+    // detect when camera is upside-down
+    const y_multiplier = up.y <= 0 ? -1 : 1;
 
-    // extract new rotation
-    euler.setFromRotationMatrix(rotation_matrix);
-
-    output.pitch = euler.x;
-    output.yaw = euler.y;
-    output.roll = euler.z;
+    output.pitch -= displacement_y;
+    output.yaw += displacement_x * y_multiplier;
 }
 
 /**

package/engine/graphics/ecs/camera/topdown/TopDownCameraControllerSystem.js

@@ -13,7 +13,6 @@ import { System } from '../../../../ecs/System.js';
 import TopDownCameraController from './TopDownCameraController.js';
 
 import { Euler as ThreeEuler } from 'three';
-import Quaternion from "../../../../../core/geom/Quaternion.js";
 
 
 const v3_scratch = new Vector3();
@@ -74,25 +73,6 @@ export function computeTopDownTransform(control, result) {
     result.position.copy(v3_scratch);
 }
 
-const q = new Quaternion();
-
-/**
- *
- * @param {number} yaw
- * @param {number} pitch
- * @param roll
- * @param {Vector3} result
- */
-export function computeCameraFacingVector(yaw, pitch, roll, result) {
-    q.__setFromEuler(pitch, yaw, roll, 'ZYX');
-    q.normalize();
-
-    result.copy(Vector3.forward);
-    result.applyQuaternion(q);
-    result.normalize();
-
-}
-
 /**
  *
  * @param {Transform} transform
@@ -123,11 +103,11 @@ export function setCameraControllerFromTransform(transform, controller, distance
 
     controller.distance = distance;
 
-    const targetOffset = direction.clone()
-        .multiplyScalar(controller.distance);
+    const targetOffset = direction.clone();
+    targetOffset.multiplyScalar(controller.distance);
 
-    const target = transform.position.clone()
-        .sub(targetOffset);
+    const target = transform.position.clone();
+    target.sub(targetOffset);
 
     controller.target.copy(target)
 }

package/engine/graphics/particles/particular/engine/ParticularEngine.js

@@ -132,6 +132,7 @@ ParticularEngine.prototype.advanceEmitter = function (emitter, timeDelta) {
 
             const step = steps[type];
 
+            step.emitter = emitter;
             step.timeDelta = timeDelta;
             step.particles = emitter.particles;
             step.layer_parameters[j] = stepDefinition.parameters;

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

@@ -3,7 +3,10 @@ export const PARTICLE_ATTRIBUTE_AGE = 1;
 export const PARTICLE_ATTRIBUTE_DEATH_AGE = 2;
 export const PARTICLE_ATTRIBUTE_UV = 3;
 export const PARTICLE_ATTRIBUTE_SIZE = 4;
+export const PARTICLE_ATTRIBUTE_SIZE_INITIAL = 11;
 export const PARTICLE_ATTRIBUTE_LAYER_POSITION = 5;
 export const PARTICLE_ATTRIBUTE_VELOCITY = 6;
 export const PARTICLE_ATTRIBUTE_ROTATION = 7;
 export const PARTICLE_ATTRIBUTE_ROTATION_SPEED = 8;
+export const PARTICLE_ATTRIBUTE_COLOR = 9;
+export const PARTICLE_ATTRIBUTE_BLEND = 10;

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

@@ -22,12 +22,14 @@ import { ParticleEmitterFlag } from "./ParticleEmitterFlag.js";
 import { AABB3 } from "../../../../../../core/bvh2/aabb3/AABB3.js";
 import {
     PARTICLE_ATTRIBUTE_AGE,
+    PARTICLE_ATTRIBUTE_BLEND,
     PARTICLE_ATTRIBUTE_DEATH_AGE,
     PARTICLE_ATTRIBUTE_LAYER_POSITION,
     PARTICLE_ATTRIBUTE_POSITION,
     PARTICLE_ATTRIBUTE_ROTATION,
     PARTICLE_ATTRIBUTE_ROTATION_SPEED,
     PARTICLE_ATTRIBUTE_SIZE,
+    PARTICLE_ATTRIBUTE_SIZE_INITIAL,
     PARTICLE_ATTRIBUTE_UV,
     PARTICLE_ATTRIBUTE_VELOCITY
 } from "./PARTICLE_ATTRIBUTES.js";
@@ -39,7 +41,7 @@ import { randomPointInBox } from "../../../../../../core/geom/random/randomPoint
 import { randomPointOnBox } from "../../../../../../core/geom/random/randomPointOnBox.js";
 import { EmissionFromType } from "./EmissionFromType.js";
 import { EmissionShapeType } from "./EmissionShapeType.js";
-
+import { update_parameters } from "../simulator/update_parameters.js";
 
 const EMPTY_GEOMETRY = new BufferGeometry();
 
@@ -635,7 +637,7 @@ export class ParticleEmitter {
 
     build() {
 
-        this.particles = new ParticlePool(particleSpecification);
+        this.particles = new ParticlePool(PARTICULAR_PARTICLE_SPECIFICATION);
 
         //make overallocation a bit more aggressive to prevent frequent resizing
         this.particles.shrinkFactor = 0.5;
@@ -1004,7 +1006,7 @@ export class ParticleEmitter {
             //write particle size
             const size = layer.particleSize.sampleRandom(random);
 
-            particles.writeAttributeScalar(ref, PARTICLE_ATTRIBUTE_SIZE, size);
+            particles.writeAttributeScalar(ref, PARTICLE_ATTRIBUTE_SIZE_INITIAL, size);
 
             //write UV
             const atlasPatch = layer.__atlasPatch;
@@ -1027,6 +1029,10 @@ export class ParticleEmitter {
             }
 
             particles.writeAttributeScalar(ref, PARTICLE_ATTRIBUTE_LAYER_POSITION, layerPosition);
+
+            update_parameters(ref, particles, layer, initialAge / deathAge);
+
+            particles.writeAttributeScalar(ref,PARTICLE_ATTRIBUTE_BLEND,this.blendingMode);
         }
 
         //update time buffer
@@ -1124,7 +1130,7 @@ export class ParticleEmitter {
             //write size
             const size = layer.particleSize.sampleRandom(random);
 
-            particles.writeAttributeScalar(ref, PARTICLE_ATTRIBUTE_SIZE, size);
+            particles.writeAttributeScalar(ref, PARTICLE_ATTRIBUTE_SIZE_INITIAL, size);
 
             //write UV
             const atlasPatch = layer.__atlasPatch;
@@ -1151,6 +1157,9 @@ export class ParticleEmitter {
 
             particles.writeAttributeScalar(ref, PARTICLE_ATTRIBUTE_LAYER_POSITION, layerPosition);
 
+            update_parameters(ref, particles, layer, initialAge / deathAge);
+
+            particles.writeAttributeScalar(ref,PARTICLE_ATTRIBUTE_BLEND,this.blendingMode);
         }
 
         if (spritesNeedUpdate) {
@@ -1253,17 +1262,20 @@ const defaultPointsMaterial = new PointsMaterial({ color: 0xFFFFFF });
 
 
 //build particle spec
-const particleSpecification = new ParticleSpecification();
-
-particleSpecification.add(new ParticleAttribute('position', ParticleAttributeType.Vector3, ParticleDataType.Float32));
-particleSpecification.add(new ParticleAttribute('age', ParticleAttributeType.Scalar, ParticleDataType.Float32));
-particleSpecification.add(new ParticleAttribute('deathAge', ParticleAttributeType.Scalar, ParticleDataType.Float32));
-particleSpecification.add(new ParticleAttribute('atlasPatch', ParticleAttributeType.Vector4, ParticleDataType.Float32));
-particleSpecification.add(new ParticleAttribute('size', ParticleAttributeType.Scalar, ParticleDataType.Float32));
-particleSpecification.add(new ParticleAttribute('layerPosition', ParticleAttributeType.Scalar, ParticleDataType.Float32));
-particleSpecification.add(new ParticleAttribute('velocity', ParticleAttributeType.Vector3, ParticleDataType.Float32));
-particleSpecification.add(new ParticleAttribute('rotation', ParticleAttributeType.Scalar, ParticleDataType.Float32));
-particleSpecification.add(new ParticleAttribute('rotationSpeed', ParticleAttributeType.Scalar, ParticleDataType.Float32));
+export const PARTICULAR_PARTICLE_SPECIFICATION = new ParticleSpecification();
+
+PARTICULAR_PARTICLE_SPECIFICATION.add(new ParticleAttribute('position', ParticleAttributeType.Vector3, ParticleDataType.Float32));
+PARTICULAR_PARTICLE_SPECIFICATION.add(new ParticleAttribute('age', ParticleAttributeType.Scalar, ParticleDataType.Float32));
+PARTICULAR_PARTICLE_SPECIFICATION.add(new ParticleAttribute('deathAge', ParticleAttributeType.Scalar, ParticleDataType.Float32));
+PARTICULAR_PARTICLE_SPECIFICATION.add(new ParticleAttribute('atlasPatch', ParticleAttributeType.Vector4, ParticleDataType.Float32));
+PARTICULAR_PARTICLE_SPECIFICATION.add(new ParticleAttribute('size', ParticleAttributeType.Scalar, ParticleDataType.Float32));
+PARTICULAR_PARTICLE_SPECIFICATION.add(new ParticleAttribute('layerPosition', ParticleAttributeType.Scalar, ParticleDataType.Float32));
+PARTICULAR_PARTICLE_SPECIFICATION.add(new ParticleAttribute('velocity', ParticleAttributeType.Vector3, ParticleDataType.Float32));
+PARTICULAR_PARTICLE_SPECIFICATION.add(new ParticleAttribute('rotation', ParticleAttributeType.Scalar, ParticleDataType.Float32));
+PARTICULAR_PARTICLE_SPECIFICATION.add(new ParticleAttribute('rotationSpeed', ParticleAttributeType.Scalar, ParticleDataType.Float32));
+PARTICULAR_PARTICLE_SPECIFICATION.add(new ParticleAttribute('color', ParticleAttributeType.Vector4, ParticleDataType.Float32));
+PARTICULAR_PARTICLE_SPECIFICATION.add(new ParticleAttribute('blending', ParticleAttributeType.Scalar, ParticleDataType.Uint8));
+PARTICULAR_PARTICLE_SPECIFICATION.add(new ParticleAttribute('size_initial', ParticleAttributeType.Scalar, ParticleDataType.Float32));
 
 
 const frustum = new Frustum();

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

@@ -74,8 +74,10 @@ export class ParticlePool {
         this.occupancy.set(index, true);
 
         //ensure attribute arrays are large enough
-        if (this.capacity < index + 1) {
-            this.growCapacity(index + 1);
+        const min_capacity = index + 1;
+
+        if (this.capacity < min_capacity) {
+            this.growCapacity(min_capacity);
         }
 
         return index;
@@ -86,7 +88,9 @@ export class ParticlePool {
      * @returns {boolean}
      */
     hasHoles() {
-        return this.occupancy.nextClearBit(0) < this.occupancy.size();
+        const occupancy = this.occupancy;
+
+        return occupancy.nextClearBit(0) < occupancy.size();
     }
 
     /**
@@ -111,6 +115,8 @@ export class ParticlePool {
         holeIndex = occupancy.nextClearBit(0);
         lastIndex = occupancy.previousSetBit(occupancy.size());
 
+        const attributes = this.attributes;
+
         while (holeIndex < lastIndex) {
 
             //move occupancy flag from the last to the hole
@@ -119,7 +125,7 @@ export class ParticlePool {
 
             //move attribute values
             for (attributeIndex = 0; attributeIndex < numAttributes; attributeIndex++) {
-                const attribute = this.attributes[attributeIndex];
+                const attribute = attributes[attributeIndex];
 
                 const itemSize = attribute.itemSize;
 
@@ -127,13 +133,13 @@ export class ParticlePool {
                  *
                  * @type {Float32Array}
                  */
-                const oldArray = attribute.array;
+                const attribute_array = attribute.array;
 
                 //do swaps in the old array
                 const targetIndex = holeIndex * itemSize;
                 const sourceIndex = lastIndex * itemSize;
 
-                oldArray.copyWithin(targetIndex, sourceIndex, sourceIndex + itemSize);
+                attribute_array.copyWithin(targetIndex, sourceIndex, sourceIndex + itemSize);
             }
 
             //move hole and last cursors
@@ -269,7 +275,14 @@ export class ParticlePool {
      * @param {number} capacity
      */
     growCapacity(capacity) {
-        const newCapacity = Math.floor(max3(capacity, this.capacity * this.growFactor, this.capacity + GROW_MIN_STEP));
+        const newCapacity = Math.floor(
+            max3(
+                capacity,
+                this.capacity * this.growFactor,
+                this.capacity + GROW_MIN_STEP
+            )
+        );
+
         this.setCapacity(newCapacity);
     }
 
@@ -278,8 +291,13 @@ export class ParticlePool {
      * @param {number} newCapacity
      */
     shrinkCapacity(newCapacity) {
-        if (newCapacity < this.capacity * this.shrinkFactor && newCapacity < this.capacity - SHRINK_THRESHOLD) {
+        if (
+            newCapacity < this.capacity * this.shrinkFactor
+            && newCapacity < this.capacity - SHRINK_THRESHOLD
+        ) {
+
             this.setCapacity(newCapacity);
+
         }
     }
 
@@ -293,8 +311,10 @@ export class ParticlePool {
             return;
         }
 
-        if (newCapacity < this.occupancy.size()) {
-            throw new Error(`Can not set capacity (=${newCapacity}) below occupancy set size (=${this.occupancy.size()})`);
+        const occupancy_size = this.occupancy.size();
+
+        if (newCapacity < occupancy_size) {
+            throw new Error(`Can not set capacity (=${newCapacity}) below occupancy set size (=${occupancy_size})`);
         }
 
         this.capacity = newCapacity;

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

@@ -1,8 +1,5 @@
 import { inverseLerp } from "../../../../../../core/math/inverseLerp.js";
-import {
-    computeHashFloatArray,
-    computeHashIntegerArray
-} from "../../../../../../core/math/MathUtils.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";
@@ -123,11 +120,12 @@ export class ParameterLookupTable {
     /**
      *
      * @param {number} position
-     * @param {number[]} result
+     * @param {number[]|Float32Array|Float64Array} result
      */
     sample(position, result) {
         assert.isNumber(position, 'position');
-        assert.ok(position >= 0 && position <= 1, `position must be between 0 and 1, instead was ${position}`);
+        assert.greaterThanOrEqual(position, 0, 'position');
+        // assert.ok(position >= 0 && position <= 1, `position must be between 0 and 1, instead was ${position}`);
 
         const itemSize = this.itemSize;
         const data = this.data;

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

@@ -37,12 +37,15 @@ ParameterTrackSet.prototype.forEach = function (visitor) {
  */
 ParameterTrackSet.prototype.getTrackByName = function (name) {
     const tracks = this.tracks;
-    const nTracks = tracks.length;
+
+    const tracks_array = tracks.asArray();
+
+    const nTracks = tracks_array.length;
 
     for (let i = 0; i < nTracks; i++) {
-        const parameterTrack = tracks.get(i);
+        const parameterTrack = tracks_array[i];
 
-        if(parameterTrack.name === name){
+        if (parameterTrack.name === name) {
             return parameterTrack;
         }
     }