@woosh/meep-engine 2.43.9 → 2.43.12

package/core/binary/is_data_url.js

@@ -0,0 +1,12 @@
+/**
+ * Returns true if string is a data URL
+ * @param {string} url
+ * @return {boolean}
+ */
+export function is_data_url(url) {
+    if (typeof url !== "string") {
+        return false;
+    }
+
+    return url.startsWith('data:');
+}

package/core/binary/url_to_data_url.js

@@ -0,0 +1,28 @@
+/**
+ *
+ * @param {string} url
+ * @returns {string}
+ */
+export 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);
+
+            });
+
+        });
+}

package/core/collection/queue/Deque.js

@@ -302,7 +302,7 @@ Deque.prototype.peek = Deque.prototype.getFirst;
 Deque.prototype.push = Deque.prototype.addFirst;
 Deque.prototype.pop = Deque.prototype.removeFirst;
 
-/*
-Standard queue method
+/**
+ * Standard queue method
  */
 Deque.prototype.add = Deque.prototype.addLast;

package/core/geom/3d/shape/AbstractShape3D.js

@@ -63,6 +63,15 @@ export class AbstractShape3D {
         throw new Error('Not Implemented');
     }
 
+    /**
+     *
+     * @param {number[]|ArrayLike<number>|Float32Array|Float64Array} result format: x0,y0,z0,x1,y1,z1
+     * @returns {void}
+     */
+    compute_bounding_box(result) {
+        throw new Error('Not Implemented');
+    }
+
     /**
      * @template {AbstractShape3D} T
      * @param {T} other

package/core/geom/3d/shape/TransformedShape3D.js

@@ -3,6 +3,7 @@ import { AbstractShape3D } from "./AbstractShape3D.js";
 import { sign } from "../../../math/sign.js";
 import { isArrayEqualStrict } from "../../../collection/array/isArrayEqualStrict.js";
 import { computeHashFloatArray } from "../../../math/hash/computeHashFloatArray.js";
+import { aabb3_matrix4_project } from "../aabb/aabb3_matrix4_project.js";
 
 /**
  *
@@ -108,6 +109,13 @@ export class TransformedShape3D extends AbstractShape3D {
         return this.__subject.volume * scale_modifier;
     }
 
+    compute_bounding_box(result) {
+        const tmp = [];
+        this.__subject.compute_bounding_box(tmp);
+
+        aabb3_matrix4_project(result, tmp, this.__matrix);
+    }
+
     signed_distance_gradient_at_point(result, point) {
         // transform point to subject's local space
         vec3.transformMat4(scratch_v3_0, point, this.__inverse_matrix);

package/core/geom/3d/shape/UnionShape3D.js

@@ -5,6 +5,7 @@ import { compareNumbers } from "../../../primitives/numbers/compareNumbers.js";
 import { min2 } from "../../../math/min2.js";
 import { compute_signed_distance_gradient_by_sampling } from "./util/compute_signed_distance_gradient_by_sampling.js";
 import { isArrayEqual } from "../../../collection/array/isArrayEqual.js";
+import { max2 } from "../../../math/max2.js";
 
 /**
  * To avoid severe performance overhead, we limit number of possible rejections
@@ -44,6 +45,40 @@ export class UnionShape3D extends AbstractShape3D {
         this.__child_volumes = [];
     }
 
+    compute_bounding_box(result) {
+        let x0 = Infinity, y0 = Infinity, z0 = Infinity,
+            x1 = -Infinity, y1 = -Infinity, z1 = -Infinity;
+
+        const children = this.children;
+        const n = children.length;
+
+        const tmp_aabb3 = new Float32Array(6);
+
+        for (let i = 0; i < n; i++) {
+            const child = children[i];
+
+            child.compute_bounding_box(tmp_aabb3);
+
+            x0 = min2(x0, tmp_aabb3[0]);
+            y0 = min2(y0, tmp_aabb3[1]);
+            z0 = min2(z0, tmp_aabb3[2]);
+
+            x1 = max2(x1, tmp_aabb3[3]);
+            y1 = max2(y1, tmp_aabb3[4]);
+            z1 = max2(z1, tmp_aabb3[5]);
+
+        }
+
+
+        result[0] = x0;
+        result[1] = y0;
+        result[2] = z0;
+
+        result[3] = x1;
+        result[4] = y1;
+        result[5] = z1;
+    }
+
     /**
      *
      * @private

package/core/geom/3d/shape/UnitCubeShape3D.js

@@ -13,6 +13,16 @@ export class UnitCubeShape3D extends AbstractShape3D {
         return 1;
     }
 
+    compute_bounding_box(result) {
+        result[0] = -0.5;
+        result[1] = -0.5;
+        result[2] = -0.5;
+
+        result[3] = 0.5;
+        result[4] = 0.5;
+        result[5] = 0.5;
+    }
+
     nearest_point_on_surface(result, reference) {
         const r_x = reference[0];
         const r_y = reference[1];

package/core/geom/3d/shape/UnitSphereShape3D.js

@@ -15,6 +15,16 @@ export class UnitSphereShape3D extends AbstractShape3D {
         return 3.14159265;
     }
 
+    compute_bounding_box(result) {
+        result[0] = -0.5;
+        result[1] = -0.5;
+        result[2] = -0.5;
+
+        result[3] = 0.5;
+        result[4] = 0.5;
+        result[5] = 0.5;
+    }
+
     nearest_point_on_surface(result, reference) {
 
         const r_x = reference[0];

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

@@ -1,72 +1,18 @@
 import { TypeEditor } from "../TypeEditor.js";
-import { StringEditor } from "./primitive/StringEditor.js";
 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);
-
-            });
-
-        });
-}
+import { url_to_data_url } from "../../../../core/binary/url_to_data_url.js";
+import { is_data_url } from "../../../../core/binary/is_data_url.js";
+import { LargeStrongEditor } from "./LargeStrongEditor.js";
 
 export class ImagePathEditor extends TypeEditor {
     inline = true;
 
     build(parent, field, registry) {
-        let url_editor;
-
-        if (field.type === String) {
+        const url_editor = new LargeStrongEditor();
 
-            url_editor = new StringEditor();
-
-        } else if (field.type === ObservedString) {
-
-            url_editor = new ObservedStringEditor();
-
-        } else {
-            throw new Error(`Unsupported type`);
-        }
-
-        const vEditor = url_editor.build(parent, field, registry);
+        const editor = url_editor.build(parent, field, registry);
 
         const r = new EmptyView({
             css: {
@@ -87,14 +33,14 @@ export class ImagePathEditor extends TypeEditor {
                 field.adapter.write(parent, field.name, url);
 
                 // update editor value
-                vEditor.el.value = url;
+                editor.methods.set_value(url);
 
-                update();
+                input_changed();
             }
         });
 
         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'
+            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() {
@@ -116,15 +62,18 @@ export class ImagePathEditor extends TypeEditor {
             }
         }
 
-        function update() {
-            vPreview.__setSource(vEditor.el.value);
+        function input_changed() {
+            const url = field.adapter.read(parent, field.name);
+
+            vPreview.__setSource(url);
+
             update_data_url_status();
         }
 
         r.addChild(vPreview);
-        r.addChild(vEditor);
+        r.addChild(editor.view);
 
-        vEditor.el.addEventListener('input', update);
+        editor.signals.input_changed.add(input_changed);
 
         r.on.linked.add(update_data_url_status);
 

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

@@ -0,0 +1,107 @@
+import { TypeEditor } from "../TypeEditor.js";
+import { StringEditor } from "./primitive/StringEditor.js";
+import ObservedString from "../../../../core/model/ObservedString.js";
+import { ObservedStringEditor } from "./ObservedStringEditor.js";
+import EmptyView from "../../../../view/elements/EmptyView.js";
+import LabelView from "../../../../view/common/LabelView.js";
+import { MouseEvents } from "../../../../engine/input/devices/events/MouseEvents.js";
+import Signal from "../../../../core/events/signal/Signal.js";
+
+/**
+ * If path is larger than this - it will be truncated and displayed as non-input
+ * @readonly
+ * @type {number}
+ */
+const MAX_PATH_LENGTH_EDITABLE = 256;
+/**
+ * How long to crop to
+ * @readonly
+ * @type {number}
+ */
+const MAX_CROP_LENGTH = 32;
+
+export class LargeStrongEditor extends TypeEditor {
+    inline = true;
+
+    build(parent, field, registry) {
+        let url_editor;
+
+        if (field.type === String) {
+
+            url_editor = new StringEditor();
+
+        } else if (field.type === ObservedString) {
+
+            url_editor = new ObservedStringEditor();
+
+        } else {
+            throw new Error(`Unsupported type`);
+        }
+
+        let in_focus = false;
+
+        const vEditor = url_editor.build(parent, field, registry);
+
+        const truncated_url = new ObservedString('');
+        const vTruncated = new LabelView(truncated_url);
+
+        vTruncated.el.addEventListener(MouseEvents.Click, () => {
+            in_focus = true;
+            update();
+            vEditor.el.focus();
+        });
+        vEditor.el.addEventListener('focusin', () => {
+            in_focus = true;
+            update();
+        });
+        vEditor.el.addEventListener('blur', () => {
+            in_focus = false;
+            update();
+        });
+
+        const r = new EmptyView();
+
+        function update() {
+            const url = field.adapter.read(parent, field.name);
+
+            if (typeof url === "string" && url.length > MAX_PATH_LENGTH_EDITABLE && !in_focus) {
+                r.removeChild(vEditor);
+
+                truncated_url.set('[...]'+url.slice(0, MAX_CROP_LENGTH));
+
+                if (!r.hasChild(vTruncated)) {
+                    r.addChild(vTruncated);
+                }
+
+            } else if(!r.hasChild(vEditor)){
+                r.removeChild(vTruncated);
+                r.addChild(vEditor);
+            }
+        }
+
+        const input_changed = new Signal();
+
+        vEditor.el.addEventListener('input', () => {
+
+            const value = vEditor.el.value;
+
+            input_changed.send1(value);
+
+            update();
+        });
+        r.on.linked.add(update);
+
+        return {
+            view: r, signals: {
+                input_changed
+            },
+            methods: {
+                set_value(v) {
+                    field.adapter.write(parent, field.name, v);
+                    update();
+                    vEditor.el.value = v;
+                }
+            }
+        };
+    }
+}

