@woosh/meep-engine 2.41.0 → 2.42.1

package/core/assert.js

@@ -167,8 +167,8 @@ function arrayHasNo(haystack, needle, message = 'Array contains the item') {
 
 /**
  * @template T
- * @param {T[]|ArrayLike<T>|Float32Array} a
- * @param {T[]|ArrayLike<T>|Float32Array} b
+ * @param {T[]|ArrayLike<T>|Float32Array|Int32Array} a
+ * @param {T[]|ArrayLike<T>|Float32Array|Int32Array} b
  * @param {string} [message]
  */
 function arrayEqual(a, b, message = 'Arrays are not equal') {

package/core/collection/array/array_swap.js

@@ -1,8 +1,8 @@
 /**
- *
- * @param {T[]|ArrayLike<T>|TypedArray|Uint8ClampedArray|Uint8Array} a
+ * @template T
+ * @param {T[]|ArrayLike<T>|TypedArray|Uint8ClampedArray|Uint8Array|Float32Array} a
  * @param {number} a_offset
- * @param {T[]|ArrayLike<T>|TypedArray|Uint8ClampedArray|Uint8Array} b
+ * @param {T[]|ArrayLike<T>|TypedArray|Uint8ClampedArray|Uint8Array|Float32Array} b
  * @param {number} b_offset
  * @param {number} length How many elements should be moved
  */

package/core/collection/map/AsyncLoadingCache.js

@@ -0,0 +1,47 @@
+import { AbstractAsyncMap } from "./AbstractAsyncMap.js";
+
+/**
+ * Cache wrapper that loads data when it's not found in the cache
+ */
+export class AsyncLoadingCache extends AbstractAsyncMap {
+    /**
+     *
+     * @param {Map} cache
+     * @param {function(K):Promise<T>} loader
+     */
+    constructor(cache, loader) {
+        super();
+
+        this.__cache = cache;
+        this.__loader = loader;
+        this.__pending = new Map();
+    }
+
+    async get(key) {
+
+        const cached = this.__cache.get(key);
+
+        if (cached !== undefined) {
+            return cached;
+        }
+
+        let promise = this.__pending.get(key);
+        let original_loader = false;
+
+        if (promise === undefined) {
+            promise = this.__loader(key);
+
+            this.__pending.set(key, promise);
+
+            original_loader = true;
+        }
+
+        const value = await promise;
+
+        if (original_loader) {
+            this.__cache.get(key, value);
+        }
+
+        return value;
+    }
+}

package/core/geom/3d/aabb/aabb3_compute_distance_above_plane_max.js

@@ -18,7 +18,7 @@ export function aabb3_computeDistanceAbovePlane_max(
     _x1, _y1, _z1
 ) {
 
-    // pick a corner point nearest along the plane normal
+    // pick a corner point that is the closest along the plane normal
     const px = plane_normal_x > 0 ? _x1 : _x0;
     const py = plane_normal_y > 0 ? _y1 : _y0;
     const pz = plane_normal_z > 0 ? _z1 : _z0;

package/core/geom/3d/apply_mat4_transform_to_v3_array.js

@@ -6,11 +6,9 @@
  * @param {number[]|Float32Array|Float64Array} destination
  * @param {number} destination_offset
  * @param {number} count
- * @param {THREE.Matrix4} matrix
+ * @param {mat4|number[]|Float32Array} mat4
  */
-export function apply_mat4_transform_to_v3_array(source, source_offset, destination, destination_offset, count, matrix) {
-
-    const mat4 = matrix.elements;
+export function apply_mat4_transform_to_v3_array(source, source_offset, destination, destination_offset, count, mat4) {
 
     const a0 = mat4[0];
     const a1 = mat4[1];

package/core/geom/3d/sphere/sphere_radius_sqr_from_v3_array_transformed.js

@@ -0,0 +1,28 @@
+/**
+ *
+ * @param {number[]|ArrayLike<number>} input
+ * @param {number} input_length
+ * @param {ArrayLike<number>|number[]|Float32Array} e 4x4 transformation matrix
+ * @returns {number}
+ */
+export function sphere_radius_sqr_from_v3_array_transformed(input, input_length, e) {
+    let result = 0;
+
+    for (let i = 0; i < input_length; i += 3) {
+        const x = input[i];
+        const y = input[i + 1];
+        const z = input[i + 2];
+
+        const _x = e[0] * x + e[4] * y + e[8] * z + e[12];
+        const _y = e[1] * x + e[5] * y + e[9] * z + e[13];
+        const _z = e[2] * x + e[6] * y + e[10] * z + e[14];
+
+        const l2 = _x * _x + _y * _y + _z * _z;
+
+        if (l2 > result) {
+            result = l2;
+        }
+    }
+
+    return result;
+}

package/core/geom/Quaternion.js

@@ -1705,6 +1705,20 @@ class Quaternion {
         return result;
     }
 
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @returns {Quaternion}
+     */
+    static fromEulerAngles(x, y, z) {
+        const r = new Quaternion();
+
+        r.fromEulerAnglesXYZ(x, y, z);
+
+        return r;
+    }
 
     /**
      * Behaves similarly to Unity's Quaternion `RotateToward` method

package/core/math/statistics/computeSampleSize_Cochran.js

@@ -12,9 +12,9 @@
  *  99%   |  2.57583
  *  99.9% |  3.29053
  *
- * @param z Standard distribution value. # of standard deviations. See statistical tables
- * @param p Fraction of the population with attribute in question. For example if we want to estimate what time people have breakfast and we know that only 30% of people have have breakfast overall, p would be 0.3
- * @param e Error tolerance, 0.05 represents 5% error tolerance
+ * @param {number} z Standard distribution value. # of standard deviations. See statistical tables
+ * @param {number} p Fraction of the population with attribute in question. For example if we want to estimate what time people have breakfast and we know that only 30% of people have have breakfast overall, p would be 0.3
+ * @param {number} e Error tolerance, 0.05 represents 5% error tolerance
  * @returns {number} Sample size
  */
 export function computeSampleSize_Cochran(z, p, e) {

package/editor/ecs/component/editors/geom/QuaternionEditor.js

@@ -1,7 +1,8 @@
 import { TypeEditor } from "../../TypeEditor.js";
 import Vector3 from "../../../../../core/geom/Vector3.js";
-import { DEG2RAD, RAD2DEG } from "three/src/math/MathUtils.js";
 import { makeV3_editor } from "../common/makeV3_editor.js";
+import { DEG_TO_RAD } from "../../../../../core/math/DEG_TO_RAD.js";
+import { RAD_TO_DEG } from "../../../../../core/math/RAD_TO_DEG.js";
 
 export class QuaternionEditor extends TypeEditor {
     build(parent, field, registry) {
@@ -20,7 +21,13 @@ export class QuaternionEditor extends TypeEditor {
             }
 
             lock = true;
-            q.__setFromEuler(euler.x * DEG2RAD, euler.y * DEG2RAD, euler.z * DEG2RAD);
+
+            q.__setFromEuler(
+                euler.x * DEG_TO_RAD,
+                euler.y * DEG_TO_RAD,
+                euler.z * DEG_TO_RAD
+            );
+
             lock = false;
         };
 
@@ -36,9 +43,9 @@ export class QuaternionEditor extends TypeEditor {
             q.toEulerAnglesXYZ(t);
 
             euler.set(
-                t.x * RAD2DEG,
-                t.y * RAD2DEG,
-                t.z * RAD2DEG,
+                t.x * RAD_TO_DEG,
+                t.y * RAD_TO_DEG,
+                t.z * RAD_TO_DEG,
             );
 
             lock = false;

package/engine/Engine.js

@@ -84,7 +84,7 @@ class Engine {
          *
          * @type {ConcurrentExecutor}
          */
-        this.executor = new ConcurrentExecutor(0, 10);
+        this.executor = new ConcurrentExecutor(1, 10);
 
         this.__using_external_entity_manager = entityManager !== undefined;
 
@@ -412,6 +412,9 @@ class Engine {
     start() {
         const self = this;
 
+
+        this.assetManager.startup();
+
         function promiseEntityManager() {
             return new Promise(function (resolve, reject) {
                 //initialize entity manager
@@ -488,6 +491,8 @@ class Engine {
 
 
         // TODO shutdown executor
+
+        await this.assetManager.shutdown();
     }
 
     exit() {

package/engine/EngineBootstrapper.js

@@ -30,7 +30,8 @@ export class EngineBootstrapper {
 
         this.rootNode.appendChild(v.el);
 
-        const started = engine.start();
+        // NOTE: the engine used to be started here, this was moved out
+        const started = Promise.resolve();
 
         const vExecutionEngineState = new LabelView('');
         const vAssetManagerState = new LabelView('');

package/engine/EngineHarness.js

@@ -153,6 +153,7 @@ export class EngineHarness {
      * @param {boolean} [autoClip]
      * @param {number} [distanceMin]
      * @param {number} [distanceMax]
+     * @param {number} [fieldOfView] in degrees
      * @returns {EntityBuilder}
      */
     static buildCamera(
@@ -163,9 +164,10 @@ export class EngineHarness {
             distance = 10,
             pitch = 1.4,
             yaw = 0,
-            autoClip = true,
+            autoClip = false,
             distanceMin = 0,
-            distanceMax = 1000
+            distanceMax = 1000,
+            fieldOfView = 45
         }
     ) {
         const em = engine.entityManager;
@@ -199,6 +201,8 @@ export class EngineHarness {
 
         camera.active.set(true);
         camera.autoClip = autoClip;
+        camera.clip_far = distanceMax;
+        camera.fov.set(fieldOfView);
 
         const entityBuilder = new EntityBuilder();
 
@@ -229,6 +233,8 @@ export class EngineHarness {
      * @param {boolean} [enableWater]
      * @param {boolean} [enableTerrain]
      * @param {boolean} [enableLights=true]
+     * @param {number} [cameraFieldOfView]
+     * @param {number} [cameraFarDistance]
      * @param {boolean} [cameraController=true]
      */
     static async buildBasics({
@@ -244,6 +250,8 @@ export class EngineHarness {
                                  enableWater = true,
                                  enableTerrain = true,
                                  enableLights = true,
+                                 cameraFieldOfView,
+                                 cameraFarDistance,
                                  cameraController = true
                              }) {
 
@@ -256,7 +264,9 @@ export class EngineHarness {
             target: focus,
             pitch,
             yaw,
-            distance
+            distance,
+            fieldOfView: cameraFieldOfView,
+            distanceMax: cameraFarDistance
         });
 
         const cameraEntity = camera.entity;

package/engine/asset/AssetManager.js

@@ -13,6 +13,9 @@ import { CrossOriginConfig } from "./CORS/CrossOriginConfig.js";
 import { array_remove_element } from "../../core/collection/array/array_remove_element.js";
 import { AssetDescription } from "./AssetDescription.js";
 import { noop } from "../../core/function/Functions.js";
+import { Deque } from "../../core/collection/queue/Deque.js";
+import Task from "../../core/process/task/Task.js";
+import { TaskSignal } from "../../core/process/task/TaskSignal.js";
 
 class AssetRequest {
     /**
@@ -68,6 +71,18 @@ class PendingAsset {
     }
 }
 
+class Response {
+    /**
+     *
+     * @param {Asset} asset
+     * @param {AssetRequest} request
+     */
+    constructor(asset, request) {
+        this.asset = asset;
+        this.request = request;
+    }
+}
+
 
 /**
  * @class
@@ -139,6 +154,60 @@ export class AssetManager {
          * @type {boolean}
          */
         this.isAssetManager = true;
+
+        /**
+         *
+         * @type {Deque<Response>}
+         * @private
+         */
+        this.__response_queue = new Deque();
+
+        /**
+         *
+         * @type {Task}
+         * @private
+         */
+        this.__response_processor = new Task({
+            name: "Asset Manager Response processor",
+            cycleFunction: () => {
+                if (this.__response_queue.isEmpty()) {
+                    return TaskSignal.Yield;
+                }
+
+                const response = this.__response_queue.removeFirst();
+
+                this.__process_response(response);
+
+                return TaskSignal.Continue;
+            }
+        });
+
+        this.__is_running = false;
+    }
+
+    startup() {
+        if (this.__is_running) {
+            return;
+        }
+
+        this.__engine.executor.run(this.__response_processor);
+
+        this.__is_running = true;
+    }
+
+    async shutdown(immediate = false) {
+        if (!this.__is_running) {
+            return;
+        }
+
+        if (!immediate) {
+            // wait until all responses have been processed
+            await Promise.allSettled([Task.promise(this.__response_processor)]);
+        }
+
+        this.__engine.executor.removeTask(this.__response_processor);
+
+        this.__is_running = false;
     }
 
     /**
@@ -215,6 +284,30 @@ export class AssetManager {
         this.assets.set(assetDescription, asset);
     }
 
+    /**
+     *
+     * @param {Response} response
+     * @private
+     */
+    __process_response(response) {
+
+        try {
+            response.request.successCallback(response.asset);
+        } catch (e) {
+            console.error("Failed to execute asset success callback", e);
+        }
+    }
+
+    /**
+     *
+     * @param {Asset} asset
+     * @param {AssetRequest} request
+     * @private
+     */
+    __schedule_response(asset, request) {
+        this.__response_queue.add(new Response(asset, request));
+    }
+
     /**
      *
      * @param {string} path
@@ -299,18 +392,15 @@ export class AssetManager {
             //register asset
             assets.set(assetDescription, asset);
 
+            //clear callbacks
+            requestMap.delete(assetDescription);
+
             // process callbacks
             for (let i = 0; i < requests.length; i++) {
                 const request = requests[i];
-                try {
-                    request.successCallback(asset);
-                } catch (e) {
-                    console.error("Failed to execute asset success callback", e);
-                }
+                this.__schedule_response(asset, request);
             }
 
-            //clear callbacks
-            requestMap.delete(assetDescription);
         }
 
         function failure(error) {

package/engine/development/performance/AbstractMetric.js

@@ -17,6 +17,7 @@ export class AbstractMetric {
     /**
      *
      * @param {MetricStatistics} result
+     * @returns {boolean} whether metric was successfully computed or not
      */
     computeStats(result) {
         throw new Error('Not implemented');

package/engine/development/performance/RingBufferMetric.js

@@ -20,16 +20,37 @@ export class RingBufferMetric extends AbstractMetric {
         this.__data.push(value);
     }
 
+    /**
+     *
+     * @param {MetricStatistics} result
+     * @returns {boolean}
+     */
     computeStats(result) {
 
         const buffer = this.__data;
         const array = buffer.data;
         const data_count = buffer.count;
 
-        result.mean = computeStatisticalMean(array, 0, data_count);
-        result.meadian = computeStatisticalPartialMedian(array, 0, data_count);
-        result.max = computeArrayMax(array, 0, data_count);
-        result.min = computeArrayMin(array, 0, data_count);
+        if (data_count === 0) {
+
+            // no data
+            result.mean = 0;
+            result.meadian = 0;
+            result.min = 0;
+            result.max = 0;
+
+            return false;
+
+        } else {
+
+            result.mean = computeStatisticalMean(array, 0, data_count);
+            result.meadian = computeStatisticalPartialMedian(array, 0, data_count);
+            result.max = computeArrayMax(array, 0, data_count);
+            result.min = computeArrayMin(array, 0, data_count);
+
+            return true;
+
+        }
     }
 
     clear() {

package/engine/ecs/EntityBuilder.js

@@ -8,11 +8,30 @@ import { isDefined } from "../../core/process/matcher/Matchers.js";
  * @enum
  */
 export const EntityBuilderFlags = {
+    /**
+     * Whether the entity is built, set internally
+     */
     Built: 1,
-    RegisterComponents: 2
+    /**
+     * If component type is not registered on the {@link EntityComponentDataset} when calling {@link #build} - will register the component first
+     */
+    RegisterComponents: 2,
+    /**
+     * Entity builder will watch destruction of the entity (subscribe to event), this will make the EntityBuilder automatically
+     * recognize when the corresponding entity is destroyed outside the EntityBuilder API
+     * NOTE: useful to turn off to save a bit of memory, as those event listeners take up a bit of space. Feel free to turn this flag off when you don't care to keep the reference to the EntityBuilder
+     */
+    WatchDestruction: 4
 };
 
-const DEFAULT_FLAGS = EntityBuilderFlags.RegisterComponents;
+/**
+ * Set of default flags
+ * @type {number}
+ */
+const DEFAULT_FLAGS =
+    EntityBuilderFlags.RegisterComponents
+    | EntityBuilderFlags.WatchDestruction
+;
 
 /**
  * Representation of an entity, helps build entities and keep track of them without having to access {@link EntityComponentDataset} directly
@@ -53,6 +72,10 @@ class EntityBuilder {
          */
         this.dataset = null;
 
+        /**
+         *
+         * @type {EntityBuilderFlags|number}
+         */
         this.flags = DEFAULT_FLAGS;
 
         /**
@@ -132,7 +155,7 @@ class EntityBuilder {
             throw new Error("Can not add " + componentInstance + " to EntityBuilder");
         }
 
-        assert.notOk(this.hasComponent(Object.getPrototypeOf(componentInstance).constructor) , 'Component of this type already exists');
+        assert.notOk(this.hasComponent(Object.getPrototypeOf(componentInstance).constructor), 'Component of this type already exists');
 
         this.element.push(componentInstance);
 
@@ -378,7 +401,9 @@ class EntityBuilder {
 
         this.setFlag(EntityBuilderFlags.Built);
 
-        dataset.addEntityEventListener(entity, EventType.EntityRemoved, this.__handleEntityDestroyed, this);
+        if (this.getFlag(EntityBuilderFlags.WatchDestruction)) {
+            dataset.addEntityEventListener(entity, EventType.EntityRemoved, this.__handleEntityDestroyed, this);
+        }
 
         this.on.built.send2(entity, dataset);
         return entity;

package/engine/ecs/transform/Transform.js

@@ -63,9 +63,29 @@ export class Transform {
         this.flags = FLAGS_DEFAULT;
 
         // watch changes
-        this.position.onChanged.add(this.__handle_component_change, this);
-        this.rotation.onChanged.add(this.__handle_component_change, this);
-        this.scale.onChanged.add(this.__handle_component_change, this);
+        this.subscribeAllChanges(this.__handle_component_change, this);
+    }
+
+    /**
+     *
+     * @param {function} handler
+     * @param {*} [thisArg]
+     */
+    subscribeAllChanges(handler, thisArg) {
+        this.position.onChanged.add(handler, thisArg);
+        this.rotation.onChanged.add(handler, thisArg);
+        this.scale.onChanged.add(handler, thisArg);
+    }
+
+    /**
+     *
+     * @param {function} handler
+     * @param {*} [thisArg]
+     */
+    unsubscribeAllChanges(handler, thisArg) {
+        this.position.onChanged.remove(handler, thisArg);
+        this.rotation.onChanged.remove(handler, thisArg);
+        this.scale.onChanged.scale(handler, thisArg);
     }
 
     /**

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

@@ -24,6 +24,22 @@ class TopDownCameraControllerSystem extends System {
 
     }
 
+    /**
+     *
+     * @param {TopDownCameraController} ctrl
+     * @param {number} entity
+     * @private
+     */
+    __visit_camera_entity(ctrl, entity){
+        const transform = this.entityManager.dataset.getComponent(entity,Transform);
+
+        if(transform === undefined){
+            return;
+        }
+
+        computeTopDownTransform(ctrl,transform);
+    }
+
     update(timeDelta) {
         const em = this.entityManager;
 
@@ -34,7 +50,7 @@ class TopDownCameraControllerSystem extends System {
         const dataset = em.dataset;
 
         if (this.enabled.get() && dataset !== null) {
-            dataset.traverseEntities([TopDownCameraController, Transform], computeTopDownTransform);
+            dataset.traverseComponents(TopDownCameraController, this.__visit_camera_entity, this);
         }
 
     }

package/engine/graphics/ecs/decal/v2/Decal.d.ts

@@ -0,0 +1,11 @@
+export class Decal {
+    /**
+     * Path to image
+     */
+    uri: string
+
+    /**
+     * Draw order, higher values will be drawn on top of lower values when there's an overlap
+     */
+    priority: number
+}

package/engine/graphics/ecs/decal/v2/Decal.js

@@ -0,0 +1,50 @@
+export class Decal {
+    constructor() {
+        /**
+         * Asset URL
+         * @type {string}
+         */
+        this.uri = "";
+
+        /**
+         * Controls draw order
+         * @type {number}
+         */
+        this.priority = 0;
+
+        /**
+         * Internal transient reference to loaded asset
+         * @type {Sampler2D|null}
+         * @private
+         */
+        this.__cached_sampler = null;
+        /**
+         *
+         * @type {String|null}
+         * @private
+         */
+        this.__cached_uri = null;
+    }
+
+    toJSON() {
+        return {
+            uri: this.uri,
+            priority: this.priority
+        };
+    }
+
+    fromJSON({
+                 uri, priority = 0
+             }) {
+        this.uri = uri;
+        this.priority = priority;
+
+        if (uri !== this.__cached_uri) {
+            // reset sampler
+            this.__cached_sampler = null;
+            this.__cached_uri = null;
+        }
+    }
+}
+
+Decal.typeName = 'Decal';