@woosh/meep-engine 2.34.6 → 2.34.10

package/core/assert.js

@@ -268,7 +268,10 @@ assert.isFunction = function (value, name = 'value') {
  */
 assert.isNonNegativeInteger = function (value, name = 'value') {
     assert.isNumber(value, name);
-    assert.greaterThanOrEqual(value, 0, `${name} must be >= 0, instead was ${value}`);
+
+    if (value < 0) {
+        throw new Error(`${name} must be >= 0, instead was ${value}`);
+    }
 
     if (!Number.isInteger(value)) {
         throw new Error(`${name} must be an integer, instead was ${value}`);

package/core/binary/BitSet.js

@@ -472,11 +472,11 @@ BitSet.prototype.get = function (bitIndex) {
     const byteOffset = bitIndex >> 5;
     const bitOffset = bitIndex & 31;
 
-    const byte = this.__data_uint32[byteOffset];
+    const word = this.__data_uint32[byteOffset];
 
-    const maskedValue = byte & (1 << bitOffset);
+    const masked_word = word & (1 << bitOffset);
 
-    return maskedValue !== 0;
+    return masked_word !== 0;
 };
 
 /**

package/core/process/executor/ConcurrentExecutor.d.ts

@@ -0,0 +1,12 @@
+import Task from "../task/Task";
+import TaskGroup from "../task/TaskGroup";
+
+export default class ConcurrentExecutor {
+    constructor(quietTime: number, workTime: number)
+
+    runGroup(t: TaskGroup): void
+
+    run(t: Task): void
+
+    runMany(tasks: Task[]): void
+}

package/core/process/task/ITask.d.ts

@@ -0,0 +1,18 @@
+import Signal from "../../events/signal/Signal";
+
+export abstract class ITask {
+    readonly name: string
+    readonly on: {
+        started: Signal,
+        completed: Signal,
+        failed: Signal
+    }
+
+    promise(): Promise<void>
+
+    getExecutedCpuTime(): number
+
+    getEstimatedDuration(): number
+
+    computeProgress(): number
+}

package/core/process/task/Task.d.ts

@@ -0,0 +1,5 @@
+import {ITask} from "./ITask";
+
+export default class Task extends ITask {
+    readonly isTask:boolean
+}

package/core/process/task/TaskGroup.d.ts

@@ -0,0 +1,5 @@
+import {ITask} from "./ITask";
+
+export default class TaskGroup extends ITask{
+
+}

package/engine/Engine.d.ts

@@ -9,6 +9,7 @@ import {EntityManager} from "./ecs/EntityManager";
 import View from "../view/View";
 import Ticker from "./simulation/Ticker";
 import {EnginePluginManager} from "./plugin/EnginePluginManager";
+import ConcurrentExecutor from "../core/process/executor/ConcurrentExecutor";
 
 export interface IEngineInitializationOptions {
     entityManager?: EntityManager
@@ -27,6 +28,7 @@ export default class Engine {
     public readonly assetManager: AssetManager
     public readonly ticker: Ticker
     public readonly plugins: EnginePluginManager
+    public readonly executor: ConcurrentExecutor
 
     public start(): Promise<any>
 

package/engine/Engine.js

@@ -82,6 +82,12 @@ class Engine {
          */
         this.performance = new MetricCollection();
 
+        /**
+         *
+         * @type {ConcurrentExecutor}
+         */
+        this.executor = new ConcurrentExecutor(0, 10);
+
         this.__using_external_entity_manager = entityManager !== undefined;
 
         //setup entity component system
@@ -179,7 +185,6 @@ class Engine {
 
         this.settings = new EngineSettings();
 
-        this.executor = new ConcurrentExecutor(0, 10);
 
         this.services = {
             compression: new CompressionService()

package/engine/asset/AssetManager.d.ts

@@ -6,17 +6,19 @@ import {AssetTransformer} from "./AssetTransformer";
 export class AssetManager {
     public readonly crossOriginConfig: CrossOriginConfig
 
-    public promise<T>(path: string, type: string): Promise<Asset<T>>
+    promise<T>(path: string, type: string): Promise<Asset<T>>
 
-    public remove(path: string, type: string): boolean
+    remove(path: string, type: string): boolean
 
-    public clear(): void
+    clear(): void
 
-    public registerLoader<T>(type: string, loader: AssetLoader<T>): Promise<void>
+    registerLoader<T>(type: string, loader: AssetLoader<T>): Promise<void>
 
-    public unregisterLoader(type: string): Promise<void>
+    unregisterLoader(type: string): Promise<void>
 
-    public registerTransformer<T extends Asset<X>, X = any>(type: string, transformer: AssetTransformer<T>): void
+    getLoaderByType<T>(type: string): AssetLoader<T> | undefined
 
-    public unregisterTransformer<T extends Asset<X>, X = any>(type: string, transformer: AssetTransformer<T>): boolean
+    registerTransformer<T extends Asset<X>, X = any>(type: string, transformer: AssetTransformer<T>): void
+
+    unregisterTransformer<T extends Asset<X>, X = any>(type: string, transformer: AssetTransformer<T>): boolean
 }

package/engine/asset/loaders/material/bitmap2sampler_gl.js

@@ -2,7 +2,7 @@
  * Transfer bitmap contents to Sampler2D, effectively moving data to CPU, making it readable
  * @param {WebGL2RenderingContext} gl
  * @param {Sampler2D} sampler
- * @param {ImageBitmap} bitmap
+ * @param {ImageBitmap|ImageData|HTMLImageElement|HTMLCanvasElement|HTMLVideoElement} bitmap
  */
 export function bitmap2sampler_gl(gl, sampler, bitmap) {
     gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, bitmap);
@@ -15,5 +15,11 @@ export function bitmap2sampler_gl(gl, sampler, bitmap) {
         throw new Error(`Expected sampler.itemSize to be 4, instead was '${sampler.itemSize}'`);
     }
 
-    gl.readPixels(0, 0, w, h, gl.RGBA, gl.UNSIGNED_BYTE, sampler.data);
+    /**
+     *
+     * @type {Uint8ClampedArray}
+     */
+    const target_data = sampler.data;
+
+    gl.readPixels(0, 0, w, h, gl.RGBA, gl.UNSIGNED_BYTE, target_data);
 }

package/engine/asset/loaders/material/computeTextureEquality.js

@@ -78,6 +78,9 @@ export function textureImagesEqual(a, b) {
         if (a.src === b.src) {
             //same source
             return true;
+        } else {
+            // different source, assume images are different too
+            return false;
         }
     }
 

package/engine/asset/loaders/material/computeTextureHash.js

@@ -2,6 +2,7 @@ import { computeImageBitmapHash } from "./computeImageBitmapHash.js";
 import { computeHashIntegerArray } from "../../../../core/collection/array/computeHashIntegerArray.js";
 import { computeHashFloat } from "../../../../core/math/hash/computeHashFloat.js";
 import { murmur3_32 } from "../../../../core/math/hash/murmur3_32.js";
+import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.js";
 
 /**
  *
@@ -20,6 +21,11 @@ function vector2Hash(v) {
  */
 const data_cache = new WeakMap();
 
+/**
+ *
+ * @param {ImageBitmap|HTMLImageElement|{data,width:number,height:number}} image
+ * @return {number}
+ */
 export function computeImageDataHash(image) {
     const cached_value = data_cache.get(image);
 
@@ -31,6 +37,8 @@ export function computeImageDataHash(image) {
 
     if (image instanceof ImageBitmap) {
         result = computeImageBitmapHash(image);
+    } else if (image instanceof HTMLImageElement) {
+        result = computeStringHash(image.src);
     }
 
     let width = 0;

package/engine/ecs/EntityComponentDataset.d.ts

@@ -40,4 +40,6 @@ export class EntityComponentDataset {
     public sendEvent<T>(entity: number, name: string, event?: T);
 
     public getComponentClassByName<T>(name: string): Type<T>;
+
+    getAnyComponent<T>(type: Type<T>): { entity: number, component: T | null }
 }

package/engine/ecs/EntityComponentDataset.js

@@ -1057,7 +1057,7 @@ export class EntityComponentDataset {
         if (!ENV_PRODUCTION) {
             assert.isArray(classes, "classes");
             // assert.notOk(classes.some((c, i) => classes.indexOf(c) !== i), 'classes contains duplicates');
-            assert.typeOf(visitor, "function", "visitor");
+            assert.isFunction(visitor, "visitor");
         }
 
         let entityIndex, i;
@@ -1093,18 +1093,23 @@ export class EntityComponentDataset {
 
         const entityOccupancy = this.entityOccupancy;
 
+        const component_type_count = this.componentTypeCount;
+        const component_occupancy = this.componentOccupancy;
+        const components = this.components;
+
         entity_loop: for (entityIndex = entityOccupancy.nextSetBit(0); entityIndex !== -1; entityIndex = entityOccupancy.nextSetBit(entityIndex + 1)) {
-            const componentOccupancyAddress = entityIndex * this.componentTypeCount;
+            const componentOccupancyAddress = entityIndex * component_type_count;
+
             for (i = 0; i < numClasses; i++) {
                 const componentIndex = indices[i];
 
-                const componentPresent = this.componentOccupancy.get(componentOccupancyAddress + componentIndex);
+                const componentPresent = component_occupancy.get(componentOccupancyAddress + componentIndex);
 
                 if (!componentPresent) {
                     continue entity_loop;
                 }
 
-                args[i] = this.components[componentIndex][entityIndex];
+                args[i] = components[componentIndex][entityIndex];
             }
 
             args[numClasses] = entityIndex;

package/engine/graphics/render/visibility/IncrementalDeltaSet.js

@@ -184,10 +184,11 @@ export class IncrementalDeltaSet {
      */
     push(element) {
         //check if element is already in the set
-        const i = this.elements.indexOf(element); //TODO this can probably be done faster. Maybe use a bloom filter? or some kind of a hash
+        const elements = this.elements;
+        const i = elements.indexOf(element); //TODO this can probably be done faster. Maybe use a bloom filter? or some kind of a hash
 
         if (i === -1) {
-            this.elements.push(element);
+            elements.push(element);
             this.size++;
 
             this.onAdded.send1(element);

package/engine/graphics/render/visibility/VisibilityComputer.js

@@ -95,7 +95,7 @@ export class VisibilityComputer {
      * @param {Object3D} object3d
      */
     __includeObject(object3d) {
-        assert.equal(object3d.isObject3D, true, `expected isObject3D to be true, instead was '${object3d.isObject3D}'`);
+        assert.equal(object3d.isObject3D, true, 'object3d.isObject3D !== true');
 
         // mark object, this is a hack, needs to be fixed at some point
         object3d[SOURCE_RENDER_LAYER_PROPERTY] = this.__activeLayer;

package/package.json

@@ -5,7 +5,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.34.6",
+  "version": "2.34.10",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",