package/engine/graphics/ecs/path/PathDisplaySystem.js

@@ -11,6 +11,7 @@ import { RibbonPathBuilder } from "./ribbon/RibbonPathBuilder.js";
 import { PathEvents } from "../../../navigation/ecs/components/PathEvents.js";
 import { assert } from "../../../../core/assert.js";
 import { TubePathBuilder } from "./tube/build/TubePathBuilder.js";
+import { Deque } from "../../../../core/collection/queue/Deque.js";
 
 const builders = {
     [PathDisplayType.None]: function (style, path, result) {
@@ -82,6 +83,14 @@ const builders = {
     }
 };
 
+/**
+ * Maximum amount of time allowed per system tick to spend on processing update queue
+ * in milliseconds
+ * @readonly
+ * @type {number}
+ */
+const UPDATE_PROCESSING_BUDGET_MS = 10;
+
 class PathDisplayContext extends SystemEntityContext {
     constructor() {
         super();
@@ -100,6 +109,8 @@ class PathDisplayContext extends SystemEntityContext {
         const ownedEntities = this.__owned_entities;
         ownedEntities.splice(0, ownedEntities.length);
 
+        // todo check that the main entity still exists before we decide to spawn new entities
+
         /**
          * @type {PathDisplay}
          */
@@ -180,6 +191,16 @@ class PathDisplayContext extends SystemEntityContext {
         this.__build();
     }
 
+    request_update() {
+        /**
+         *
+         * @type {PathDisplaySystem}
+         */
+        const system = this.system;
+
+        system.request_entity_update(this.entity);
+    }
+
     link() {
         super.link();
 
@@ -189,8 +210,8 @@ class PathDisplayContext extends SystemEntityContext {
 
         const entity = this.entity;
 
-        ecd.addEntityEventListener(entity, PathEvents.Changed, this.rebuild, this);
-        ecd.addEntityEventListener(entity, PathDisplayEvents.Changed, this.rebuild, this);
+        ecd.addEntityEventListener(entity, PathEvents.Changed, this.request_update, this);
+        ecd.addEntityEventListener(entity, PathDisplayEvents.Changed, this.request_update, this);
     }
 
     unlink() {
@@ -200,8 +221,16 @@ class PathDisplayContext extends SystemEntityContext {
 
         const entity = this.entity;
 
-        ecd.removeEntityEventListener(entity, PathEvents.Changed, this.rebuild, this);
-        ecd.removeEntityEventListener(entity, PathDisplayEvents.Changed, this.rebuild, this);
+        ecd.removeEntityEventListener(entity, PathEvents.Changed, this.request_update, this);
+        ecd.removeEntityEventListener(entity, PathDisplayEvents.Changed, this.request_update, this);
+
+        /**
+         *
+         * @type {PathDisplaySystem}
+         */
+        const system = this.system;
+
+        system.cancel_entity_update(entity);
 
         // destroy existing owned entities
         this.__destroy_existing_entities();
@@ -238,6 +267,35 @@ export class PathDisplaySystem extends AbstractContextSystem {
          * @type {Reference<RibbonXPlugin>}
          */
         this.plugin = null;
+
+        /**
+         * Deferred queue of entities slated to be rebuilt
+         * @type {Deque<number>}
+         * @private
+         */
+        this.__rebuild_queue = new Deque();
+    }
+
+    /**
+     * Request that path displays be rebuilt
+     * @package
+     * @param {number} entity
+     */
+    request_entity_update(entity) {
+        assert.isNonNegativeInteger(entity, 'entity');
+
+        if (!this.__rebuild_queue.has(entity)) {
+            this.__rebuild_queue.add(entity);
+        }
+    }
+
+    /**
+     * Cancel any pending updates
+     * @package
+     * @param {number} entity
+     */
+    cancel_entity_update(entity) {
+        this.__rebuild_queue.remove(entity);
     }
 
     async startup(entityManager, readyCallback, errorCallback) {
@@ -253,4 +311,34 @@ export class PathDisplaySystem extends AbstractContextSystem {
 
         super.shutdown(entityManager, readyCallback, errorCallback);
     }
+
+    update(time_delta) {
+        // process update queue
+
+        const queue = this.__rebuild_queue;
+        if (queue.isEmpty()) {
+            return;
+        }
+
+        const t0 = performance.now();
+
+        do {
+            // note that we don't need to check if the queue is empty here for the first iteration, as we already checked earlier
+            const entity = queue.pop();
+
+            /**
+             *
+             * @type {PathDisplayContext|undefined}
+             */
+            const ctx = this.__getEntityContext(entity);
+
+            // check that entity still exists
+            if (ctx === undefined) {
+                continue;
+            }
+
+            ctx.rebuild();
+
+        } while ((performance.now() - t0) < UPDATE_PROCESSING_BUDGET_MS && !queue.isEmpty());
+    }
 }

package/engine/graphics/ecs/path/tube/build/{GeometryOutput.js → StreamGeometryBuilder.js}

@@ -4,7 +4,7 @@ import { BufferAttribute, BufferGeometry } from "three";
 /**
  * Helper class, allowing us to treat geometry build process as a stream without having to create intermediate arrays and performing unnecessary copying
  */
-export class GeometryOutput {
+export class StreamGeometryBuilder {
     constructor() {
         /**
          *

package/engine/graphics/ecs/path/tube/build/TubePathBuilder.js

@@ -1,4 +1,4 @@
-import { BufferGeometry, MeshBasicMaterial, MeshMatcapMaterial, MeshStandardMaterial, Vector3 } from "three";
+import { BufferGeometry, MeshBasicMaterial, MeshMatcapMaterial, MeshStandardMaterial } from "three";
 import { InterpolationType } from "../../../../../navigation/ecs/components/InterpolationType.js";
 import EntityBuilder from "../../../../../ecs/EntityBuilder.js";
 import { Transform } from "../../../../../ecs/transform/Transform.js";
@@ -11,6 +11,7 @@ import { ShadedGeometryFlags } from "../../../mesh-v2/ShadedGeometryFlags.js";
 import { m3_rm_compose_transform } from "../../../../../../view/m3_rm_compose_transform.js";
 import { fix_shape_normal_order } from "./fix_shape_normal_order.js";
 import { compute_smooth_profile_normals } from "./compute_smooth_profile_normals.js";
+import { assert } from "../../../../../../core/assert.js";
 
 /**
  *
@@ -28,6 +29,9 @@ function make_geometry_segment(
     shape, shape_normal, shape_transform,
     segment_start, segment_end
 ) {
+    assert.notNaN(segment_start, 'segment_start');
+    assert.notNaN(segment_end, 'segment_end');
+    assert.greaterThanOrEqual(segment_end, segment_start, 'segment_start must be <= segment_end');
 
     const interpolation = path_component.interpolation;
 
@@ -129,8 +133,6 @@ export class TubePathBuilder {
         // generate three.js curve from path
         const path_component = this.path;
 
-        const three_points = [];
-
         const pointCount = path_component.getPointCount();
 
         if (pointCount < 2) {
@@ -138,15 +140,6 @@ export class TubePathBuilder {
             return;
         }
 
-        for (let i = 0; i < pointCount; i++) {
-            const v3 = new Vector3();
-
-            path_component.getPosition(i, v3);
-
-            three_points.push(v3);
-        }
-
-
         const material_def = make_material(style, this.assetManager);
 
         material_def.color.set(style.color.toUint());
@@ -172,8 +165,17 @@ export class TubePathBuilder {
         for (let i = 0; i < segment_count; i++) {
             const i2 = i * 2;
 
-            const segment_start = style.path_mask[i2];
-            const segment_end = style.path_mask[i2 + 1];
+            let segment_start = style.path_mask[i2];
+            let segment_end = style.path_mask[i2 + 1];
+
+            // check for wrong ordering
+            if (segment_end < segment_start) {
+                // violated interval constraint, re-order
+                const t = segment_end;
+
+                segment_end = segment_start;
+                segment_start = t;
+            }
 
             const geometry = make_geometry_segment(
                 path_component, style,

package/engine/graphics/ecs/path/tube/build/build_geometry_catmullrom.spec.js

@@ -0,0 +1,32 @@
+import Path from "../../../../../navigation/ecs/components/Path.js";
+import { build_geometry_catmullrom } from "./build_geometry_catmullrom.js";
+import { TubePathStyle } from "../TubePathStyle.js";
+import { CapType } from "../CapType.js";
+
+test('very tiny segment of a path', () => {
+    const path = Path.fromJSON({
+        points: [3, 1, 1, 3, 1, 3, 7, 1, 3, 7, 1, 7, 3, 1, 7, 3, 1, 8]
+    });
+
+    const style = new TubePathStyle();
+    style.cap_type = CapType.Flat;
+    style.width = 0.1;
+    style.path_mask = [0, 0.00005900000113712167];
+    style.resolution = 10;
+    style.shape = [1, -2.4492937051703357e-16, 0.9238795042037964, -0.3826834261417389, 0.7071067690849304, -0.7071067690849304, 0.3826834261417389, -0.9238795042037964, -1.8369701465288538e-16, -1, -0.3826834261417389, -0.9238795042037964, -0.7071067690849304, -0.7071067690849304, -0.9238795042037964, -0.3826834261417389, -1, 1.2246468525851679e-16, -0.9238795042037964, 0.3826834261417389, -0.7071067690849304, 0.7071067690849304, -0.3826834261417389, 0.9238795042037964, 6.123234262925839e-17, 1, 0.3826834261417389, 0.9238795042037964, 0.7071067690849304, 0.7071067690849304, 0.9238795042037964, 0.3826834261417389];
+
+    const result = build_geometry_catmullrom(path, style, style.shape, [
+        1.131973639570565e-16, 1, 0.3826834559440613, 0.9238795042037964, 0.7071067690849304, 0.7071067690849304, 0.9238795042037964, 0.3826834559440613, 1, -8.489801965906992e-17, 0.9238795042037964, -0.3826834559440613, 0.7071067690849304, -0.7071067690849304, 0.3826834559440613, -0.9238795042037964, -5.659868197852824e-17, -1, -0.3826834559440613, -0.9238795042037964, -0.7071067690849304, -0.7071067690849304, -0.9238795042037964, -0.3826834559440613, -1, 4.244900982953496e-17, -0.9238795042037964, 0.3826834559440613, -0.7071067690849304, 0.7071067690849304, -0.3826834559440613, 0.9238795042037964
+    ], [
+        0.10000000149011612, 0, 0, -0, 0.10000000149011612, 0, 0, 0, 1
+    ], 0, 0.00005900000113712167);
+
+
+    const attribute_position = result.getAttribute("position");
+    expect(attribute_position).toBeDefined();
+    expect(attribute_position).not.toBeNull();
+
+    for (let i = 0; i < attribute_position.array.length; i++) {
+        expect(attribute_position.array[i]).not.toBeNaN();
+    }
+});

package/engine/graphics/ecs/path/tube/build/computeFrenetFrames.js

@@ -101,8 +101,13 @@ export function computeFrenetFrames(points, closed = false, normal_hint) {
             // no tangent, copy previous one
             if (i > 0) {
                 tangents[i] = tangents[i - 1];
-                continue;
+            } else {
+                // very first tangent is undefined, set something arbitrary
+                // TODO take normal_hint into account
+                tangents[i] = new Vector3(0, 0, 1);
             }
+            continue;
+
         }
 
         tangents[i] = new Vector3(