@woosh/meep-engine 2.39.36 → 2.39.39

package/core/geom/3d/plane/plane3_projectPoint.spec.js

@@ -0,0 +1,54 @@
+import { plane3_projectPoint } from "./plane3_projectPoint.js";
+import Vector3 from "../../Vector3.js";
+
+test("point above orthographic plane at origin", () => {
+    const p = new Vector3();
+
+
+    plane3_projectPoint(
+        p,
+        0, 1, 0,
+        0, 1, 0, 0
+    );
+
+    expect(p.toJSON()).toEqual({ x: 0, y: 0, z: 0 });
+});
+
+test("point above orthographic plane", () => {
+    const p = new Vector3();
+
+
+    plane3_projectPoint(
+        p,
+        0, 2, 0,
+        0, 1, 0, -1
+    );
+
+    expect(p.toJSON()).toEqual({ x: 0, y: 1, z: 0 });
+});
+
+test("point on orthographic plane", () => {
+    const p = new Vector3();
+
+
+    plane3_projectPoint(
+        p,
+        0, 1, 0,
+        0, 1, 0, -1
+    );
+
+    expect(p.toJSON()).toEqual({ x: 0, y: 1, z: 0 });
+});
+
+test("point below orthographic plane", () => {
+    const p = new Vector3();
+
+
+    plane3_projectPoint(
+        p,
+        0, 0, 0,
+        0, 1, 0, -1
+    );
+
+    expect(p.toJSON()).toEqual({ x: 0, y: 1, z: 0 });
+});

package/core/geom/Plane.js

@@ -121,25 +121,6 @@ export function computePlaneRayIntersection(out, originX, originY, originZ, dire
     }
 }
 
-/**
- * Orthogonal distance of a point to a plane, the distance is positive when the point lies above the plane and negative when the point is below
- * @param {number} x
- * @param {number} y
- * @param {number} z
- * @param {number} normalX
- * @param {number} normalY
- * @param {number} normalZ
- * @param {number} planeConstant
- * @returns {number}
- */
-export function computePointDistanceToPlane(
-    x, y, z,
-    normalX, normalY, normalZ, planeConstant
-) {
-    // this is is the same v4_dot(v4(x,y,z,1.0), v4(plane.normal, plane.constant));
-    return v3_dot(normalX, normalY, normalZ, x, y, z) + planeConstant;
-}
-
 /**
  *
  * @param {Vector3} out Result will be written here

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/geom/v3_distance_above_plane.js

@@ -0,0 +1,20 @@
+import { v3_dot } from "./v3_dot.js";
+
+/**
+ * Orthogonal distance of a point to a plane, the distance is positive when the point lies above the plane and negative when the point is below
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @param {number} normalX
+ * @param {number} normalY
+ * @param {number} normalZ
+ * @param {number} planeConstant
+ * @returns {number}
+ */
+export function v3_distance_above_plane(
+    x, y, z,
+    normalX, normalY, normalZ, planeConstant
+) {
+    // this is is the same v4_dot(v4(x,y,z,1.0), v4(plane.normal, plane.constant));
+    return v3_dot(normalX, normalY, normalZ, x, y, z) + planeConstant;
+}

package/core/geom/v3_distance_above_plane.spec.js

@@ -0,0 +1,40 @@
+import { v3_distance_above_plane } from "./v3_distance_above_plane.js";
+
+test('point above orthographic plane at origin', () => {
+    expect(v3_distance_above_plane(
+        0, 1, 0,
+        0, 1, 0, 0
+    )).toBe(1);
+});
+
+test('point below orthographic plane at origin', () => {
+    expect(v3_distance_above_plane(
+        0, -1, 0,
+        0, 1, 0, 0
+    )).toBe(-1);
+});
+
+test('point above orthographic plane', () => {
+    expect(v3_distance_above_plane(
+        0, 2, 0,
+        0, 1, 0, -1
+    )).toBe(1);
+});
+
+test('point below orthographic plane', () => {
+    expect(v3_distance_above_plane(
+        0, 0, 0,
+        0, 1, 0, -1
+    )).toBe(-1);
+});
+
+test('orthographic planes at origin', () => {
+    expect(v3_distance_above_plane(1, 0, 0, 1, 0, 0, 0)).toBe(1);
+    expect(v3_distance_above_plane(-1, 0, 0, 1, 0, 0, 0)).toBe(-1);
+
+    expect(v3_distance_above_plane(0, 1, 0, 0, 1, 0, 0)).toBe(1);
+    expect(v3_distance_above_plane(0, -1, 0, 0, 1, 0, 0)).toBe(-1);
+
+    expect(v3_distance_above_plane(0, 0, 1, 0, 0, 1, 0)).toBe(1);
+    expect(v3_distance_above_plane(0, 0, -1, 0, 0, 1, 0)).toBe(-1);
+});

