@woosh/meep-engine 2.75.3 → 2.75.5

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

@@ -1,9 +1,9 @@
-import { TypeEditor } from "../../TypeEditor.js";
-import { CanvasView } from "../../../../../src/view/elements/CanvasView.js";
-import { plot_data } from "../../../../../src/engine/animation/curve/draw/plot_data.js";
 import Vector2 from "../../../../../src/core/geom/Vector2.js";
-import EmptyView from "../../../../../src/view/elements/EmptyView.js";
+import { canvas2d_plot_data_line } from "../../../../../src/engine/graphics/canvas/canvas2d_plot_data_line.js";
 import { MouseEvents } from "../../../../../src/engine/input/devices/events/MouseEvents.js";
+import { CanvasView } from "../../../../../src/view/elements/CanvasView.js";
+import EmptyView from "../../../../../src/view/elements/EmptyView.js";
+import { TypeEditor } from "../../TypeEditor.js";
 
 export class ParameterLookupTableEditor extends TypeEditor {
     get schema() {
@@ -16,7 +16,7 @@ export class ParameterLookupTableEditor extends TypeEditor {
         };
     }
 
-    build(parent, field,registry) {
+    build(parent, field, registry) {
 
         /**
          * @type {ParameterLookupTable}
@@ -25,7 +25,7 @@ export class ParameterLookupTableEditor extends TypeEditor {
         const trackName = field.adapter.read(parent, "name");
 
         // if it is a track scale
-        if (trackName === "scale"){
+        if (trackName === "scale") {
             const canvasView = new CanvasView();
             canvasView.size.set(200, 100);
             const ctx = canvasView.context2d;
@@ -41,19 +41,30 @@ export class ParameterLookupTableEditor extends TypeEditor {
                 data[i] = sample[0];
             }
 
-            plot_data({ ctx, data, width: canvasView.size.x, height: canvasView.size.y, margin: new Vector2(4, 4) });
+            canvas2d_plot_data_line({
+                ctx,
+                data,
+                width: canvasView.size.x,
+                height: canvasView.size.y,
+                margin: new Vector2(4, 4),
+                range_x: [lut.positions[0], lut.positions[lut.positions.length - 1]],
+            });
 
             return canvasView;
-        } else if (trackName === "color"){
+        } else if (trackName === "color") {
             // if it is color track
             const resultView = new EmptyView();
             const canvasView = new CanvasView();
-            canvasView.css({borderColor: 'white', borderStyle: 'solid', borderWidth: '1px',});
+            canvasView.css({ borderColor: 'white', borderStyle: 'solid', borderWidth: '1px', });
             canvasView.size.set(200, 70);
 
             const ctx = canvasView.context2d;
 
-            const colorView = new EmptyView({tag: "input", attr: {type: "color"}, css: {padding: "0px", border: "0px"}});
+            const colorView = new EmptyView({
+                tag: "input",
+                attr: { type: "color" },
+                css: { padding: "0px", border: "0px" }
+            });
 
             resultView.addChild(canvasView);
             resultView.addChild(colorView);
@@ -76,7 +87,7 @@ export class ParameterLookupTableEditor extends TypeEditor {
                     y = e.clientY - rect.top;
                 for (let i = 0; i < stops.length; i++) {
                     if (stops[i].x <= x && stops[i].x + stops[i].width >= x &&
-                        stops[i].y <= y && stops[i].y + stops[i].height >= y){
+                        stops[i].y <= y && stops[i].y + stops[i].height >= y) {
                         let s = [];
                         lut.sample(lut.positions[i], s);
 
@@ -97,13 +108,14 @@ export class ParameterLookupTableEditor extends TypeEditor {
             return resultView;
         }
     }
+
     /**
      * converts rgb to hex string
      * @param {Float} r
      * @param {Float} g
      * @param {Float} b
      */
-    RGBToHex(r,g,b) {
+    RGBToHex(r, g, b) {
         r = r.toString(16);
         g = g.toString(16);
         b = b.toString(16);
@@ -122,20 +134,21 @@ export class ParameterLookupTableEditor extends TypeEditor {
      * converts lut color sample to RGB
      * @param {number[]} sample
      */
-    convertRGB(sample){
+    convertRGB(sample) {
         sample[0] = Math.floor(sample[0] * 255);
         sample[1] = Math.floor(sample[1] * 255);
         sample[2] = Math.floor(sample[2] * 255);
     }
+
     /**
      * draws tiled background
      * @param {CanvasView} canvasView
      * @param {CanvasRenderingContext2D} ctx
      * @param {{}} config
      */
-    DrawBackground(canvasView, ctx, config){
+    DrawBackground(canvasView, ctx, config) {
         for (let i = 0; i < canvasView.size.x; i += config.tileSize.x) {
-            for (let j = config.gradientBoxYRange.x; j < config.gradientBoxYRange.y; j += config.tileSize.y){
+            for (let j = config.gradientBoxYRange.x; j < config.gradientBoxYRange.y; j += config.tileSize.y) {
                 ctx.fillStyle = (((i / config.tileSize.x) + (j / config.tileSize.y)) % 2 === 0 ? config.tileColor1 : config.tileColor2);
                 ctx.fillRect(i, j, config.tileSize.x, config.tileSize.y);
             }
@@ -149,7 +162,7 @@ export class ParameterLookupTableEditor extends TypeEditor {
      * @param {CanvasRenderingContext2D} ctx
      * @param {{}} config
      */
-    DrawGradient(canvasView, lut, ctx, config){
+    DrawGradient(canvasView, lut, ctx, config) {
         const sample = [];
         for (let i = 0; i < canvasView.size.x; i++) {
             const f = i / (canvasView.size.x - 1);
@@ -172,23 +185,24 @@ export class ParameterLookupTableEditor extends TypeEditor {
      * @param {Integer} selectedInd
      * @returns {*[]}
      */
-    DrawStops(canvasView, lut, ctx, colorView, config, selectedInd){
+    DrawStops(canvasView, lut, ctx, colorView, config, selectedInd) {
         const sample = [];
 
         let stops = [];
-        for (let i = 0; i < lut.positions.length; i++){
+        for (let i = 0; i < lut.positions.length; i++) {
             const posX = lut.positions[i] * canvasView.size.x;
-            if (i === selectedInd){
+            if (i === selectedInd) {
                 lut.sample(lut.positions[i], sample);
 
                 this.convertRGB(sample);
 
                 colorView.el.value = this.RGBToHex(sample[0], sample[1], sample[2]);
             }
-            stops.push(this.DrawStop(ctx, config, posX, i=== selectedInd));
+            stops.push(this.DrawStop(ctx, config, posX, i === selectedInd));
         }
         return stops;
     }
+
     /**
      * draws gradient stop
      * @param {CanvasRenderingContext2D} ctx
@@ -196,7 +210,7 @@ export class ParameterLookupTableEditor extends TypeEditor {
      * @param {Integer} posX
      * @param {Boolean} isSelected
      */
-    DrawStop(ctx, config, posX, isSelected){
+    DrawStop(ctx, config, posX, isSelected) {
         ctx.beginPath();
         ctx.moveTo(posX, config.gradientBoxYRange.x + 7);
         ctx.lineTo(posX - 5, config.gradientBoxYRange.x);

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.75.3",
+  "version": "2.75.5",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {
@@ -38,7 +38,7 @@
     "fastest-levenshtein": "1.0.16",
     "gl-matrix": "3.4.3",
     "opentype.js": "1.3.3",
-    "robust-predicates": "3.0.1",
+    "robust-predicates": "3.0.2",
     "simplex-noise": "2.4.0",
     "pako": "2.0.3"
   },

package/src/core/collection/array/array_compute_min_max.js

@@ -0,0 +1,20 @@
+import { max2 } from "../../math/max2.js";
+import { min2 } from "../../math/min2.js";
+
+/**
+ *
+ * @param {number[]} data
+ * @return {number[]} [min, max]
+ */
+export function array_compute_min_max(data) {
+    const point_count = data.length;
+
+    let min = Number.POSITIVE_INFINITY;
+    let max = Number.NEGATIVE_INFINITY;
+    for (let i = 0; i < point_count; i++) {
+        min = min2(data[i], min);
+        max = max2(data[i], max);
+    }
+
+    return [min, max];
+}

package/src/core/collection/map/HashMap.js

@@ -1,13 +1,13 @@
 import { assert } from "../../assert.js";
-import { invokeObjectEquals } from "../../model/object/invokeObjectEquals.js";
-import { invokeObjectHash } from "../../model/object/invokeObjectHash.js";
-import { isPowerOfTwo } from "../../math/isPowerOrTwo.js";
 import { ctz32 } from "../../binary/ctz32.js";
 import { ceilPowerOfTwo } from "../../binary/operations/ceilPowerOfTwo.js";
-import { UintArrayForCount } from "../array/typed/uint_array_for_count.js";
-import { array_copy } from "../array/array_copy.js";
+import { isPowerOfTwo } from "../../math/isPowerOrTwo.js";
 import { min2 } from "../../math/min2.js";
+import { invokeObjectEquals } from "../../model/object/invokeObjectEquals.js";
+import { invokeObjectHash } from "../../model/object/invokeObjectHash.js";
+import { array_copy } from "../array/array_copy.js";
 import { arraySwapElements } from "../array/arraySwapElements.js";
+import { UintArrayForCount } from "../array/typed/uint_array_for_count.js";
 
 /*
  * Heavily inspired by ruby's "new" (circa 2016) hash table implementation
@@ -378,15 +378,17 @@ export class HashMap {
     }
 
     #rebuild_if_necessary() {
-        if (this.#entries_bound === this.#entries_allocated_count) {
-            if (this.#size === this.#entries_allocated_count) {
-                // used up all allocated entries
-                // bin count must always be larger than end of the entries table
-                this.#grow();
-            } else {
-                // exhausted entries array, perform compaction
-                this.rebuild();
-            }
+        if (this.#entries_bound !== this.#entries_allocated_count) {
+            return;
+        }
+
+        if (this.#size === this.#entries_allocated_count) {
+            // used up all allocated entries
+            // bin count must always be larger than end of the entries table
+            this.#grow();
+        } else {
+            // exhausted entries array, perform compaction
+            this.rebuild();
         }
     }
 

package/src/core/geom/2d/convex-hull/fixed_convex_hull_humus.js

@@ -1,9 +1,9 @@
 //
 
 import { array_copy } from "../../../collection/array/array_copy.js";
+import { UintArrayForCount } from "../../../collection/array/typed/uint_array_for_count.js";
 import { compute_polygon_area_2d } from "../compute_polygon_area_2d.js";
 import { intersect_ray_2d } from "../intersect_ray_2d.js";
-import { UintArrayForCount } from "../../../collection/array/typed/uint_array_for_count.js";
 
 /**
  * Compute a bounding polygon with a fixed given number of vertices such that the area would be minimal
@@ -15,7 +15,7 @@ import { UintArrayForCount } from "../../../collection/array/typed/uint_array_fo
  * @param {number} output_point_count number of points to comprise bounding polygon
  * @param {number[]} input_points Points to be bounded, must be an ordered loop
  * @param {number} input_point_count number of points in the input to consider
- * @returns {number} actual number of points, this can be lower because input polygon has too few points
+ * @returns {boolean} whether or not a valid result could be found
  *
  * @see 2014 "Implementation of linear minimum area enclosing triangle algorithm" Ovidiu Pârvu & David Gilbert
  * @see https://github.com/MagnusTiberius/humus3/blob/9d43412d6e6be869e224817f0a966fe48a1af40f/Util/ConvexHull.cpp#L281
@@ -64,19 +64,29 @@ export function fixed_convex_hull_humus(
             const i0 = subset[i];
             const i1 = subset[(i + 1) % k];
 
-            const a0x = input_points[i0 * 2];
-            const a0y = input_points[i0 * 2 + 1];
+            const i0_2 = i0 << 1;
+
+            const a0x = input_points[i0_2];
+            const a0y = input_points[i0_2 + 1];
 
             const a1 = (i0 + 1) % input_point_count;
 
-            const a1x = input_points[a1 * 2];
-            const a1y = input_points[a1 * 2 + 1];
+            const a1_2 = a1 << 1;
+
+            const a1x = input_points[a1_2];
+            const a1y = input_points[a1_2 + 1];
+
+            const i1_2 = i1 << 1;
+
+            const b0x = input_points[i1_2];
+            const b0y = input_points[i1_2 + 1];
 
-            const b0x = input_points[i1 * 2];
-            const b0y = input_points[i1 * 2 + 1];
             const b1 = (i1 + 1) % input_point_count;
-            const b1x = input_points[b1 * 2];
-            const b1y = input_points[b1 * 2 + 1];
+
+            const b1_2 = b1 << 1;
+
+            const b1x = input_points[b1_2];
+            const b1y = input_points[b1_2 + 1];
 
             const a_dir_x = a1x - a0x;
             const a_dir_y = a1y - a0y;
@@ -85,7 +95,7 @@ export function fixed_convex_hull_humus(
             const b_dir_y = b1y - b0y;
 
             if (!intersect_ray_2d(
-                intersections, i * 2,
+                intersections, i << 1,
                 a0x, a0y, a_dir_x, a_dir_y,
                 b0x, b0y, b_dir_x, b_dir_y
             )) {
@@ -98,7 +108,7 @@ export function fixed_convex_hull_humus(
         const area = compute_polygon_area_2d(intersections, k);
 
         if (area < best_area) {
-            array_copy(intersections, 0, output, output_offset, k * 2);
+            array_copy(intersections, 0, output, output_offset, k << 1);
             best_area = area;
         }
 
@@ -135,5 +145,5 @@ export function fixed_convex_hull_humus(
 
     console.log(`combinations:  ${combos}, valid: ${combos_valid} (${(combos_valid * 100 / combos).toFixed(2)}%)`);
 
-    return output_point_count;
+    return combos_valid > 0;
 }

package/src/core/geom/2d/intersect_ray_2d.js

@@ -1,17 +1,5 @@
 import { fabsf } from "../../math/fabsf.js";
 
-/**
- *
- * @param {number} ux
- * @param {number} uy
- * @param {number} vx
- * @param {number} vy
- * @returns {number}
- */
-function perp(ux, uy, vx, vy) {
-    return (ux * vy - uy * vx);
-}
-
 /**
  * NOTE: that direction must not be normalized for correct results and instead derived from line length
  * @param {number[]|Float32Array|Float64Array} out
@@ -31,11 +19,16 @@ export function intersect_ray_2d(
     origin_a_x, origin_a_y, direction_a_x, direction_a_y,
     origin_b_x, origin_b_y, direction_b_x, direction_b_y
 ) {
-    const d = perp(direction_a_x, direction_a_y, direction_b_x, direction_b_y);
+
+    const d = (direction_a_x * direction_b_y - direction_a_y * direction_b_x);
+
     if (fabsf(d) < 0.000000000001) // Parallel lines
         return false;
 
-    const t = perp(direction_b_x, direction_b_y, origin_a_x - origin_b_x, origin_a_y - origin_b_y) / d;
+    const oab_y = origin_a_y - origin_b_y;
+    const oab_x = origin_a_x - origin_b_x;
+
+    const t = (direction_b_x * oab_y - direction_b_y * oab_x) / d;
 
     if (t < 0.5) // Intersects on the wrong side
         return false;

package/src/core/geom/3d/aabb/AABB3.js

@@ -296,6 +296,19 @@ export class AABB3 {
         this.setBounds(Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY);
     }
 
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     */
+    _translate(x,y,z){
+        this.setBounds(
+            this.x0 + x, this.y0 + y, this.z0 + z,
+            this.x1 + x, this.y1 + y, this.z1 + z
+        )
+    }
+
     /**
      *
      * @param {number} x

package/src/core/geom/3d/topology/samples/sampleFloodFill.js

@@ -1,32 +1,32 @@
-import { EngineHarness } from "../../../../../engine/EngineHarness.js";
 import { MeshBasicMaterial, MeshStandardMaterial, OctahedronBufferGeometry } from "three";
-import Entity from "../../../../../engine/ecs/Entity.js";
-import { ShadedGeometry } from "../../../../../engine/graphics/ecs/mesh-v2/ShadedGeometry.js";
-import { Transform } from "../../../../../engine/ecs/transform/Transform.js";
-import { ShadedGeometrySystem } from "../../../../../engine/graphics/ecs/mesh-v2/ShadedGeometrySystem.js";
-import { SurfacePoint3 } from "../../SurfacePoint3.js";
-import { topo_mesh_to_three_buffer_geometry } from "../topo_mesh_to_three_buffer_geometry.js";
-import { three_buffer_geometry_to_topo_mesh } from "../three_buffer_geometry_to_topo_mesh.js";
-import { mesh_flood_fill } from "../util/mesh_flood_fill.js";
-import { compute_aabb_from_points } from "../../aabb/compute_aabb_from_points.js";
-import { AABB3 } from "../../../../geom/3d/aabb/AABB3.js";
 import { mergeVertices } from "three/examples/jsm/utils/BufferGeometryUtils.js";
-import { makeGeometryIndexed } from "../../../../../engine/graphics/geometry/buffered/makeGeometryIndexed.js";
-import { v3_dot } from "../../../vec3/v3_dot.js";
-import { TopoMesh } from "../struct/TopoMesh.js";
-import { SGMeshSystem } from "../../../../../engine/graphics/ecs/mesh-v2/aggregate/SGMeshSystem.js";
-import { SGMesh } from "../../../../../engine/graphics/ecs/mesh-v2/aggregate/SGMesh.js";
 import { GameAssetType } from "../../../../../engine/asset/GameAssetType.js";
 import { GLTFAssetLoader } from "../../../../../engine/asset/loaders/GLTFAssetLoader.js";
-import { computeTriangleSurfaceArea } from "../../../../../engine/graphics/geometry/computeMeshSurfaceArea.js";
+import Entity from "../../../../../engine/ecs/Entity.js";
+import { EntityNode } from "../../../../../engine/ecs/parent/EntityNode.js";
+import { TransformAttachmentSystem } from "../../../../../engine/ecs/transform-attachment/TransformAttachmentSystem.js";
+import { Transform } from "../../../../../engine/ecs/transform/Transform.js";
+import { EngineHarness } from "../../../../../engine/EngineHarness.js";
+import { SGMesh } from "../../../../../engine/graphics/ecs/mesh-v2/aggregate/SGMesh.js";
 import { SGMeshEvents } from "../../../../../engine/graphics/ecs/mesh-v2/aggregate/SGMeshEvents.js";
+import { SGMeshSystem } from "../../../../../engine/graphics/ecs/mesh-v2/aggregate/SGMeshSystem.js";
+import { ShadedGeometry } from "../../../../../engine/graphics/ecs/mesh-v2/ShadedGeometry.js";
+import { ShadedGeometrySystem } from "../../../../../engine/graphics/ecs/mesh-v2/ShadedGeometrySystem.js";
+import { makeGeometryIndexed } from "../../../../../engine/graphics/geometry/buffered/makeGeometryIndexed.js";
+import { load_and_set_cubemap_v0 } from "../../../../../engine/graphics/load_and_set_cubemap_v0.js";
+import { make_ray_from_viewport_position } from "../../../../../engine/graphics/make_ray_from_viewport_position.js";
 import { Color } from "../../../../color/Color.js";
+import { AABB3 } from "../../../../geom/3d/aabb/AABB3.js";
 import { seededRandom } from "../../../../math/random/seededRandom.js";
+import { v3_dot } from "../../../vec3/v3_dot.js";
+import { compute_aabb_from_points } from "../../aabb/compute_aabb_from_points.js";
+import { SurfacePoint3 } from "../../SurfacePoint3.js";
+import { computeTriangleSurfaceArea } from "../../triangle/computeTriangleSurfaceArea.js";
 import { expandConnectivityByLocality } from "../expandConnectivityByLocality.js";
-import { EntityNode } from "../../../../../engine/ecs/parent/EntityNode.js";
-import { TransformAttachmentSystem } from "../../../../../engine/ecs/transform-attachment/TransformAttachmentSystem.js";
-import { make_ray_from_viewport_position } from "../../../../../engine/graphics/make_ray_from_viewport_position.js";
-import { load_and_set_cubemap_v0 } from "../../../../../engine/graphics/load_and_set_cubemap_v0.js";
+import { TopoMesh } from "../struct/TopoMesh.js";
+import { three_buffer_geometry_to_topo_mesh } from "../three_buffer_geometry_to_topo_mesh.js";
+import { topo_mesh_to_three_buffer_geometry } from "../topo_mesh_to_three_buffer_geometry.js";
+import { mesh_flood_fill } from "../util/mesh_flood_fill.js";
 
 const harness = new EngineHarness();
 

package/src/core/geom/3d/topology/tm_face_area.js

@@ -1,4 +1,4 @@
-import { computeTriangleSurfaceArea } from "../../../../engine/graphics/geometry/computeMeshSurfaceArea.js";
+import { computeTriangleSurfaceArea } from "../triangle/computeTriangleSurfaceArea.js";
 
 /**
  *

package/src/core/geom/3d/triangle/computeTriangleSurfaceArea.js

@@ -0,0 +1,39 @@
+/**
+ * Based on: https://gamedev.stackexchange.com/questions/165643/how-to-calculate-the-surface-area-of-a-mesh
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {number} x2
+ * @param {number} y2
+ * @param {number} z2
+ * @returns {number}
+ */
+export function computeTriangleSurfaceArea(
+    x0, y0, z0,
+    x1, y1, z1,
+    x2, y2, z2
+) {
+
+    const ax = x1 - x0;
+    const ay = y1 - y0;
+    const az = z1 - z0;
+
+    const bx = x2 - x0;
+    const by = y2 - y0;
+    const bz = z2 - z0;
+
+    //compute cross product
+    const x = ay * bz - az * by;
+    const y = az * bx - ax * bz;
+    const z = ax * by - ay * bx;
+
+    //area is equal to half-magnitude of the cross-product
+    const magnitude = Math.sqrt(x * x + y * y + z * z);
+
+    const area = magnitude / 2;
+
+    return area;
+}

package/src/core/process/task/util/countTask.js

@@ -1,5 +1,5 @@
-import { TaskSignal } from "../TaskSignal.js";
 import Task from "../Task.js";
+import { TaskSignal } from "../TaskSignal.js";
 
 /**
  *
@@ -46,7 +46,6 @@ export function countTask(initial, limit, callback) {
             }
 
             i = initialValue;
-
         },
         cycleFunction: cycle,
         computeProgress: function () {

package/src/engine/EngineBootstrapper.js

@@ -1,5 +1,4 @@
 import LabelView from "../view/common/LabelView.js";
-import { FrameRunner } from "./graphics/FrameRunner.js";
 
 /**
  * Used for monitoring progress of the engine startup
@@ -39,16 +38,25 @@ export class EngineBootstrapper {
         v.addChild(vExecutionEngineState);
         v.addChild(vAssetManagerState);
 
-        const frameRunner = new FrameRunner(() => {
-            vExecutionEngineState.updateText(`Executor: ${engine.executor.queueReady.length} ready, ${engine.executor.queueUnresolved.length} unresolved`);
-            vAssetManagerState.updateText(`Assets: ${engine.assetManager.assets.size} loaded, ${engine.assetManager.request_map.size} pending`);
-        });
+        const update_stats = () => {
+            const executor = engine.executor;
+            const assetManager = engine.assetManager;
+
+            vExecutionEngineState.updateText(`Executor: ${executor.queueReady.length} ready, ${executor.queueUnresolved.length} unresolved`);
+            vAssetManagerState.updateText(`Assets: ${assetManager.assets.size} loaded, ${assetManager.request_map.size} pending`);
+        };
+
+        const update_loop = () => {
+            update_stats();
 
-        frameRunner.startup();
+            if (v.isLinked) {
+                requestIdleCallback(update_loop)
+            }
+        };
 
+        update_loop();
 
         started.then(() => {
-            frameRunner.shutdown();
 
             this.rootNode.removeChild(v.el);