@woosh/meep-engine 2.47.23 → 2.47.26

package/build/meep.module.js

@@ -70580,33 +70580,32 @@ function array_copy_unique(source, source_position, destination, destination_pos
  * @template C
  */
 class System {
-    constructor() {
 
-        /**
-         *
-         * @type {EntityManager}
-         */
-        this.entityManager = null;
+    /**
+     * @protected
+     * @type {EntityManager}
+     */
+    entityManager = null;
 
-        /**
-         *
-         * @type {ObservedValue.<System.State>}
-         */
-        this.state = new ObservedValue(System.State.INITIAL);
+    /**
+     * @readonly
+     * @type {ObservedValue.<System.State>}
+     */
+    state = new ObservedValue(System.State.INITIAL);
 
-        /**
-         * Other components which have to be present before the system links component
-         * @type {Array}
-         */
-        this.dependencies = [];
+    /**
+     * Other components which have to be present before the system links component
+     * @type {Array}
+     */
+    dependencies = [];
+
+    /**
+     * Component types that are used internally by the system
+     * Declaring this helps EntityManager to ensure that all relevant component types are properly registered for the system
+     * @type {Array}
+     */
+    components_used = [];
 
-        /**
-         * Component types that are used internally by the system
-         * Declaring this helps EntityManager to ensure that all relevant component types are properly registered for the system
-         * @type {Array}
-         */
-        this.components_used = [];
-    }
 
     /**
      * @returns {[]}
@@ -70637,15 +70636,22 @@ class System {
 
     }
 
-    /**
-     *
-     * @param {number} timeDelta Time in seconds
-     */
-    update(timeDelta) {
-
-    }
 }
 
+/**
+ * Fixed update function, every step happens with the same exact time increment
+ * useful for systems that must have a fixed time step to be predictable and stable, such as physics
+ * @param {number} timeDelta in seconds
+ */
+System.prototype.fixedUpdate = noop; // by assigning NO-OP we enable a simple check, whether running the update would be useful
+
+
+/**
+ * This update is generally synchronized with the render loop
+ * @param {number} timeDelta Time in seconds
+ */
+System.prototype.update = noop; // by assigning NO-OP we enable a simple check, whether running the update would be useful
+
 Object.defineProperties(System.prototype, {
     /**
      * @deprecated
@@ -70995,6 +71001,113 @@ const ProjectionType = {
     Orthographic: "orthographic"
 };
 
+/**
+ * Created by Alex on 20/02/2017.
+ */
+
+/**
+ *
+ * @param {Vector3} out Result will be written here
+ * @param {number} originX Ray origin
+ * @param {number} originY Ray origin
+ * @param {number} originZ Ray origin
+ * @param {number} directionX Ray direction
+ * @param {number} directionY Ray direction
+ * @param {number} directionZ Ray direction
+ * @param {number} normalX Plane normal
+ * @param {number} normalY Plane normal
+ * @param {number} normalZ Plane normal
+ * @param {number} dist Plane distance
+ * @returns {boolean} true if intersection is found, false otherwise
+ */
+function computePlaneRayIntersection(out, originX, originY, originZ, directionX, directionY, directionZ, normalX, normalY, normalZ, dist) {
+    const denom = v3_dot(directionX, directionY, directionZ, normalX, normalY, normalZ);
+
+    const p = v3_dot(normalX, normalY, normalZ, originX, originY, originZ) + dist;
+
+    if (denom !== 0) {
+
+        const t = -p / denom;
+
+        if (t < 0) {
+            return false;
+        }
+
+        out.set(
+            directionX * t + originX,
+            directionY * t + originY,
+            directionZ * t + originZ
+        );
+
+        return true;
+
+    } else {
+
+        if (p === 0) {
+
+            out.set(originX, originY, originZ);
+
+            return true;
+
+        } else {
+
+            //no intersection
+            return false;
+
+        }
+
+    }
+}
+
+/**
+ *
+ * @param {Float32Array|number[]|vec3} result
+ * @param {number} result_offset
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {number} normalX
+ * @param {number} normalY
+ * @param {number} normalZ
+ * @param {number} dist
+ * @returns {boolean}
+ */
+function plane3_computeLineSegmentIntersection(
+    result, result_offset,
+    x0, y0, z0,
+    x1, y1, z1,
+    normalX, normalY, normalZ, dist
+) {
+
+    const directionX = x1 - x0;
+    const directionY = y1 - y0;
+    const directionZ = z1 - z0;
+
+    const denom = v3_dot(directionX, directionY, directionZ, normalX, normalY, normalZ);
+
+    if (denom === 0) {
+        return false;
+    }
+
+    const p = v3_dot(normalX, normalY, normalZ, x0, y0, z0) + dist;
+
+    const t = -p / denom;
+
+    if (t < 0 || t > 1) {
+        return false;
+    }
+
+    result[result_offset] = directionX * t + x0;
+    result[result_offset + 1] = directionY * t + y0;
+    result[result_offset + 2] = directionZ * t + z0;
+
+    return true;
+
+}
+
 /**
  * Created by Alex on 31/12/2014.
  */
@@ -71206,6 +71319,42 @@ class Camera {
         return true;
     }
 
+    /**
+     *
+     * @param {Vector3} out
+     * @param {number} origin_x
+     * @param {number} origin_y
+     * @param {number} origin_z
+     * @param {number} direction_x
+     * @param {number} direction_y
+     * @param {number} direction_z
+     * @param {number} plane_index
+     */
+    rayPlaneIntersection(
+        out,
+        origin_x, origin_y, origin_z,
+        direction_x, direction_y, direction_z,
+        plane_index
+    ) {
+
+        assert.isNonNegativeInteger(plane_index, 'plane_index');
+        assert.lessThanOrEqual(plane_index, 5, `plane_index must be <= 5, was ${plane_index}`);
+
+        frustum_from_camera(this.object, scratch_frustum$1);
+
+        const plane = scratch_frustum$1.planes[plane_index];
+
+        assert.defined(plane, 'plane');
+
+        computePlaneRayIntersection(
+            out,
+            origin_x, origin_y, origin_z,
+            direction_x, direction_y, direction_z,
+            plane.normal.x, plane.normal.y, plane.normal.z,
+            plane.constant
+        );
+    }
+
     /**
      *
      * @param {number} x
@@ -73859,26 +74008,25 @@ const EntityManagerState = {
  */
 function EntityManager() {
     /**
-     *
-     * @type {Array.<System>}
+     * @readonly
+     * @type {System[]}
      */
     this.systems = [];
 
     /**
-     *
-     * @type {Array<EntityObserver>}
+     * @readonly
+     * @type {EntityObserver[]}
      */
     this.systemObservers = [];
 
+    /**
+     * @readonly
+     */
     this.on = {
         systemStarted: new Signal(),
         systemStopped: new Signal(),
         systemAdded: new Signal(),
         systemRemoved: new Signal(),
-        /**
-         * @deprecated
-         */
-        reset: new Signal()
     };
 
     /**
@@ -73887,6 +74035,19 @@ function EntityManager() {
      */
     this.state = EntityManagerState.Initial;
 
+    /**
+     * @private
+     * @readonly
+     * @type {Map<System, number>}
+     */
+    this.systemAccumulatedFixedStepTime = new Map();
+
+    /**
+     * In seconds
+     * @type {number}
+     */
+    this.fixedUpdateStepSize = 0.015;
+
     /**
      *
      * @type {EntityComponentDataset}
@@ -73961,170 +74122,6 @@ EntityManager.prototype.attachDataSet = function (dataset) {
     });
 };
 
-/**
- * @deprecated
- * @returns {number}
- */
-EntityManager.prototype.createEntity = function () {
-    console.warn("EntityManager.createEntity is deprecated");
-
-    return this.dataset.createEntity();
-};
-
-/**
- * @deprecated
- * @param id
- */
-EntityManager.prototype.createEntitySpecific = function (id) {
-    console.warn("EntityManager.createEntitySpecific is deprecated");
-    this.dataset.createEntitySpecific(id);
-};
-
-
-/**
- * @deprecated
- * Remove association of specified component type from entity
- * @param {Number} entityId
- * @param {Number} componentType
- */
-EntityManager.prototype.removeComponentFromEntity = function (entityId, componentType) {
-    console.warn("EntityManager.removeComponentFromEntity is deprecated");
-
-    this.dataset.removeComponentFromEntityByIndex(entityId, componentType);
-};
-
-/**
- * @deprecated use dataset directly
- * Retrieves component instance associated with entity
- * @template T
- * @param {Number} entityId
- * @param {class.<T>} componentClass
- * @returns {T|null}
- * @nosideeffects
- */
-EntityManager.prototype.getComponent = function (entityId, componentClass) {
-    return this.dataset.getComponent(entityId, componentClass);
-};
-
-/**
- *
- * @param {number} entityIndex
- * @returns {boolean}
- */
-EntityManager.prototype.entityExists = function (entityIndex) {
-    if (this.dataset === null) {
-        //no dataset - no entities
-        return false;
-    }
-    return this.dataset.entityExists(entityIndex);
-};
-
-/**
- * same as getComponent when component exists, if component is not associated with the entity, callback will be invoked once when it is added.
- * @param {Number} entityId
- * @param {Class} componentClass
- * @param {function} callback
- * @param {*} [thisArg]
- */
-EntityManager.prototype.getComponentAsync = function (entityId, componentClass, callback, thisArg) {
-    const self = this;
-    const component = this.getComponent(entityId, componentClass);
-
-    function handler(options) {
-        if (options.klass === componentClass) {
-            self.removeEntityEventListener(entityId, EventType.ComponentAdded, handler);
-            callback.call(thisArg, options.instance);
-        }
-    }
-
-    if (component === void 0 || component === null) {
-        this.addEntityEventListener(entityId, EventType.ComponentAdded, handler);
-    } else {
-        callback.call(thisArg, component);
-    }
-};
-
-/**
- * @deprecated Use {@link EntityManager#dataset} direction
- * @param entity
- * @returns {Array}
- */
-EntityManager.prototype.getComponents = function (entity) {
-    console.warn("EntityManager.getComponents is deprecated");
-
-    return this.dataset.getAllComponents(entity);
-};
-
-/**
- * @deprecated
- * Retrieves component instance associated with entity
- * @param {Number} entityId
- * @param {Number} componentType
- * @returns {*|undefined} component of specified type or undefined if it was not found
- */
-EntityManager.prototype.getComponentByType = function (entityId, componentType) {
-    console.warn("EntityManager.getComponentByType is deprecated");
-    return this.dataset.getComponentByIndex(entityId, componentType);
-};
-
-/**
- * @deprecated
- * does traversal on a subset of entities which have specified components.
- * @example traverseEntities([Transform,Renderable,Tag],function(transform, renderable, tag, entity){ ... }, this);
- * @param {Array.<class>} classes
- * @param {Function} callback
- * @param {Object} [thisArg] specifies context object on which callbacks are to be called, optional
- */
-EntityManager.prototype.traverseEntities = function (classes, callback, thisArg) {
-    if (this.dataset === null) {
-        //no data to traverse
-        return;
-    }
-    this.dataset.traverseEntities(classes, callback, thisArg);
-};
-
-/**
- * @deprecated
- * @param entity
- * @param eventName
- * @param listener
- */
-EntityManager.prototype.addEntityEventListener = function (entity, eventName, listener) {
-    this.dataset.addEntityEventListener(entity, eventName, listener);
-};
-
-/**
- * @deprecated
- * @param {number} entity
- * @param {string} eventName
- * @param {function} listener
- */
-EntityManager.prototype.removeEntityEventListener = function (entity, eventName, listener) {
-    this.dataset.removeEntityEventListener(entity, eventName, listener);
-};
-
-/**
- * @deprecated use dataset directly instead
- * @param entity
- * @param eventName
- * @param event
- */
-EntityManager.prototype.sendEvent = function (entity, eventName, event) {
-    this.dataset.sendEvent(entity, eventName, event);
-};
-
-/**
- * @deprecated
- * @param {function} klazz
- * @param {function(component: *, entity: number):boolean} callback
- * @param {*} [thisArg]
- * @deprecated
- */
-EntityManager.prototype.traverseComponents = function (klazz, callback, thisArg) {
-    if (this.dataset !== null) {
-        this.dataset.traverseComponents(klazz, callback, thisArg);
-    }
-};
 
 /**
  * @template T
@@ -74156,33 +74153,6 @@ EntityManager.prototype.getSystem = function (systemClass) {
     return null;
 };
 
-/**
- * @deprecated Use {@link #getSystem} instead
- * @template T,C
- * @param {C} klazz
- * @returns {System|T}
- */
-EntityManager.prototype.getOwnerSystemByComponentClass = function (klazz) {
-    const index = this.getOwnerSystemIdByComponentClass(klazz);
-    return this.systems[index];
-};
-
-/**
- * @deprecated
- * @param {function} clazz
- * @returns {number} value >= 0, representing system Id, or -1 if system was not found
- */
-EntityManager.prototype.getOwnerSystemIdByComponentClass = function (clazz) {
-    const systems = this.systems;
-    let i = 0;
-    const l = systems.length;
-    for (; i < l; i++) {
-        if (systems[i].componentClass === clazz) {
-            return i;
-        }
-    }
-    return -1;
-};
 
 /**
  * @template T
@@ -74204,19 +74174,6 @@ EntityManager.prototype.getComponentClassByName = function (className) {
     return null;
 };
 
-/**
- *
- * @param {System} system
- * @param {number} timeDelta
- */
-function tryUpdateSystem(system, timeDelta) {
-    try {
-        system.update(timeDelta);
-    } catch (e) {
-        console.error(`Failed to update system '${computeSystemName(system)}': `, e);
-    }
-}
-
 /**
  * Advance simulation forward by a specified amount of time
  * @param {number} timeDelta in seconds, real number
@@ -74226,12 +74183,51 @@ EntityManager.prototype.simulate = function (timeDelta) {
     assert.notNaN(timeDelta, 'timeDelta');
     assert.greaterThanOrEqual(timeDelta, 0, 'timeDelta must be >= 0');
 
+    /**
+     *
+     * @type {System[]}
+     */
     const systems = this.systems;
-    let i = 0;
-    const l = systems.length;
-    for (; i < l; i++) {
+
+    const system_count = systems.length;
+
+    const fixed_step = this.fixedUpdateStepSize;
+    const accumulatedTime = this.systemAccumulatedFixedStepTime;
+
+    for (let i = 0; i < system_count; i++) {
+
         const system = systems[i];
-        tryUpdateSystem(system, timeDelta);
+
+        if (system.fixedUpdate !== noop) {
+            let accumulated_time = accumulatedTime.get(system) + timeDelta;
+
+
+            while (accumulated_time > fixed_step) {
+
+                try {
+                    system.fixedUpdate(fixed_step);
+                } catch (e) {
+                    console.error(`Failed during fixedUpdate of system '${computeSystemName(system)}': `, e);
+                }
+
+                accumulated_time -= fixed_step;
+            }
+
+            // record whatever remains
+            accumulatedTime.set(system, accumulated_time);
+
+        }
+
+        if (system.update !== noop) {
+
+            try {
+                system.update(timeDelta);
+            } catch (e) {
+                console.error(`Failed during update of system '${computeSystemName(system)}': `, e);
+            }
+
+        }
+
     }
 };
 
@@ -74354,6 +74350,8 @@ EntityManager.prototype.addSystem = async function (system) {
         this.dataset.addObserver(linkObserver);
     }
 
+    this.systemAccumulatedFixedStepTime.set(system, 0);
+
     this.on.systemAdded.send1(system);
 
     await startup_promise;
@@ -74397,6 +74395,8 @@ EntityManager.prototype.removeSystem = async function (system) {
         });
     });
 
+    this.systemAccumulatedFixedStepTime.delete(system);
+
     this.on.systemRemoved.send1(system);
 };
 
