@woosh/meep-engine 2.34.5 → 2.34.9

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/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/image/png/PNG.js

@@ -343,7 +343,9 @@ PNG.prototype.getUint8Data_case3 = function () {
     for (let i = 0; i < pixel_count; i++) {
         const destination_address = i * itemSize;
 
-        const lookup_value = pixels[i * d];
+        const lookup_index = pixels[i * d];
+
+        const lookup_value = lookup_index * 3;
 
         result_data[destination_address] = palette[lookup_value];
         result_data[destination_address + 1] = palette[lookup_value + 1];
@@ -381,7 +383,12 @@ PNG.prototype.getUint8Data = function () {
             break;
         case 3:
             // palette
-            return this.getUint8Data_case3();
+            const c3 = this.getUint8Data_case3();
+
+            data = c3.data;
+            itemSize = c3.itemSize;
+
+            break;
         case 4:
             // grayscale with alpha
             data = this.pixels;

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.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/micron/plugin/MicronRenderPlugin.js

@@ -125,15 +125,15 @@ class GLTFAssetTransformer extends AssetTransformer {
     /**
      *
      * @param {Asset} source
-     * @param asset_description
+     * @param {AssetDescription} asset_description
      * @return {Promise<Asset>}
      */
     async transform(source, asset_description) {
         const animationClips = source.animations;
 
         if (animationClips !== undefined && animationClips.length > 0) {
-            // not suitable
-            return source;
+            // animations might cause trouble
+            console.warn(`model '${asset_description.path}' contains animations, these animations might not works as intended with micron.`);
         }
 
         /**

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.5",
+  "version": "2.34.9",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",

package/samples/terrain/editor.js

@@ -20,6 +20,7 @@ import { copy_Sampler2D_channel_data } from "../../engine/graphics/texture/sampl
 import { TextureAssetLoader } from "../../engine/asset/loaders/texture/TextureAssetLoader.js";
 import { CanvasView } from "../../view/elements/CanvasView.js";
 import convertSampler2D2Canvas from "../../engine/graphics/texture/sampler/Sampler2D2Canvas.js";
+import { drawSamplerHTML } from "../../engine/graphics/texture/sampler/util/drawSamplerHTML.js";
 
 const engineHarness = new EngineHarness();
 
@@ -309,10 +310,6 @@ async function main(engine) {
 
     await EngineHarness.buildTerrain({ engine });
 
-    const image = await engine.assetManager.promise("diffuseMap1.png", 'image');
-
-    console.log(image.create());
-
     const vMain = new EmptyView({ classList: ['ui-texture-testing-tool-view'] });
 
     vMain.css({