@woosh/meep-engine 2.39.38 → 2.39.39

package/core/binary/Base64.js

@@ -3,13 +3,21 @@
  * @author Jameson Little
  */
 
-var lookup = [];
-var revLookup = [];
-var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array;
+/**
+ *
+ * @type {string[]}
+ */
+const lookup = [];
+/**
+ *
+ * @type {number[]}
+ */
+const revLookup = [];
+const Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array;
 
-var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
 
-for (var i = 0, len = code.length; i < len; ++i) {
+for (let i = 0, len = code.length; i < len; ++i) {
     lookup[i] = code[i];
     revLookup[code.charCodeAt(i)] = i;
 }
@@ -19,6 +27,11 @@ for (var i = 0, len = code.length; i < len; ++i) {
 revLookup['-'.charCodeAt(0)] = 62;
 revLookup['_'.charCodeAt(0)] = 63;
 
+/**
+ *
+ * @param {string} b64
+ * @return {number[]}
+ */
 function getLens(b64) {
     var len = b64.length;
 
@@ -41,12 +54,6 @@ function getLens(b64) {
 }
 
 // base64 is 4/3 + up to two characters of the original data
-function byteLength(b64) {
-    var lens = getLens(b64);
-    var validLen = lens[0];
-    var placeHoldersLen = lens[1];
-    return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen;
-}
 
 function _byteLength(b64, validLen, placeHoldersLen) {
     return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen;
@@ -99,37 +106,57 @@ function toByteArray(b64) {
 }
 
 function tripletToBase64(num) {
-    return lookup[num >> 18 & 0x3F] +
-        lookup[num >> 12 & 0x3F] +
-        lookup[num >> 6 & 0x3F] +
-        lookup[num & 0x3F];
+    return lookup[num >> 18 & 0x3F]
+        + lookup[num >> 12 & 0x3F]
+        + lookup[num >> 6 & 0x3F]
+        + lookup[num & 0x3F]
+        ;
 }
 
+/**
+ *
+ * @param {Uint8Array} uint8
+ * @param {number} start
+ * @param {number} end
+ * @return {string}
+ */
 function encodeChunk(uint8, start, end) {
-    var tmp;
-    var output = [];
-    for (var i = start; i < end; i += 3) {
-        tmp =
-            ((uint8[i] << 16) & 0xFF0000) +
-            ((uint8[i + 1] << 8) & 0xFF00) +
-            (uint8[i + 2] & 0xFF);
+    const output = [];
+
+    for (let i = start; i < end; i += 3) {
+
+        const tmp = ((uint8[i] << 16) & 0xFF0000)
+            + ((uint8[i + 1] << 8) & 0xFF00)
+            + (uint8[i + 2] & 0xFF);
+
         output.push(tripletToBase64(tmp));
     }
+
     return output.join('');
 }
 
+/**
+ *
+ * @param {Uint8Array} uint8
+ * @return {string}
+ */
 function fromByteArray(uint8) {
-    var tmp;
-    var len = uint8.length;
-    var extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes
-    var parts = [];
-    var maxChunkLength = 16383; // must be multiple of 3
+    let tmp;
+
+    const len = uint8.length;
+    const extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes
+    const parts = [];
+    const maxChunkLength = 16383; // must be multiple of 3
 
     // go through the array every three bytes, we'll deal with trailing stuff later
-    for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
-        parts.push(encodeChunk(
-            uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)
-        ));
+    const len2 = len - extraBytes;
+
+    for (let i = 0; i < len2; i += maxChunkLength) {
+        const end = (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength);
+
+        const chunk = encodeChunk(uint8, i, end);
+
+        parts.push(chunk);
     }
 
     // pad the end with zeros, but make sure to not forget the extra bytes

package/core/binary/Base64.spec.js

@@ -0,0 +1,14 @@
+import { Base64 } from "./Base64.js";
+
+test("to/from consistency", () => {
+    const source = new Uint8Array(256);
+    for (let i = 0; i < source.length; i++) {
+        source[i] = i;
+    }
+
+    const encoded = Base64.encode(source.buffer);
+
+    const decoded = Base64.decode(encoded);
+
+    expect(Array.from(new Uint8Array(decoded))).toEqual(Array.from(source));
+});

package/core/color/Color.js

@@ -301,12 +301,15 @@ export class Color {
      * @param {number} v 0..1
      */
     setHSV(h, s, v) {
-        let _h = h % 1;
+        let _h = h;
 
         if (_h < 0) {
-            _h = h + 1;
+            // move into positive range
+            _h = _h + Math.ceil(Math.abs(_h));
         }
 
+        _h = _h % 1
+
         const _s = clamp01(s);
         const _v = clamp01(v);
 
@@ -409,7 +412,8 @@ export class Color {
      * @param {Color} other
      */
     copy(other) {
-        this.setRGB(this.r, this.g, this.b);
+        this.a = other.a;
+        this.setRGB(other.r, other.g, other.b);
     }
 
     /**

package/core/geom/Quaternion.js

@@ -8,7 +8,7 @@ import { assert } from "../assert.js";
 import Signal from "../events/signal/Signal.js";
 import { clamp } from "../math/clamp.js";
 import { lerp } from "../math/lerp.js";
-import { EPSILON, epsilonEquals, PI2 } from "../math/MathUtils.js";
+import { EPSILON, epsilonEquals } from "../math/MathUtils.js";
 import Vector3 from "./Vector3.js";
 import { v3_dot } from "./v3_dot.js";
 import { min2 } from "../math/min2.js";
@@ -20,12 +20,6 @@ const forward = new Vector3();
 const up = new Vector3();
 const right = new Vector3();
 
-const rotAxis = new Vector3();
-
-function normalizeAngle(v) {
-    return v % PI2;
-}
-
 /**
  *
  * @param {number[]|Float32Array} out
@@ -518,7 +512,12 @@ class Quaternion {
      * @return {number}
      */
     length() {
-        return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w);
+        const x = this.x;
+        const y = this.y;
+        const z = this.z;
+        const w = this.w;
+
+        return Math.sqrt(x * x + y * y + z * z + w * w);
     }
 
     /**
@@ -827,13 +826,16 @@ class Quaternion {
         const scaled_y = y * 0.5;
         const scaled_z = z * 0.5;
 
-        const s1 = Math.sin(scaled_x);
-        const s2 = Math.sin(scaled_y);
-        const s3 = Math.sin(scaled_z);
+        const sin = Math.sin;
+        const cos = Math.cos;
+
+        const s1 = sin(scaled_x);
+        const s2 = sin(scaled_y);
+        const s3 = sin(scaled_z);
 
-        const c1 = Math.cos(scaled_x);
-        const c2 = Math.cos(scaled_y);
-        const c3 = Math.cos(scaled_z);
+        const c1 = cos(scaled_x);
+        const c2 = cos(scaled_y);
+        const c3 = cos(scaled_z);
 
         const _x = s1 * c2 * c3 + c1 * s2 * s3;
         const _y = c1 * s2 * c3 - s1 * c2 * s3;
@@ -857,13 +859,16 @@ class Quaternion {
         const scaled_y = y * 0.5;
         const scaled_z = z * 0.5;
 
-        const s1 = Math.sin(scaled_x);
-        const s2 = Math.sin(scaled_y);
-        const s3 = Math.sin(scaled_z);
+        const sin = Math.sin;
+        const cos = Math.cos;
+
+        const s1 = sin(scaled_x);
+        const s2 = sin(scaled_y);
+        const s3 = sin(scaled_z);
 
-        const c1 = Math.cos(scaled_x);
-        const c2 = Math.cos(scaled_y);
-        const c3 = Math.cos(scaled_z);
+        const c1 = cos(scaled_x);
+        const c2 = cos(scaled_y);
+        const c3 = cos(scaled_z);
 
         const _x = s1 * c2 * c3 - c1 * s2 * s3;
         const _y = c1 * s2 * c3 + s1 * c2 * s3;
@@ -887,13 +892,16 @@ class Quaternion {
         const scaled_y = y * 0.5;
         const scaled_z = z * 0.5;
 
-        const s1 = Math.sin(scaled_x);
-        const s2 = Math.sin(scaled_y);
-        const s3 = Math.sin(scaled_z);
+        const sin = Math.sin;
+        const cos = Math.cos;
+
+        const s1 = sin(scaled_x);
+        const s2 = sin(scaled_y);
+        const s3 = sin(scaled_z);
 
-        const c1 = Math.cos(scaled_x);
-        const c2 = Math.cos(scaled_y);
-        const c3 = Math.cos(scaled_z);
+        const c1 = cos(scaled_x);
+        const c2 = cos(scaled_y);
+        const c3 = cos(scaled_z);
 
         const _x = s1 * c2 * c3 - c1 * s2 * s3;
         const _y = c1 * s2 * c3 + s1 * c2 * s3;
@@ -917,13 +925,16 @@ class Quaternion {
         const scaled_y = y * 0.5;
         const scaled_z = z * 0.5;
 
-        const s1 = Math.sin(scaled_x);
-        const s2 = Math.sin(scaled_y);
-        const s3 = Math.sin(scaled_z);
+        const sin = Math.sin;
+        const cos = Math.cos;
+
+        const s1 = sin(scaled_x);
+        const s2 = sin(scaled_y);
+        const s3 = sin(scaled_z);
 
-        const c1 = Math.cos(scaled_x);
-        const c2 = Math.cos(scaled_y);
-        const c3 = Math.cos(scaled_z);
+        const c1 = cos(scaled_x);
+        const c2 = cos(scaled_y);
+        const c3 = cos(scaled_z);
 
         const _x = s1 * c2 * c3 + c1 * s2 * s3;
         const _y = c1 * s2 * c3 + s1 * c2 * s3;
@@ -947,13 +958,16 @@ class Quaternion {
         const scaled_y = y * 0.5;
         const scaled_z = z * 0.5;
 
-        const s1 = Math.sin(scaled_x);
-        const s2 = Math.sin(scaled_y);
-        const s3 = Math.sin(scaled_z);
+        const sin = Math.sin;
+        const cos = Math.cos;
+
+        const s1 = sin(scaled_x);
+        const s2 = sin(scaled_y);
+        const s3 = sin(scaled_z);
 
-        const c1 = Math.cos(scaled_x);
-        const c2 = Math.cos(scaled_y);
-        const c3 = Math.cos(scaled_z);
+        const c1 = cos(scaled_x);
+        const c2 = cos(scaled_y);
+        const c3 = cos(scaled_z);
 
         const _x = s1 * c2 * c3 - c1 * s2 * s3;
         const _y = c1 * s2 * c3 - s1 * c2 * s3;

package/core/model/ModuleRegistry.js

@@ -32,7 +32,7 @@ export class ModuleRegistry {
 
     /**
      *
-     * @param {function(name:string, module:*)} visitor
+     * @param {(name:string, module:*)=>void} visitor
      */
     traverse(visitor) {
         this.__elements.forEach((klass, name) => visitor(name, klass));

package/core/model/reactive/model/terminal/ReactiveReference.js

@@ -57,7 +57,7 @@ export class ReactiveReference extends ReactiveExpression {
     }
 
     update(v, oldV) {
-        this.onChanged.dispatch(v, oldV);
+        this.onChanged.send2(v, oldV);
     }
 
     connect(source) {

package/core/model/reactive/trigger/ReactiveTrigger.js

@@ -10,7 +10,7 @@ export class ReactiveTrigger {
      */
     constructor(code) {
 
-        assert.typeOf(code, "string", code);
+        assert.isString(code, "code");
 
         /**
          *
@@ -55,15 +55,25 @@ export class ReactiveTrigger {
      * @param {Object} data
      */
     connect(data) {
-        this.references.forEach(ref => {
+        const references = this.references;
+        const ref_count = references.length;
+
+        for (let i = 0; i < ref_count; i++) {
+            const ref = references[i];
             const refName = ref.name;
             const datum = data[refName];
 
             ref.connect(datum);
-        });
+        }
     }
 
     disconnect() {
-        this.references.forEach(ref => ref.disconnect());
+        const references = this.references;
+        const ref_count = references.length;
+
+        for (let i = 0; i < ref_count; i++) {
+            const ref = references[i];
+            ref.disconnect();
+        }
     }
 }

package/editor/ecs/component/editors/ImagePathEditor.js

@@ -4,6 +4,49 @@ import EmptyView from "../../../../view/elements/EmptyView.js";
 import ImageView from "../../../../view/elements/image/ImageView.js";
 import ObservedString from "../../../../core/model/ObservedString.js";
 import { ObservedStringEditor } from "./ObservedStringEditor.js";
+import ButtonView from "../../../../view/elements/button/ButtonView.js";
+
+/**
+ *
+ * @param {string} url
+ * @return {boolean}
+ */
+function is_data_url(url) {
+    if (typeof url !== "string") {
+        return false;
+    }
+
+    return url.startsWith('data:');
+}
+
+/**
+ *
+ * @param {string} url
+ * @returns {string}
+ */
+async function url_to_data_url(url) {
+    return fetch(url)
+        .then(response => {
+            return response.blob();
+        })
+        .then(blob => {
+            const fr = new FileReader();
+
+            return new Promise((resolve, reject) => {
+
+                fr.onload = () => {
+                    resolve(fr.result);
+                };
+
+                fr.onerror = reject;
+                fr.onabort = reject;
+
+                fr.readAsDataURL(blob);
+
+            });
+
+        });
+}
 
 export class ImagePathEditor extends TypeEditor {
     inline = true;
@@ -36,8 +79,46 @@ export class ImagePathEditor extends TypeEditor {
 
         vPreview.size.set(32, 32);
 
+        const b_toDataURL = new ButtonView({
+            classList: ['convert-to-data-url', 'embed'],
+            async action() {
+                const url = await url_to_data_url(field.adapter.read(parent, field.name));
+
+                field.adapter.write(parent, field.name, url);
+
+                // update editor value
+                vEditor.el.value = url;
+
+                update();
+            }
+        });
+
+        b_toDataURL.attr({
+           title:'Convert URL into DATA_URL, embedding the data. This allows to bypass CORRS restrictions if the URL points to a different origin from the one where the texture resides'
+        });
+
+        function update_data_url_status() {
+            const url = field.adapter.read(parent, field.name);
+
+            const can_convert = typeof url === "string"
+                && field.adapter.writable
+                && !is_data_url(url)
+            ;
+
+            if (can_convert) {
+                // offer encoding option
+                r.addChild(b_toDataURL);
+            } else {
+                // nothing
+                if (r.hasChild(b_toDataURL)) {
+                    r.removeChild(b_toDataURL);
+                }
+            }
+        }
+
         function update() {
             vPreview.__setSource(vEditor.el.value);
+            update_data_url_status();
         }
 
         r.addChild(vPreview);
@@ -45,6 +126,8 @@ export class ImagePathEditor extends TypeEditor {
 
         vEditor.el.addEventListener('input', update);
 
+        r.on.linked.add(update_data_url_status);
+
         return r;
     }
 }

package/engine/ecs/terrain/ecs/splat/SplatMapping.js

@@ -8,6 +8,7 @@ import { scaleSampler2D } from "../../../../graphics/texture/sampler/scaleSample
 import { countTask } from "../../../../../core/process/task/TaskUtils.js";
 import { array_copy } from "../../../../../core/collection/array/copyArray.js";
 import { typed_array_copy } from "../../../../../core/collection/array/typed/typed_array_copy.js";
+import { Base64 } from "../../../../../core/binary/Base64.js";
 
 
 /**
@@ -52,20 +53,42 @@ export class SplatMapping {
     }
 
     toJSON() {
+        const encoded = Base64.encode(this.weightData.buffer);
+
         return {
             size: this.size.toJSON(),
             depth: this.depth,
-            data: Array.from(this.weightData)
+            data: encoded
         };
     }
 
     fromJSON({
                  size = { x: 1, y: 1 },
                  depth = 0,
-                 data = []
-    } = {}) {
+                 data
+             } = {}) {
         this.resize(size.x, size.y, depth);
-        array_copy(data, 0, this.weightData, 0, data.length);
+
+        let uint_data;
+
+        if (typeof data === "string") {
+
+            const decoded_data = Base64.decode(data);
+            uint_data = new Uint8Array(decoded_data);
+
+        } else if (Array.isArray(data)) {
+
+            // deprecated
+            console.warn('Array JSON format is deprecated, please upgrade your data as soon as possible');
+            uint_data = data;
+
+        } else {
+
+            throw new Error('Unsupported data format');
+
+        }
+
+        array_copy(uint_data, 0, this.weightData, 0, data.length);
 
         this.weightTexture.needsUpdate = true;
     }

package/engine/graphics/ecs/mesh-v2/ShadedGeometry.js

@@ -281,15 +281,23 @@ export class ShadedGeometry {
 
         const min = gbb.min;
 
-        scratch_aabb3_array[0] = min.x;
-        scratch_aabb3_array[1] = min.y;
-        scratch_aabb3_array[2] = min.z;
+        const x0 = min.x;
+        const y0 = min.y;
+        const z0 = min.z;
 
         const max = gbb.max;
 
-        scratch_aabb3_array[3] = max.x;
-        scratch_aabb3_array[4] = max.y;
-        scratch_aabb3_array[5] = max.z;
+        const x1 = max.x;
+        const y1 = max.y;
+        const z1 = max.z;
+
+        scratch_aabb3_array[0] = x0;
+        scratch_aabb3_array[1] = y0;
+        scratch_aabb3_array[2] = z0;
+
+        scratch_aabb3_array[3] = x1;
+        scratch_aabb3_array[4] = y1;
+        scratch_aabb3_array[5] = z1;
 
         aabb3_matrix4_project(this.__bvh_aabb, scratch_aabb3_array, this.transform);
     }

package/engine/graphics/ecs/mesh-v2/aggregate/SGMesh.js

@@ -3,7 +3,8 @@ import { AABB3 } from "../../../../../core/bvh2/aabb3/AABB3.js";
 
 export const SGMeshFlags = {
     CastShadow: 1,
-    ReceiveShadow: 2
+    ReceiveShadow: 2,
+    Loaded: 4
 };
 
 export class SGMesh {

package/engine/graphics/ecs/mesh-v2/aggregate/SGMeshSystem.js

@@ -17,6 +17,13 @@ import { min2 } from "../../../../../core/math/min2.js";
  */
 const MAX_CYCLE_COUNT = 128;
 
+/**
+ * In milliseconds
+ * @readonly
+ * @type {number}
+ */
+const MAX_CYCLE_TIME = 40;
+
 export class SGMeshSystem extends System {
     /**
      *
@@ -235,10 +242,11 @@ export class SGMeshSystem extends System {
 
         if (l > 0) {
 
-            let pointer = this.__wait_queue_process_index;
+            const time_0 = performance.now();
 
+            let pointer = this.__wait_queue_process_index;
 
-            let pointer_limit = pointer + min2(l, MAX_CYCLE_COUNT);
+            const pointer_limit = pointer + min2(l, MAX_CYCLE_COUNT);
 
             while (pointer < pointer_limit) {
 
@@ -260,6 +268,13 @@ export class SGMeshSystem extends System {
 
                 this.process(entity, mesh, transform);
 
+                const time_1 = performance.now();
+
+                if ((time_1 - time_0) > MAX_CYCLE_TIME) {
+                    // too much time has passed
+                    break;
+                }
+
             }
 
             this.__wait_queue_process_index = pointer;

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

@@ -14,6 +14,7 @@ import { typedArrayToDataType } from "../../../../core/collection/array/typedArr
 import {
     compute_typed_array_constructor_from_data_type
 } from "../../../../core/collection/table/DataType2TypedArrayConstructorMapping.js";
+import { Base64 } from "../../../../core/binary/Base64.js";
 
 /**
  * @class
@@ -1450,19 +1451,38 @@ export class Sampler2D {
     }
 
     toJSON() {
+        const encoded = Base64.encode(this.data.buffer);
+
         return {
             height: this.height,
             width: this.width,
             itemSize: this.itemSize,
             type: typedArrayToDataType(this.data),
-            data: Array.from(this.data)
+            data: encoded
         }
     }
 
     fromJSON({ height, width, itemSize, type, data }) {
         const CTOR = compute_typed_array_constructor_from_data_type(type);
 
-        this.data = new CTOR(data);
+        if (typeof data === "string") {
+
+            const decoded = Base64.decode(data);
+
+            this.data = new CTOR(decoded);
+
+        } else if (Array.isArray(data)) {
+            // deprecated
+            console.warn('Array JSON format is deprecated, please upgrade your data as soon as possible');
+
+            this.data = new CTOR(data);
+
+        }else{
+
+            throw new Error('Unsupported data format');
+
+        }
+
         this.height = height;
         this.width = width;
         this.itemSize = itemSize;

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

package/view/elements/button/ButtonView.js

@@ -50,7 +50,18 @@ class ButtonView extends View {
 
         this.el.addEventListener('click', (event) => {
             if (this.__enabled) {
-                action(event);
+                const p = action(event);
+
+                if (p instanceof Promise) {
+                    // async resolution, wait until done, disable button for now
+                    this.enabled = false;
+
+                    p.finally(() => {
+                        // restore
+                        this.enabled = true;
+                    });
+
+                }
             } else {
                 console.warn('Button is disabled, no action');
             }