@@ -74695,17 +74695,208 @@ EntityManager.prototype.shutdown = function (readyCallback, errorCallback) {
     });
 };
 
+
+/**
+ * @deprecated
+ * @returns {number}
+ */
+EntityManager.prototype.createEntity = function () {
+    console.warn("EntityManager.createEntity is deprecated");
+
+    return this.dataset.createEntity();
+};
+
+/**
+ * @deprecated
+ * @param id
+ */
+EntityManager.prototype.createEntitySpecific = function (id) {
+    console.warn("EntityManager.createEntitySpecific is deprecated");
+    this.dataset.createEntitySpecific(id);
+};
+
+
+/**
+ * @deprecated
+ * Remove association of specified component type from entity
+ * @param {Number} entityId
+ * @param {Number} componentType
+ */
+EntityManager.prototype.removeComponentFromEntity = function (entityId, componentType) {
+    console.warn("EntityManager.removeComponentFromEntity is deprecated");
+
+    this.dataset.removeComponentFromEntityByIndex(entityId, componentType);
+};
+
+/**
+ * @deprecated use dataset directly
+ * Retrieves component instance associated with entity
+ * @template T
+ * @param {Number} entityId
+ * @param {class.<T>} componentClass
+ * @returns {T|null}
+ * @nosideeffects
+ */
+EntityManager.prototype.getComponent = function (entityId, componentClass) {
+    console.warn("EntityManager.getComponent is deprecated");
+
+    return this.dataset.getComponent(entityId, componentClass);
+};
+
+/**
+ * @deprecated use {@link EntityComponentDataset.entityExists} instead
+ * @param {number} entityIndex
+ * @returns {boolean}
+ */
+EntityManager.prototype.entityExists = function (entityIndex) {
+    console.warn("EntityManager.entityExists is deprecated");
+    if (this.dataset === null) {
+        //no dataset - no entities
+        return false;
+    }
+    return this.dataset.entityExists(entityIndex);
+};
+
+
+/**
+ * @deprecated Use {@link EntityManager#dataset} direction
+ * @param entity
+ * @returns {Array}
+ */
+EntityManager.prototype.getComponents = function (entity) {
+    console.warn("EntityManager.getComponents is deprecated");
+
+    return this.dataset.getAllComponents(entity);
+};
+
+/**
+ * @deprecated
+ * Retrieves component instance associated with entity
+ * @param {Number} entityId
+ * @param {Number} componentType
+ * @returns {*|undefined} component of specified type or undefined if it was not found
+ */
+EntityManager.prototype.getComponentByType = function (entityId, componentType) {
+    console.warn("EntityManager.getComponentByType is deprecated");
+    return this.dataset.getComponentByIndex(entityId, componentType);
+};
+
+/**
+ * @deprecated
+ * does traversal on a subset of entities which have specified components.
+ * @example traverseEntities([Transform,Renderable,Tag],function(transform, renderable, tag, entity){ ... }, this);
+ * @param {Array.<class>} classes
+ * @param {Function} callback
+ * @param {Object} [thisArg] specifies context object on which callbacks are to be called, optional
+ */
+EntityManager.prototype.traverseEntities = function (classes, callback, thisArg) {
+    console.warn("EntityManager.traverseEntities is deprecated");
+
+    if (this.dataset === null) {
+        //no data to traverse
+        return;
+    }
+    this.dataset.traverseEntities(classes, callback, thisArg);
+};
+
+/**
+ * @deprecated
+ * @param entity
+ * @param eventName
+ * @param listener
+ */
+EntityManager.prototype.addEntityEventListener = function (entity, eventName, listener) {
+    console.warn("EntityManager.addEntityEventListener is deprecated");
+    this.dataset.addEntityEventListener(entity, eventName, listener);
+};
+
 /**
  * @deprecated
+ * @param {number} entity
+ * @param {string} eventName
+ * @param {function} listener
+ */
+EntityManager.prototype.removeEntityEventListener = function (entity, eventName, listener) {
+    console.warn("EntityManager.removeEntityEventListener is deprecated");
+    this.dataset.removeEntityEventListener(entity, eventName, listener);
+};
+
+/**
+ * @deprecated use dataset directly instead
+ * @param entity
+ * @param eventName
+ * @param event
+ */
+EntityManager.prototype.sendEvent = function (entity, eventName, event) {
+    console.warn("EntityManager.sendEvent is deprecated");
+    this.dataset.sendEvent(entity, eventName, event);
+};
+
+/**
+ * @deprecated
+ * @param {function} klazz
+ * @param {function(component: *, entity: number):boolean} callback
+ * @param {*} [thisArg]
+ * @deprecated
+ */
+EntityManager.prototype.traverseComponents = function (klazz, callback, thisArg) {
+    console.warn("EntityManager.traverseComponents is deprecated");
+    if (this.dataset !== null) {
+        this.dataset.traverseComponents(klazz, callback, thisArg);
+    }
+};
+
+/**
+ * @deprecated Use {@link #getSystem} instead
+ * @template T,C
+ * @param {C} klazz
+ * @returns {System|T}
+ */
+EntityManager.prototype.getOwnerSystemByComponentClass = function (klazz) {
+
+    console.warn("EntityManager.getOwnerSystemByComponentClass is deprecated, use .getSystem instead");
+    const index = this.getOwnerSystemIdByComponentClass(klazz);
+    return this.systems[index];
+};
+
+/**
+ * @deprecated
+ * @param {function} clazz
+ * @returns {number} value >= 0, representing system Id, or -1 if system was not found
+ */
+EntityManager.prototype.getOwnerSystemIdByComponentClass = function (clazz) {
+    console.warn("EntityManager.getOwnerSystemIdByComponentClass is deprecated, use .getSystem instead");
+
+    const systems = this.systems;
+    let i = 0;
+    const l = systems.length;
+    for (; i < l; i++) {
+        if (systems[i].componentClass === clazz) {
+            return i;
+        }
+    }
+    return -1;
+};
+
+
+/**
+ * same as getComponent when component exists, if component is not associated with the entity, callback will be invoked once when it is added.
+ * @param {Number} entityId
+ * @param {Class} componentClass
+ * @param {function} callback
+ * @param {*} [thisArg]
  */
