@woosh/meep-engine 2.43.11 → 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/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,44 +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";
 import { url_to_data_url } from "../../../../core/binary/url_to_data_url.js";
-
-/**
- *
- * @param {string} url
- * @return {boolean}
- */
-function is_data_url(url) {
-    if (typeof url !== "string") {
-        return false;
-    }
-
-    return url.startsWith('data:');
-}
+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) {
-
-            url_editor = new StringEditor();
-
-        } else if (field.type === ObservedString) {
+        const url_editor = new LargeStrongEditor();
 
-            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: {
@@ -59,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() {
@@ -88,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/tube/build/TubePathBuilder.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;
 
@@ -161,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/particles/particular/engine/utils/volume/ParticleVolume.d.ts

@@ -1,13 +1,15 @@
 import EntityBuilder from "../../../../../../ecs/EntityBuilder";
 import {AbstractShape3D} from "../../../../../../../core/geom/3d/shape/AbstractShape3D";
 import {AttributeValue} from "./AttributeValue";
+import {SamplingFunctionKind} from "./SamplingFunctionKind";
 
 interface Args {
     density?: number
     particle_size?: number
     shape?: AbstractShape3D
     sort?: boolean
-    sprite?: string
+    sprite?: string,
+    sampling_function?: SamplingFunctionKind
 }
 
 interface Attributes {

package/engine/graphics/particles/particular/engine/utils/volume/ParticleVolume.js

@@ -12,6 +12,10 @@ import { PARTICULAR_PARTICLE_SPECIFICATION } from "../../emitter/PARTICULAR_PART
 import { SerializationMetadata } from "../../../../../../ecs/components/SerializationMetadata.js";
 import { UnitCubeShape3D } from "../../../../../../../core/geom/3d/shape/UnitCubeShape3D.js";
 import { shape_from_json } from "../../../../../../../core/geom/3d/shape/json/shape_from_json.js";
+import { min2 } from "../../../../../../../core/math/min2.js";
+import { max2 } from "../../../../../../../core/math/max2.js";
+import { SamplingFunctionKind } from "./SamplingFunctionKind.js";
+import { assert } from "../../../../../../../core/assert.js";
 
 const DEFAULT_ATTRIBUTE_VALUES = {
     color: [1, 1, 1, 1],
@@ -182,6 +186,13 @@ export class ParticleVolume {
          */
         this.__shape = new UnitCubeShape3D();
 
+        /**
+         *
+         * @type {SamplingFunctionKind|number}
+         * @private
+         */
+        this.__sampling_function = SamplingFunctionKind.Random;
+
         const eb = new EntityBuilder();
 
         eb.add(this.__emitter)
@@ -260,6 +271,7 @@ export class ParticleVolume {
      * @param {boolean} sort
      * @param {boolean} lighting
      * @param {string} [sprite]
+     * @param {SamplingFunctionKind|number} [sampling_function]
      */
     from({
              density = 1,
@@ -267,12 +279,17 @@ export class ParticleVolume {
              shape = new UnitCubeShape3D(),
              sort = false,
              lighting = true,
-             sprite = "data/textures/particle/smokeparticle.png"
+             sprite = "data/textures/particle/smokeparticle.png",
+             sampling_function = SamplingFunctionKind.Random
          } = {}) {
 
+        assert.enum(sampling_function, SamplingFunctionKind, 'sampling_function');
+
         this.__density = density;
         this.__shape = shape;
 
+        this.__sampling_function = sampling_function;
+
         const emitter = this.__emitter;
 
         emitter.writeFlag(ParticleEmitterFlag.DepthSorting, sort);
@@ -295,6 +312,7 @@ export class ParticleVolume {
      * @param {boolean} [is_lit]
      * @param {string} sprite
      * @param {Object<Object>} [attributes]
+     * @param {string} [sampling_function]
      */
     fromJSON({
                  density,
@@ -304,20 +322,28 @@ export class ParticleVolume {
                  is_sorted = true,
                  is_lit = true,
                  sprite,
-                 attributes = {}
+                 attributes = {},
+                 sampling_function = 'Random'
              }) {
 
         const shape_object = shape_from_json(shape);
 
         const actual_density = is_density_size_adjusted ? density / particle_size : density;
 
+        const sf_type = SamplingFunctionKind[sampling_function];
+
+        if (sf_type === undefined) {
+            throw new Error(`Unsupported sampling function type '${sampling_function}', valid values:[${Object.keys(SamplingFunctionKind).join(', ')}]`);
+        }
+
         this.from({
             density: actual_density,
             shape: shape_object,
             particle_size,
             sort: is_sorted,
             lighting: is_lit,
-            sprite
+            sprite,
+            sampling_function: sf_type
         });
 
         // parse attributes
@@ -353,12 +379,118 @@ export class ParticleVolume {
 
     }
 
+    __distribute_grid() {
+        const emitter = this.__emitter;
+        const particles = emitter.particles;
+
+        const layer = emitter.layers.get(0);
+
+        // build transform matrix
+        const m4_transform = new Matrix4();
+
+        const t = this.__transform;
+
+        composeMatrix4(m4_transform, t.position, t.rotation, t.scale);
+
+        const m4_layer = new Matrix4();
+
+        composeMatrix4(m4_layer, layer.position, new Quaternion(), layer.scale);
+
+        const v3_position = [];
+
+        const m4_final = new Matrix4();
+
+        m4_final.multiplyMatrices(m4_transform, m4_layer);
+
+
+        // cache variables to save a bit on de-referencing
+        const matrix_elements = m4_final.elements;
+        const shape = this.__shape;
+
+        const ts = shape;
+
+        const bounding_box = [];
+
+        ts.compute_bounding_box(bounding_box);
+
+        const density_step = 1 / Math.pow(this.__density, 1 / 3);
+
+        let particle_index = 0;
+
+        // apply margin to the space, this will shrink the grid spacing to align particles more evenly within the bounding volume
+        const density_margin = density_step * 0.5;
+
+        const mid_x = (bounding_box[3] + bounding_box[0]) * 0.5;
+        const mid_y = (bounding_box[4] + bounding_box[1]) * 0.5;
+        const mid_z = (bounding_box[5] + bounding_box[2]) * 0.5;
+
+        const x0 = min2(mid_x, bounding_box[0] + density_margin);
+        const x1 = max2(mid_x, bounding_box[3] - density_margin);
+
+        const y0 = min2(mid_y, bounding_box[1] + density_margin);
+        const y1 = max2(mid_y, bounding_box[4] - density_margin);
+
+        const z0 = min2(mid_z, bounding_box[2] + density_margin);
+        const z1 = max2(mid_z, bounding_box[5] - density_margin);
+
+        main_loop:for (let x = x0; x <= x1; x += density_step) {
+            for (let y = y0; y <= y1; y += density_step) {
+                for (let z = z0; z <= z1; z += density_step) {
+
+                    v3_position[0] = x;
+                    v3_position[1] = y;
+                    v3_position[2] = z;
+
+                    if (ts.contains_point(v3_position)) {
+
+                        vec3.transformMat4(v3_position, v3_position, matrix_elements);
+
+                        particles.writeAttributeVector3(particle_index, PARTICLE_ATTRIBUTE_POSITION, v3_position[0], v3_position[1], v3_position[2]);
+
+                        particle_index++;
+
+                        if (particle_index >= particles.capacity) {
+                            break main_loop;
+                        }
+                    }
+                }
+            }
+        }
+
+        if (particle_index < particles.capacity) {
+            // crop out remaining particles in the pool
+            particles.occupancy.clearRange(particle_index, particles.capacity);
+            particles.update();
+        }
+
+        // request bounds update
+        emitter.setFlag(ParticleEmitterFlag.ParticleBoundsNeedUpdate);
+        emitter.computeBoundingBox();
+    }
+
+    /**
+     *
+     * @param {function} random
+     * @private
+     */
+    __distribute(random) {
+        const sf = this.__sampling_function;
+
+        if (sf === SamplingFunctionKind.Random) {
+            this.__distribute_random(random);
+        } else if (sf === SamplingFunctionKind.Grid) {
+            this.__distribute_grid();
+        } else {
+            throw new Error(`Unsupported sampling function '${sf}'`);
+        }
+    }
+
     /**
      * Distribute particles in the volume
      * @param {function():number} random
      * @private
      */
-    __distribute(random) {
+    __distribute_random(random) {
         const emitter = this.__emitter;
         const particles = emitter.particles;
         const particle_count = particles.size();

package/engine/graphics/particles/particular/engine/utils/volume/SamplingFunctionKind.d.ts

@@ -0,0 +1,4 @@
+export enum SamplingFunctionKind {
+    Random = 0,
+    Grid = 1
+}

package/engine/graphics/particles/particular/engine/utils/volume/SamplingFunctionKind.js

@@ -0,0 +1,8 @@
+/**
+ * @readonly
+ * @enum {number}
+ */
+export const SamplingFunctionKind = {
+    Random: 0,
+    Grid: 1
+};

package/engine/graphics/particles/particular/engine/utils/volume/prototypeParticleVolume.js

@@ -79,6 +79,8 @@ import { MicronRenderPlugin } from "../../../../../micron/plugin/MicronRenderPlu
 import { obtainTerrain } from "../../../../../../ecs/terrain/util/obtainTerrain.js";
 import { pick } from "../../../../../../../ecs/grid/pick.js";
 import { clamp01 } from "../../../../../../../core/math/clamp01.js";
+import { randomFromArray } from "../../../../../../../core/math/random/randomFromArray.js";
+import { SamplingFunctionKind } from "./SamplingFunctionKind.js";
 
 const engineHarness = new EngineHarness();
 
@@ -895,7 +897,7 @@ async function sample_scene_moicon_0(engine) {
  * @param {Engine} engine
  */
 async function main(engine) {
-    EngineHarness.buildBasics({
+    await EngineHarness.buildBasics({
         engine,
         enableWater: false,
         enableTerrain: false,
@@ -914,8 +916,8 @@ async function main(engine) {
     engine.graphics.renderer.setClearColor('rgba(99,99,99,1)');
 
     // await sample_scene_nam(engine);
-    // await sample_scene_0(engine);
-    await sample_scene_moicon_0(engine);
+    await sample_scene_0(engine);
+    // await sample_scene_moicon_0(engine);
 }
 
 /**
@@ -1068,7 +1070,8 @@ function create_volume({
         particle_size,
         shape: shape,
         sort,
-        sprite
+        sprite,
+        sampling_function: randomFromArray(Math.random, [SamplingFunctionKind.Random, SamplingFunctionKind.Grid])
     });
 
     v.build();

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