@woosh/meep-engine 2.43.50 → 2.43.52

package/core/collection/array/typed/typed_array_is_integer.js

@@ -0,0 +1,17 @@
+/**
+ *
+ * @param {Uint8Array|Uint16Array|Uint32Array|Int8Array|Int16Array|Int32Array} array
+ * @return {boolean}
+ */
+export function typed_array_is_integer(array) {
+    const ctor = array.constructor;
+
+    return ctor === Uint8ClampedArray
+        || ctor === Uint8Array
+        || ctor === Uint16Array
+        || ctor === Uint32Array
+        || ctor === Int8Array
+        || ctor === Int16Array
+        || ctor === Int32Array
+        ;
+}

package/core/model/node-graph/NodeGraph.spec.js

@@ -32,6 +32,25 @@ test("createConnection returns a number", () => {
     expect(typeof g.createConnection(i0, pOut, i1, pInt)).toBe('number');
 });
 
+test("createConnection populates NodeInstance.connections", () => {
+    const node = new NodeDescription();
+
+    const dt = new DataType();
+
+    const pInt = node.createPort(dt, "in", PortDirection.In);
+    const pOut = node.createPort(dt, "out", PortDirection.Out);
+
+    const g = new NodeGraph();
+
+    const i0 = g.createNode(node);
+    const i1 = g.createNode(node);
+
+    g.createConnection(i0, pOut, i1, pInt);
+
+    expect(g.getNode(i0).connections.length).toBe(1);
+    expect(g.getNode(i1).connections.length).toBe(1);
+});
+
 test('getNode produces correct result', () => {
     const graph = new NodeGraph();
 

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

@@ -10,6 +10,7 @@ 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";
+import { sampler2d_to_uint8_RGBA } from "../../../texture/sampler/sampler2d_to_uint8_RGBA.js";
 
 const placeholder_texture = Sampler2D.uint8(4, 1, 1);
 placeholder_texture.data.fill(255);
@@ -107,6 +108,13 @@ class Context extends SystemEntityContext {
          */
         const decal_spec = this.components[0];
 
+        // propagate draw priority onto decal
+        Object.defineProperty(fpDecal, 'draw_priority', {
+            get() {
+                return decal_spec.priority;
+            }
+        });
+
         this.__load_texture().then(() => {
 
             if (!this.__is_linked) {
@@ -167,7 +175,19 @@ export class FPDecalSystem extends AbstractContextSystem {
          * @private
          */
         this.__texture_cache = new AsyncLoadingCache(new Map(), (key) => {
-            return this.__assets.promise(key, GameAssetType.Image).then(asset => asset.create());
+            return this.__assets.promise(key, GameAssetType.Image).then(asset => {
+                const asset_sampler = asset.create();
+
+                if (asset_sampler.itemSize === 4) {
+                    return asset_sampler;
+                }
+
+                const resampled = Sampler2D.uint8(4, asset_sampler.width, asset_sampler.height);
+
+                sampler2d_to_uint8_RGBA(resampled, asset_sampler);
+
+                return resampled;
+            });
         });
 
         /**

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

@@ -287,7 +287,8 @@ function makeNormalTestGridDecal(ecd, root_transform = new Transform()) {
 
             const decal = new Decal();
 
-            decal.uri = decal_urls[1];
+            // decal.uri = decal_urls[1];
+            decal.uri ='moicon/ISO 7010 - Safety Signs (3)/ISO 7010 - Safety Signs/Emergency/400px/E001 – Emergency exit (left hand).png';
 
             const entity = new EntityBuilder();
 
@@ -299,7 +300,7 @@ function makeNormalTestGridDecal(ecd, root_transform = new Transform()) {
                 SPACING * j,
                 0,
             );
-            transform.scale.setScalar(1);
+            transform.scale.setScalar(3);
             transform.rotation._lookRotation(direction[0],direction[2], direction[1] , 0, 1, 0);
 
             transform.multiplyTransforms(root_transform, transform);
@@ -311,6 +312,10 @@ function makeNormalTestGridDecal(ecd, root_transform = new Transform()) {
                 .add(decal)
                 .build(ecd);
 
+            setInterval(()=>{
+                decal.priority = Math.random();
+            },7000);
+
 
             // make an arrow helper
             const arrow_transform = Transform.fromJSON({

package/engine/graphics/render/forward_plus/LightManager.js

@@ -503,6 +503,13 @@ export class LightManager {
         if (light instanceof Decal) {
             const ref = this.__decal_references.get(light);
 
+            if (ref === undefined) {
+                // This can occur when decal changes while being in the visible list, messing with the IncrementalDeltaSet's compare order
+                console.warn(`Decal reference not found: ${light}, likely live decal changed`);
+                // TODO address this case properly
+                return;
+            }
+
             const patch = ref.getValue();
             const patch_uv = patch.uv;
 

package/engine/graphics/render/forward_plus/model/AbstractLight.js

@@ -5,6 +5,10 @@ export class AbstractLight {
         this.id = id_counter++;
     }
 
+    toString() {
+        return `Light#${this.id}`;
+    }
+
     /**
      *
      * @param {function} f

package/engine/graphics/texture/sampler/Sampler2D2Canvas.js

@@ -3,6 +3,9 @@
  */
 
 
+import { Sampler2D } from "./Sampler2D.js";
+import { sample2d_write_to_canvas_raw } from "./sample2d_write_to_canvas_raw.js";
+
 /**
  *
  * @param {Sampler2D} sampler
@@ -12,32 +15,20 @@
  * @param {function(index:int, array:ArrayLike<number>, x:int, y:int)} [fillDD] allows you to supply mapping function, if none is given - one will be created from sampler using {@link Sampler2D#makeArrayFiller}
  * @returns {HTMLCanvasElement} canvas
  */
-function convertSampler2D2Canvas(sampler, scale=255, offset=0, canvas, fillDD) {
+function convertSampler2D2Canvas(sampler, scale = 255, offset = 0, canvas, fillDD) {
     const source_data = sampler.data;
 
     //generate canvas
     if (canvas === undefined) {
         canvas = document.createElement("canvas");
     }
-    const width = sampler.width;
-    const height = sampler.height;
-
-    if (canvas.width !== width) {
-        canvas.width = width;
-    }
 
-    if (canvas.height !== height) {
-        canvas.height = height;
-    }
+    const converted_sampler = Sampler2D.uint8(4, sampler.width, sampler.height);
 
-    if (height === 0 || width === 0) {
-        //there is no data, just return canvas
-        return canvas;
-    }
+    const width = sampler.width;
+    const height = sampler.height;
 
-    const context = canvas.getContext("2d");
-    const imageData = context.createImageData(width, height);
-    const array = imageData.data;
+    const array = converted_sampler.data;
     //
     const source_channel_count = sampler.itemSize;
     if (source_channel_count === 4 && offset === 0 && scale === 1) {
@@ -94,7 +85,8 @@ function convertSampler2D2Canvas(sampler, scale=255, offset=0, canvas, fillDD) {
 
     }
 
-    context.putImageData(imageData, 0, 0);
+    sample2d_write_to_canvas_raw(converted_sampler, canvas);
+
     return canvas;
 }
 

package/engine/graphics/texture/sampler/copy_Sampler2D_channel_data.js

@@ -1,3 +1,5 @@
+import { saturated_value_by_constructor } from "./saturated_value_by_constructor.js";
+
 /**
  * Allows copying data from one sampler to another with unequal number of channels (a.itemSize !== b.itemSize)
  * @example convert RGBA to RGB or R to RGB
@@ -19,12 +21,14 @@ export function copy_Sampler2D_channel_data(source, destination) {
 
     let i, j;
 
+    const saturated_channel_value = saturated_value_by_constructor(destination_data.constructor);
+
     if (source_item_size === destination_item_size) {
         // just copy data chunk
         destination_data.set(source_data);
 
     } else if (source_item_size > destination_item_size) {
-
+        // more channels in source than in destination
         for (i = 0; i < pixel_count; i++) {
             const source_sample_offset = i * source_item_size;
             const destination_sample_offset = i * destination_item_size;
@@ -44,7 +48,7 @@ export function copy_Sampler2D_channel_data(source, destination) {
             destination_data[i4 + 1] = source_data[i3 + 1];
             destination_data[i4 + 2] = source_data[i3 + 2];
 
-            destination_data[i4] = 255; // fill alpha
+            destination_data[i4 + 3] = saturated_channel_value; // fill alpha
         }
     } else if (source_item_size === 2 && destination_item_size === 4) {
         //RA -> RGBA

package/engine/graphics/texture/sampler/sample2d_write_to_canvas_raw.js

@@ -0,0 +1,38 @@
+import { Sampler2D } from "./Sampler2D.js";
+import { sampler2d_to_uint8_RGBA } from "./sampler2d_to_uint8_RGBA.js";
+
+/**
+ *
+ * @param {Sampler2D} sampler
+ * @param {HTMLCanvasElement} canvas
+ */
+export function sample2d_write_to_canvas_raw(sampler, canvas) {
+
+    const width = sampler.width;
+    const height = sampler.height;
+
+    if (canvas.width !== width) {
+        canvas.width = width;
+    }
+
+    if (canvas.height !== height) {
+        canvas.height = height;
+    }
+
+    if (height === 0 || width === 0) {
+        //there is no data, just return
+        return;
+    }
+
+    const context = canvas.getContext("2d");
+
+    const imageData = context.createImageData(width, height);
+    const array = imageData.data;
+
+    const destination_sampler = new Sampler2D(array, 4, width, height);
+
+    sampler2d_to_uint8_RGBA(destination_sampler, sampler);
+
+    context.putImageData(imageData, 0, 0);
+
+}

package/engine/graphics/texture/sampler/sampler2d_channel_linear_transform.js

@@ -0,0 +1,68 @@
+import { typed_array_is_integer } from "../../../../core/collection/array/typed/typed_array_is_integer.js";
+
+/**
+ * Applies a linear polynomial transform to each value of a given channel
+ * @param {Sampler2D} output
+ * @param {Sampler2D} input
+ * @param {number} output_channel_index
+ * @param {number} input_channel_index
+ * @param {number} gradient
+ * @param {number} intercept
+ */
+export function sampler2d_channel_linear_transform(
+    output, input,
+    output_channel_index, input_channel_index,
+    gradient, intercept
+) {
+
+    const input_width = input.width;
+    const input_height = input.height;
+
+    const output_width = output.width;
+    const output_height = output.height;
+
+    if (
+        input_width !== output_width
+        || input_height !== output_height
+    ) {
+        throw new Error('Dimensions of input and output are incompatible');
+    }
+
+    const input_item_size = input.itemSize;
+    const output_item_size = output.itemSize;
+
+    const input_data = input.data;
+    const output_data = output.data;
+
+    const pixel_count = input_width * input_height;
+
+
+    if (typed_array_is_integer(output_data)) {
+
+        for (let i = 0; i < pixel_count; i++) {
+
+            const input_address = i * input_item_size + input_channel_index;
+            const output_address = i * output_item_size + output_channel_index;
+
+            const input_value = input_data[input_address];
+
+            output_data[output_address] = Math.round(input_value * gradient + intercept);
+
+        }
+
+    } else {
+
+        for (let i = 0; i < pixel_count; i++) {
+
+            const input_address = i * input_item_size + input_channel_index;
+            const output_address = i * output_item_size + output_channel_index;
+
+            const input_value = input_data[input_address];
+
+            output_data[output_address] = input_value * gradient + intercept;
+
+        }
+
+    }
+
+}

package/engine/graphics/texture/sampler/sampler2d_to_uint8_RGBA.js

@@ -0,0 +1,97 @@
+import { sampler2d_channel_linear_transform } from "./sampler2d_channel_linear_transform.js";
+
+function compute_gradient_and_intercept_uint8(ctor) {
+    let gradient = 1;
+    let intercept = 0;
+
+    switch (ctor) {
+        case Uint16Array:
+            gradient = 0.0038910505836575876;
+            break;
+        case Uint32Array:
+            gradient = 5.937181414556033e-8;
+            break;
+        case Int8Array:
+            gradient = 1;
+            intercept = 127;
+            break
+        case Int16Array:
+            gradient = 0.0038910505836575876;
+            intercept = 127;
+            break;
+        case Int32Array:
+            gradient = 5.937181414556033e-8;
+            intercept = 127;
+            break
+        case Float32Array:
+        case Float64Array:
+            gradient = 255;
+            break;
+        default:
+        // do nothing;
+    }
+
+    return {
+        gradient, intercept
+    }
+}
+
+/**
+ * Many applications work with 8bit RGBA images, this utility function converts a given input to that format
+ * @param {Sampler2D} input
+ * @param {Sampler2D} output
+ */
+export function sampler2d_to_uint8_RGBA(output, input) {
+    if (
+        input.width !== output.width
+        || input.height !== output.height
+    ) {
+        throw new Error('Dimensions of source and destination are incompatible');
+    }
+
+    if (output.itemSize !== 4) {
+        throw new Error(`Destination must have 4 channels exactly, instead got '${output.itemSize}'`);
+    }
+
+    const { gradient, intercept } = compute_gradient_and_intercept_uint8(input.data.constructor);
+
+    const source_item_size = input.itemSize;
+
+    if (intercept === 0 && gradient === 1 && source_item_size === 4) {
+        // already in the right format, use shortcut
+        output.data.set(input.data);
+        return;
+    }
+
+    if (source_item_size === 1) {
+
+        sampler2d_channel_linear_transform(output, input, 0, 0, gradient, intercept);
+        sampler2d_channel_linear_transform(output, input, 1, 0, gradient, intercept);
+        sampler2d_channel_linear_transform(output, input, 2, 0, gradient, intercept);
+
+        output.fill_channel(3, 255);
+
+    } else if (source_item_size === 2) {
+
+        sampler2d_channel_linear_transform(output, input, 0, 0, gradient, intercept);
+        sampler2d_channel_linear_transform(output, input, 1, 0, gradient, intercept);
+        sampler2d_channel_linear_transform(output, input, 2, 0, gradient, intercept);
+        sampler2d_channel_linear_transform(output, input, 3, 1, gradient, intercept);
+
+    } else if (source_item_size === 3) {
+
+        sampler2d_channel_linear_transform(output, input, 0, 0, gradient, intercept);
+        sampler2d_channel_linear_transform(output, input, 1, 1, gradient, intercept);
+        sampler2d_channel_linear_transform(output, input, 2, 2, gradient, intercept);
+
+        output.fill_channel(3, 255);
+
+    } else if (source_item_size === 4) {
+
+        sampler2d_channel_linear_transform(output, input, 0, 0, gradient, intercept);
+        sampler2d_channel_linear_transform(output, input, 1, 1, gradient, intercept);
+        sampler2d_channel_linear_transform(output, input, 2, 2, gradient, intercept);
+        sampler2d_channel_linear_transform(output, input, 3, 3, gradient, intercept);
+
+    }
+}

package/engine/graphics/texture/sampler/sampler2d_to_uint8_RGBA.spec.js

@@ -0,0 +1,52 @@
+import { sampler2d_to_uint8_RGBA } from "./sampler2d_to_uint8_RGBA.js";
+import { Sampler2D } from "./Sampler2D.js";
+
+test('uint8 RGBA input', () => {
+
+    const source = new Sampler2D(new Uint8Array([1,3,7,11]), 4, 1, 1);
+    const destination = Sampler2D.uint8(4, 1, 1);
+
+    sampler2d_to_uint8_RGBA(destination, source);
+
+    expect(Array.from(destination.data)).toEqual([1,3,7,11]);
+});
+
+test('uint8 RGB input', () => {
+
+    const source = new Sampler2D(new Uint8Array([1,3,7]), 3, 1, 1);
+    const destination = Sampler2D.uint8(4, 1, 1);
+
+    sampler2d_to_uint8_RGBA(destination, source);
+
+    expect(Array.from(destination.data)).toEqual([1,3,7,255]);
+});
+
+test('uint8 RG input', () => {
+
+    const source = new Sampler2D(new Uint8Array([1,3]), 2, 1, 1);
+    const destination = Sampler2D.uint8(4, 1, 1);
+
+    sampler2d_to_uint8_RGBA(destination, source);
+
+    expect(Array.from(destination.data)).toEqual([1,1,1,3]);
+});
+
+test('uint8 R input', () => {
+
+    const source = new Sampler2D(new Uint8Array([1]), 1, 1, 1);
+    const destination = Sampler2D.uint8(4, 1, 1);
+
+    sampler2d_to_uint8_RGBA(destination, source);
+
+    expect(Array.from(destination.data)).toEqual([1,1,1,255]);
+});
+
+test('float32 RGBA input', () => {
+
+    const source = new Sampler2D(new Float32Array([0.1,0.3,0.7,0.11]), 4, 1, 1);
+    const destination = Sampler2D.uint8(4, 1, 1);
+
+    sampler2d_to_uint8_RGBA(destination, source);
+
+    expect(Array.from(destination.data)).toEqual([26, 77, 178, 28]);
+});

package/engine/graphics/texture/sampler/saturated_value_by_constructor.js

@@ -0,0 +1,28 @@
+/**
+ *
+ * @param {*} ctor
+ * @returns {number}
+ */
+export function saturated_value_by_constructor(ctor) {
+
+    switch (ctor) {
+        case Uint8Array:
+            return 255;
+        case Uint16Array:
+            return 65535;
+        case Uint32Array:
+            return 4294967295;
+        case Int8Array:
+            return 127;
+        case Int16Array:
+            return 32767;
+        case Int32Array:
+            return 2147483647;
+        case Float32Array:
+        case Float64Array:
+            return 1;
+        default:
+            return 1;
+    }
+
+}

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