-EntityManager.prototype.reset = function () {
-    console.warn("EntityManager.reset is deprecated and should no longer be used, reset dataset instead");
+EntityManager.prototype.getComponentAsync = function (entityId, componentClass, callback, thisArg) {
+    console.warn("EntityManager.getComponentAsync is deprecated");
 
-    this.dataset.clear();
+    const dataset = this.dataset;
 
-    this.on.reset.send0();
+    if (dataset === undefined) {
+        throw new Error('No dataset attached');
+    }
+
+    dataset.getComponentAsync(entityId, componentClass, callback, thisArg);
 
-    console.log("Entity Manager completed reset");
 };
 
 /**
@@ -86587,59 +86778,6 @@ function aabb_build_frustum(result, x0, y0, z0, x1, y1, z1) {
     result[23] = z1;
 }
 
-/**
- * Created by Alex on 20/02/2017.
- */
-
-/**
- *
- * @param {Float32Array|number[]|vec3} result
- * @param {number} result_offset
- * @param {number} x0
- * @param {number} y0
- * @param {number} z0
- * @param {number} x1
- * @param {number} y1
- * @param {number} z1
- * @param {number} normalX
- * @param {number} normalY
- * @param {number} normalZ
- * @param {number} dist
- * @returns {boolean}
- */
-function plane3_computeLineSegmentIntersection(
-    result, result_offset,
-    x0, y0, z0,
-    x1, y1, z1,
-    normalX, normalY, normalZ, dist
-) {
-
-    const directionX = x1 - x0;
-    const directionY = y1 - y0;
-    const directionZ = z1 - z0;
-
-    const denom = v3_dot(directionX, directionY, directionZ, normalX, normalY, normalZ);
-
-    if (denom === 0) {
-        return false;
-    }
-
-    const p = v3_dot(normalX, normalY, normalZ, x0, y0, z0) + dist;
-
-    const t = -p / denom;
-
-    if (t < 0 || t > 1) {
-        return false;
-    }
-
-    result[result_offset] = directionX * t + x0;
-    result[result_offset + 1] = directionY * t + y0;
-    result[result_offset + 2] = directionZ * t + z0;
-
-    return true;
-
-}
-
 /**
  * Bitfields, mapping a corner index to bitfield with attached edges
  * @type {number[]}
@@ -95869,7 +96007,7 @@ GraphicsEngine.prototype.start = function () {
         /**
          * @see https://registry.khronos.org/webgl/specs/latest/1.0/#5.2
          */
-        powerPreference:"high-performance"
+        powerPreference: "high-performance"
     };
 
     const webGLRenderer = this.renderer = new WebGLRenderer(rendererParameters);