package/core/math/statistics/halton_sequence.js

@@ -0,0 +1,26 @@
+import { assert } from "../../assert.js";
+
+/**
+ * Returns number from Halton Sequence identified by base and sequence index
+ * Halton sequence produces numbers that appear to have random distribution
+ * @see https://en.wikipedia.org/wiki/Halton_sequence
+ * @param {number} base
+ * @param {number} index sequence index
+ * @returns {number}
+ */
+export function halton_sequence(base, index) {
+    assert.isNonNegativeInteger(base, 'base');
+    assert.isNonNegativeInteger(index, 'index');
+
+    let result = 0;
+    let f = 1;
+    let i = index;
+
+    while (i > 0) {
+        f /= base;
+        result += f * (i % base);
+        i = Math.floor(i / base);
+    }
+
+    return result;
+}

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/asset/loaders/ArrayBufferLoader.js

@@ -4,20 +4,84 @@ import { CrossOriginKind } from "../CORS/CrossOriginKind.js";
 
 export class ArrayBufferLoader extends AssetLoader {
     load(path, success, failure, progress) {
+        const coc = this.assetManager.crossOriginConfig;
 
-        const xhr = new XMLHttpRequest();
-        xhr.open('GET', path, true);
-        xhr.responseType = "arraybuffer";
+        const headers = new Headers();
 
-        const coc = this.assetManager.crossOriginConfig;
+        const request = new Request(path, {
+            credentials: coc.kind === CrossOriginKind.UseCredentials ? 'include' : 'same-origin',
+            headers: headers
+        });
+
+        fetch(request)
+            .then(response => {
+                if (response.status === 200 || response.status === 0) {
+
+                    // Some browsers return HTTP Status 0 when using non-http protocol
+                    // e.g. 'file://' or 'data://'. Handle as success.
+
+                    if (response.status === 0) {
+
+                        console.warn('HTTP Status 0 received.');
+
+                    }
+
+                    if (typeof ReadableStream === 'undefined' || response.body.getReader === undefined) {
+
+                        return response;
+
+                    }
+
+                    const reader = response.body.getReader();
+                    const contentLength = response.headers.get('Content-Length');
+                    const total = contentLength ? parseInt(contentLength) : 0;
+                    const lengthComputable = total !== 0;
+                    let loaded = 0;
+
+                    // periodically read data into the new stream tracking while download progress
+                    const stream = new ReadableStream({
+                        start(controller) {
+
+                            readData();
+
+                            function readData() {
+
+                                reader.read().then(({ done, value }) => {
+
+                                    if (done) {
+
+                                        controller.close();
+
+                                    } else {
+
+                                        loaded += value.byteLength;
+
+                                        progress(loaded, length);
+
+                                        controller.enqueue(value);
+                                        readData();
+
+                                    }
+
+                                });
+
+                            }
+
+                        }
+
+                    });
+
+                    return new Response(stream);
+
+                } else {
+
+                    throw Error(`fetch for "${response.url}" responded with ${response.status}: ${response.statusText}`);
 
-        if (coc.kind === CrossOriginKind.UseCredentials) {
-            xhr.withCredentials = true;
-        }
+                }
+            })
+            .then(async response => {
+                const arrayBuffer = await response.arrayBuffer();
 
-        xhr.addEventListener('load', function () {
-            if (xhr.readyState === xhr.DONE && xhr.status === 200) {
-                const arrayBuffer = xhr.response;
                 const asset = new Asset(
                     function () {
                         return arrayBuffer;
@@ -26,13 +90,9 @@ export class ArrayBufferLoader extends AssetLoader {
                 );
 
                 success(asset);
-            } else {
-                failure(xhr);
-            }
-        }, false);
+            })
+            .catch(failure);
 
-        xhr.addEventListener('error', failure, false);
 
-        xhr.send();
     }
 }