@woosh/meep-engine 2.42.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/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

@@ -201,6 +201,7 @@ export class EngineHarness {
 
         camera.active.set(true);
         camera.autoClip = autoClip;
+        camera.clip_far = distanceMax;
         camera.fov.set(fieldOfView);
 
         const entityBuilder = new EntityBuilder();
@@ -233,6 +234,7 @@ export class EngineHarness {
      * @param {boolean} [enableTerrain]
      * @param {boolean} [enableLights=true]
      * @param {number} [cameraFieldOfView]
+     * @param {number} [cameraFarDistance]
      * @param {boolean} [cameraController=true]
      */
     static async buildBasics({
@@ -249,6 +251,7 @@ export class EngineHarness {
                                  enableTerrain = true,
                                  enableLights = true,
                                  cameraFieldOfView,
+                                 cameraFarDistance,
                                  cameraController = true
                              }) {
 
@@ -262,7 +265,8 @@ export class EngineHarness {
             pitch,
             yaw,
             distance,
-            fieldOfView: cameraFieldOfView
+            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/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/FPDecalSystem.js

@@ -8,6 +8,8 @@ import { Decal as FPDecal } from '../../../render/forward_plus/model/Decal.js';
 import { AssetManager } from "../../../../asset/AssetManager.js";
 import { Sampler2D } from "../../../texture/sampler/Sampler2D.js";
 import { GameAssetType } from "../../../../asset/GameAssetType.js";
+import { assert } from "../../../../../core/assert.js";
+import { AsyncLoadingCache } from "../../../../../core/collection/map/AsyncLoadingCache.js";
 
 const placeholder_texture = Sampler2D.uint8(4, 1, 1);
 placeholder_texture.data.fill(255);
@@ -65,8 +67,20 @@ class Context extends SystemEntityContext {
             return;
         }
 
+        /**
+         *
+         * @type {FPDecalSystem}
+         */
+        const system = this.system;
+
+        /**
+         * @type {Sampler2D}
+         */
+        const loaded_texture = await system.__texture_cache.get(_uri);
 
-        const loaded_texture = await this.system.internal_loadTexture(_uri);
+        assert.defined(loaded_texture, 'loaded_texture');
+        assert.notNull(loaded_texture, 'loaded_texture');
+        assert.equal(loaded_texture.isSampler2D, true, 'texture.isSampler2D !== true');
 
         decal_spec.__cached_sampler = loaded_texture;
         decal_spec.__cached_uri = _uri;
@@ -147,7 +161,9 @@ export class FPDecalSystem extends AbstractContextSystem {
          * @type {Map<string, Sampler2D>}
          * @private
          */
-        this.__texture_cache = new Map();
+        this.__texture_cache = new AsyncLoadingCache(new Map(), (key) => {
+            return this.__assets.promise(key, GameAssetType.Image).then(asset => asset.create());
+        });
 
         /**
          *
@@ -171,34 +187,6 @@ export class FPDecalSystem extends AbstractContextSystem {
         this.__fp_plugin = Reference.NULL;
     }
 
-    /**
-     *
-     * @param {string} uri
-     * @returns {Promise<void>}
-     */
-    async internal_loadTexture(uri) {
-        const cached = this.__texture_cache.get(uri);
-
-        if (cached !== undefined) {
-            return cached;
-        }
-
-        const asset = await this.__assets.promise(uri, GameAssetType.Image);
-
-        // check cache again, in case another request has succeeded
-        const cached_v2 = this.__texture_cache.get(uri);
-
-        if (cached_v2 !== undefined) {
-            return cached_v2;
-        }
-
-        const sampler = asset.create();
-
-        this.__texture_cache.set(uri, sampler);
-
-        return sampler;
-    }
-
     async startup(em, ready_callback, error_callback) {
         this.__fp_plugin = await this.__engine.plugins.acquire(ForwardPlusRenderingPlugin);