@@ -96000,8 +96138,9 @@ GraphicsEngine.prototype.normalizeViewportPoint = function (input, result) {
 
     const viewportSize = this.viewport.size;
 
-    const _x = input.x;
-    const _y = input.y;
+    // shift by pixel center
+    const _x = input.x + 0.5;
+    const _y = input.y + 0.5;
 
     result.x = (_x / viewportSize.x) * 2 - 1;
     result.y = -(_y / viewportSize.y) * 2 + 1;
@@ -96323,6 +96462,27 @@ const TouchEvents = {
     Cancel: "touchcancel",
 };
 
+/**
+ * Representation of an input device key
+ */
+class InputDeviceSwitch {
+    /**
+     * Button press
+     * @type {Signal}
+     */
+    down = new Signal()
+    /**
+     * Button release
+     * @type {Signal}
+     */
+    up = new Signal()
+    /**
+     * is button currently being pressed?
+     * @type {boolean}
+     */
+    is_down = false
+}
+
 /**
  * Created by Alex on 29/01/2015.
  */
@@ -96689,6 +96849,13 @@ class PointerDevice {
      */
     isRunning = false;
 
+    /**
+     * The MouseEvent.buttons is a 32bit field, which means we can encode up to 32 buttons
+     * @readonly
+     * @type {InputDeviceSwitch[]}
+     */
+    buttons = new Array(32);
+
     /**
      *
      * @param {EventTarget} domElement html element
@@ -96697,6 +96864,10 @@ class PointerDevice {
     constructor(domElement) {
         assert.defined(domElement, "domElement");
 
+        // initialize buttons
+        for (let i = 0; i < this.buttons.length; i++) {
+            this.buttons[i] = new InputDeviceSwitch();
+        }
 
         /**
          *
@@ -96738,6 +96909,16 @@ class PointerDevice {
     #eventHandlerMouseDown = (event) => {
         this.readPointerPositionFromEvent(this.position, event);
         this.on.down.send2(this.position, event);
+
+        // update button state and dispatch specific signal
+        const button_index = event.button;
+
+        const button = this.buttons[button_index];
+
+        if (button !== undefined) {
+            button.is_down = true;
+            button.down.send0();
+        }
     }
 
     /**
@@ -96765,6 +96946,16 @@ class PointerDevice {
     #eventHandlerGlobalMouseUp = (event) => {
         this.readPointerPositionFromEvent(this.position, event);
         this.#globalUp.send2(this.position, event);
+
+        // update button state and dispatch specific signal
+        const button_index = event.button;
+
+        const button = this.buttons[button_index];
+
+        if (button !== undefined) {
+            button.is_down = false;
+            button.up.send0();
+        }
     }
 
     /**
@@ -96955,27 +97146,6 @@ const KeyboardEvents = {
     KeyDown: 'keydown'
 };
 
-/**
- * Representation of an input device key
- */
-class InputDeviceSwitch {
-    /**
-     * Button press
-     * @type {Signal}
-     */
-    down = new Signal()
-    /**
-     * Button release
-     * @type {Signal}
-     */
-    up = new Signal()
-    /**
-     * is button currently being pressed?
-     * @type {boolean}
-     */
-    is_down = false
-}
-
 /**
  * Created by Alex on 06/03/2017.
  */
@@ -98373,10 +98543,35 @@ class EntityComponentDataset {
     }
 
     /**
-     *
+     * same as getComponent when component exists, if component is not associated with the entity, callback will be invoked once when it is added.
+     * @param {Number} entityId
+     * @param {Class} componentClass
+     * @param {function} callback
+     * @param {*} [thisArg]
+     */
+    getComponentAsync (entityId, componentClass, callback, thisArg) {
+        const component = this.getComponent(entityId, componentClass);
+
+        const handler = (options) => {
+            if (options.klass === componentClass) {
+                this.removeEntityEventListener(entityId, EventType.ComponentAdded, handler);
+                callback.call(thisArg, options.instance);
+            }
+        };
+
+        if (component === undefined) {
+            this.addEntityEventListener(entityId, EventType.ComponentAdded, handler);
+        } else {
+            callback.call(thisArg, component);
+        }
+    };
+
+    /**
+     * Performs traversal on a subset of entities which have specified components.
+     * @example traverseEntities([Transform,Renderable,Tag],function(transform, renderable, tag, entity){ ... }, this);
      * @param {Array} classes
      * @param {function:boolean?} visitor Visitor can return optional "false" to terminate traversal earlier
-     * @param {object} [thisArg]
+     * @param {object} [thisArg] specifies context object on which callbacks are to be called, optional
      */
     traverseEntities(classes, visitor, thisArg) {
 
@@ -98452,7 +98647,7 @@ class EntityComponentDataset {
     }
 
     /**
-     * does traversal on a subset of entities which have only the specified components and no others
+     * Performs traversal on a subset of entities which have only the specified components and no others
      * @example traverseEntitiesExact([Transform,Renderable,Tag],function(transform, renderable, tag, entity){ ... }, this);
      * @param {Array.<class>} classes
      * @param {Function} visitor
@@ -99858,7 +100053,7 @@ class RepeatBehavior extends AbstractDecoratorBehavior {
          * @type {number}
          * @private
          */
-        this.__limit = count;
+        this.limit = count;
 
         /**
          *
@@ -99871,19 +100066,19 @@ class RepeatBehavior extends AbstractDecoratorBehavior {
     }
 
     /**
-     *
+     * @deprecated use .limit directly instead
      * @param {number} v
      */
     setCount(v) {
-        this.__limit = v;
+        this.limit = v;
     }
 
     /**
-     *
+     * @deprecated use .limit directly instead
      * @return {number}
      */
     getCount() {
-        return this.__limit;
+        return this.limit;
     }
 
     /**
@@ -99896,8 +100091,17 @@ class RepeatBehavior extends AbstractDecoratorBehavior {
         return new RepeatBehavior(source, count);
     }
 
+    initialize(context) {
+        super.initialize(context);
+
+        // reset iterator
+        this.__iterator = 0;
+    }
+
     tick(timeDelta) {
-        const s = this.__source.tick(timeDelta);
+        const source = this.__source;
+
+        const s = source.tick(timeDelta);
 
         assert.enum(s, BehaviorStatus, 'status');
 
@@ -99908,12 +100112,12 @@ class RepeatBehavior extends AbstractDecoratorBehavior {
 
         this.__iterator++;
 
-        if (this.__iterator >= this.__limit) {
+        if (this.__iterator >= this.limit) {
 
             return BehaviorStatus.Succeeded;
         } else {
             //re-initialize the source behavior
-            this.__source.initialize(this.context);
+            source.initialize(this.context);
 
             return BehaviorStatus.Running;
         }
@@ -123976,7 +124180,7 @@ function makeAlexWaterMaterial() {
  * @param {function(terrain:Terrain,entity:number)} [callback]
  * @returns {Terrain|null}
  */
-function obtainTerrain(ecd, callback) {
+function obtainTerrain(ecd, callback=noop) {
     assert.notEqual(ecd, null, 'ecd is null');
     assert.notEqual(ecd, undefined, 'ecd is undefined');
 
@@ -123984,9 +124188,7 @@ function obtainTerrain(ecd, callback) {
 
     const terrain = object.component;
 
-    if (terrain !== null && typeof callback === "function") {
         callback(terrain, object.entity);
-    }
 
     return terrain;
 }