@woosh/meep-engine 2.27.0 → 2.30.0

package/core/geom/3d/plane_computeConvex3PlaneIntersection.js

@@ -1,4 +1,4 @@
-import Vector3, { v3_dot } from "../Vector3.js";
+import { v3_dot } from "../Vector3.js";
 
 
 /**
@@ -22,10 +22,6 @@ export function plane_three_computeConvex3PlaneIntersection(result, a, b, c) {
     );
 }
 
-const bxc = new Vector3();
-const cxa = new Vector3();
-const axb = new Vector3();
-
 /**
  * NOTE: Based on Intersection of 3 planes, Graphics Gems 1 pg 305
  * @param {Vector3} result
@@ -57,23 +53,19 @@ export function plane_computeConvex3PlaneIntersection(
     float3 r = -P0.w * bxc - P1.w * cxa - P2.w * axb;
     return r * (1 / dot(P0.xyz, bxc));
      */
+    const bxc_x = b_normal_y * c_normal_z - b_normal_z * c_normal_y;
+    const bxc_y = b_normal_z * c_normal_x - b_normal_x * c_normal_z;
+    const bxc_z = b_normal_x * c_normal_y - b_normal_y * c_normal_x;
 
-    bxc._crossVectors(
-        b_normal_x, b_normal_y, b_normal_z,
-        c_normal_x, c_normal_y, c_normal_z
-    );
+    const cxa_x = c_normal_y * a_normal_z - c_normal_z * a_normal_y;
+    const cxa_y = c_normal_z * a_normal_x - c_normal_x * a_normal_z;
+    const cxa_z = c_normal_x * a_normal_y - c_normal_y * a_normal_x;
 
-    cxa._crossVectors(
-        c_normal_x, c_normal_y, c_normal_z,
-        a_normal_x, a_normal_y, a_normal_z
-    );
-
-    axb._crossVectors(
-        a_normal_x, a_normal_y, a_normal_z,
-        b_normal_x, b_normal_y, b_normal_z
-    );
+    const axb_x = a_normal_y * b_normal_z - a_normal_z * b_normal_y;
+    const axb_y = a_normal_z * b_normal_x - a_normal_x * b_normal_z;
+    const axb_z = a_normal_x * b_normal_y - a_normal_y * b_normal_x;
 
-    const determinant = v3_dot(a_normal_x, a_normal_y, a_normal_z, bxc.x, bxc.y, bxc.z);
+    const determinant = v3_dot(a_normal_x, a_normal_y, a_normal_z, bxc_x, bxc_y, bxc_z);
 
     if (determinant === 0) {
         // planes are not convex, there is no intersection
@@ -82,13 +74,13 @@ export function plane_computeConvex3PlaneIntersection(
 
     const d = 1 / determinant;
 
-    bxc.multiplyScalar(-a_constant);
-    cxa.multiplyScalar(-b_constant);
-    axb.multiplyScalar(-c_constant);
+    const neg_a_constant = -a_constant;
+    const neg_b_constant = -b_constant;
+    const neg_c_constant = -c_constant;
 
-    const x = (bxc.x + cxa.x + axb.x) * d;
-    const y = (bxc.y + cxa.y + axb.y) * d;
-    const z = (bxc.z + cxa.z + axb.z) * d;
+    const x = (bxc_x * neg_a_constant + cxa_x * neg_b_constant + axb_x * neg_c_constant) * d;
+    const y = (bxc_y * neg_a_constant + cxa_y * neg_b_constant + axb_y * neg_c_constant) * d;
+    const z = (bxc_z * neg_a_constant + cxa_z * neg_b_constant + axb_z * neg_c_constant) * d;
 
     result.set(
         x,

package/core/geom/AABB2.d.ts

@@ -19,4 +19,6 @@ export default class AABB2 {
     computeArea(): number
 
     grow(size: number): void
+
+    setNegativelyInfiniteBounds(): void
 }

package/core/geom/GeometryMath.js

@@ -1,4 +1,3 @@
-import { PI2 } from "../math/MathUtils.js";
 import { SurfacePoint3 } from "./3d/SurfacePoint3.js";
 import { computeTriangleRayIntersection } from "./3d/triangle/computeTriangleRayIntersection.js";
 
@@ -32,129 +31,3 @@ export function rayTriangleIntersection(result, rayOrigin, rayDirection, a, b, c
     return hit_found;
 }
 
-/**
- * Pick a random point within a unit circle
- * Based on: https://stackoverflow.com/questions/5837572/generate-a-random-point-within-a-circle-uniformly
- * @param {function} random
- * @param {Vector2} result
- */
-export function randomPointInCircle(random, result) {
-    const r = Math.sqrt(random());
-
-    const theta = random() * PI2;
-
-    const x = r * Math.cos(theta);
-    const y = r * Math.sin(theta);
-
-    result.set(x, y);
-}
-
-/**
- * Volumetric sampling method, since sample volume is a point, it simply sets result to origin
- * @param {function} random
- * @param {Vector3} result
- */
-export function randomPointInPoint(random, result) {
-    result.set(0, 0, 0);
-}
-
-/**
- *
- * @see based on python code suggested here: https://stackoverflow.com/questions/5408276/sampling-uniformly-distributed-random-points-inside-a-spherical-volume
- * @param {function} random
- * @param {Vector3} result
- */
-export function randomPointInSphere(random, result) {
-    const phi = PI2 * random();
-
-    const cosTheta = random() * 2 - 1;
-
-    const u = random() * 0.5;
-
-    const theta = Math.acos(cosTheta);
-
-    const r = Math.cbrt(u);
-
-    const sinTheta = Math.sin(theta);
-
-    //compute coordinates
-    const x = r * sinTheta * Math.cos(phi);
-    const y = r * sinTheta * Math.sin(phi);
-    const z = r * cosTheta;
-
-    //write the result
-    result.set(x, y, z);
-}
-
-/**
- *
- * @see based on python code suggested here: https://stackoverflow.com/questions/5408276/sampling-uniformly-distributed-random-points-inside-a-spherical-volume
- * @param {function} random
- * @param {Vector3} result
- */
-export function randomPointOnSphere(random, result) {
-    const phi = Math.PI * 2 * random();
-
-    const cosTheta = random() * 2 - 1;
-
-    const theta = Math.acos(cosTheta);
-
-    const sinTheta = Math.sin(theta);
-
-    const r = 0.5;
-
-    //compute coordinates
-    const x = r * sinTheta * Math.cos(phi);
-    const y = r * sinTheta * Math.sin(phi);
-    const z = r * cosTheta;
-
-    //write the result
-    result.set(x, y, z);
-}
-
-/**
- *
- * @param {function} random
- * @param {Vector3} result
- */
-export function randomPointInBox(random, result) {
-    const x = random() - 0.5;
-    const y = random() - 0.5;
-    const z = random() - 0.5;
-
-    result.set(x, y, z);
-}
-
-/**
- *
- * @param {function} random
- * @param {Vector3} result
- */
-export function randomPointOnBox(random, result) {
-    //pick a side
-    const side = random();
-
-    //determine axis of the side
-    const axis = side % 0.5;
-
-    //convert side and axis to a fixed value for the axis
-    const fixedAxis = side > 0.5 ? -0.5 : 0.5;
-
-    let x, y, z;
-
-    if (axis < 0.16666666666) {
-        x = fixedAxis;
-        y = random() - 0.5;
-        z = random() - 0.5;
-    } else if (axis < 0.33333333333) {
-        x = random() - 0.5;
-        y = fixedAxis;
-        z = random() - 0.5;
-    } else {
-        x = random() - 0.5;
-        y = random() - 0.5;
-        z = fixedAxis;
-    }
-
-    result.set(x, y, z);
-}

package/core/geom/random/randomPointInBox.js

@@ -0,0 +1,12 @@
+/**
+ *
+ * @param {function} random
+ * @param {Vector3} result
+ */
+export function randomPointInBox(random, result) {
+    const x = random() - 0.5;
+    const y = random() - 0.5;
+    const z = random() - 0.5;
+
+    result.set(x, y, z);
+}

package/core/geom/random/randomPointInCircle.js

@@ -0,0 +1,18 @@
+import { PI2 } from "../../math/MathUtils.js";
+
+/**
+ * Pick a random point within a unit circle
+ * Based on: https://stackoverflow.com/questions/5837572/generate-a-random-point-within-a-circle-uniformly
+ * @param {function} random
+ * @param {Vector2} result
+ */
+export function randomPointInCircle(random, result) {
+    const r = Math.sqrt(random());
+
+    const theta = random() * PI2;
+
+    const x = r * Math.cos(theta);
+    const y = r * Math.sin(theta);
+
+    result.set(x, y);
+}

package/core/geom/random/randomPointInPoint.js

@@ -0,0 +1,8 @@
+/**
+ * Volumetric sampling method, since sample volume is a point, it simply sets result to origin
+ * @param {function} random
+ * @param {Vector3} result
+ */
+export function randomPointInPoint(random, result) {
+    result.set(0, 0, 0);
+}

package/core/geom/random/randomPointInSphere.js

@@ -0,0 +1,31 @@
+import { PI2 } from "../../math/MathUtils.js";
+
+/**
+ *
+ * @see based on python code suggested here: https://stackoverflow.com/questions/5408276/sampling-uniformly-distributed-random-points-inside-a-spherical-volume
+ * @param {function} random
+ * @param {Vector3} result
+ */
+export function randomPointInSphere(random, result) {
+    const phi = PI2 * random();
+
+    const cosTheta = random() * 2 - 1;
+
+    const u = random() * 0.5;
+
+    const theta = Math.acos(cosTheta);
+
+    const r = Math.cbrt(u);
+
+    const sinTheta = Math.sin(theta);
+
+    //compute coordinates
+    const rst = r * sinTheta;
+
+    const x = rst * Math.cos(phi);
+    const y = rst * Math.sin(phi);
+    const z = r * cosTheta;
+
+    //write the result
+    result.set(x, y, z);
+}

package/core/geom/random/randomPointOnBox.js

@@ -0,0 +1,33 @@
+/**
+ *
+ * @param {function} random
+ * @param {Vector3} result
+ */
+export function randomPointOnBox(random, result) {
+    //pick a side
+    const side = random();
+
+    //determine axis of the side
+    const axis = side % 0.5;
+
+    //convert side and axis to a fixed value for the axis
+    const fixedAxis = side > 0.5 ? -0.5 : 0.5;
+
+    let x, y, z;
+
+    if (axis < 0.16666666666) {
+        x = fixedAxis;
+        y = random() - 0.5;
+        z = random() - 0.5;
+    } else if (axis < 0.33333333333) {
+        x = random() - 0.5;
+        y = fixedAxis;
+        z = random() - 0.5;
+    } else {
+        x = random() - 0.5;
+        y = random() - 0.5;
+        z = fixedAxis;
+    }
+
+    result.set(x, y, z);
+}

package/core/geom/random/randomPointOnSphere.js

@@ -0,0 +1,27 @@
+/**
+ *
+ * @see based on python code suggested here: https://stackoverflow.com/questions/5408276/sampling-uniformly-distributed-random-points-inside-a-spherical-volume
+ * @param {function} random
+ * @param {Vector3} result
+ */
+export function randomPointOnSphere(random, result) {
+    const phi = Math.PI * 2 * random();
+
+    const cosTheta = random() * 2 - 1;
+
+    const theta = Math.acos(cosTheta);
+
+    const sinTheta = Math.sin(theta);
+
+    const r = 0.5;
+
+    //compute coordinates
+    const rst = r * sinTheta;
+
+    const x = rst * Math.cos(phi);
+    const y = rst * Math.sin(phi);
+    const z = r * cosTheta;
+
+    //write the result
+    result.set(x, y, z);
+}

package/core/math/noise/sdnoise.js

@@ -1,29 +1,3 @@
-/**
- *
- * Ported from C code by Stefan Gustavson by @Alex Goldring
- * @source http://weber.itn.liu.se/~stegu/aqsis/DSOs/DSOnoises.html
- * ================
- *
- * This is an implementation of Perlin "simplex noise" over one
- * dimension (x), two dimensions (x,y), three dimensions (x,y,z)
- * and four dimensions (x,y,z,w). The analytic derivative is
- * returned, to make it possible to do lots of fun stuff like
- * flow animations, curl noise, analytic antialiasing and such.
- *
- * Visually, this noise is exactly the same as the plain version of
- * simplex noise provided in the file "snoise1234.c". It just returns
- * all partial derivatives in addition to the scalar noise value.
- *
- * 2012-01-12: Slight update to compile with MSVC (declarations moved).
- *
- *  @author Alexander Goldring 2020
- *  @author Stefan Gustavson 2003-2012
- */
-
-function fastfloor(v) {
-    return v | 0;
-}
-
 const v2_array = [];
 const v3_array = [];
 const v4_array = [];
@@ -222,7 +196,7 @@ function grad4(result, hash) {
  * @returns {number}
  */
 function sdnoise1(derivatives, x) {
-    const i0 = fastfloor(x);
+    const i0 = x | 0;
     const i1 = i0 + 1;
 
     const x0 = x - i0;
@@ -303,8 +277,8 @@ function sdnoise2(derivatives, x, y) {
     const xs = x + s;
     const ys = y + s;
 
-    let ii, i = fastfloor(xs);
-    let jj, j = fastfloor(ys);
+    let ii, i = xs | 0;
+    let jj, j = ys | 0;
 
     const t = (float)(i + j) * G2;
     const X0 = i - t; /* Unskew the cell origin back to (x,y) space */
@@ -458,9 +432,11 @@ export function sdnoise3(derivatives, x, y, z) {
     const k = zs | 0;
 
     const t = (i + j + k) * G3;
+
     const X0 = i - t; /* Unskew the cell origin back to (x,y,z) space */
     const Y0 = j - t;
     const Z0 = k - t;
+
     const x0 = x - X0; /* The x,y,z distances from the cell origin */
     const y0 = y - Y0;
     const z0 = z - Z0;
@@ -529,12 +505,18 @@ export function sdnoise3(derivatives, x, y, z) {
     const x1 = x0 - i1 + G3; /* Offsets for second corner in (x,y,z) coords */
     const y1 = y0 - j1 + G3;
     const z1 = z0 - k1 + G3;
-    const x2 = x0 - i2 + 2.0 * G3; /* Offsets for third corner in (x,y,z) coords */
-    const y2 = y0 - j2 + 2.0 * G3;
-    const z2 = z0 - k2 + 2.0 * G3;
-    const x3 = x0 - 1.0 + 3.0 * G3; /* Offsets for last corner in (x,y,z) coords */
-    const y3 = y0 - 1.0 + 3.0 * G3;
-    const z3 = z0 - 1.0 + 3.0 * G3;
+
+    const G6 = G3 + G3;
+
+    const x2 = x0 - i2 + G6; /* Offsets for third corner in (x,y,z) coords */
+    const y2 = y0 - j2 + G6;
+    const z2 = z0 - k2 + G6;
+
+    const G9 = G6 + G3;
+
+    const x3 = x0 - 1.0 + G9; /* Offsets for last corner in (x,y,z) coords */
+    const y3 = y0 - 1.0 + G9;
+    const z3 = z0 - 1.0 + G9;
 
     /* Wrap the integer indices at 256, to avoid indexing perm[] out of bounds */
     const ii = i % 256;
@@ -632,16 +614,19 @@ export function sdnoise3(derivatives, x, y, z) {
     let dnoise_dz = temp0 * z0;
 
     const temp1 = t21 * t1 * (gx1 * x1 + gy1 * y1 + gz1 * z1);
+
     dnoise_dx += temp1 * x1;
     dnoise_dy += temp1 * y1;
     dnoise_dz += temp1 * z1;
 
     const temp2 = t22 * t2 * (gx2 * x2 + gy2 * y2 + gz2 * z2);
+
     dnoise_dx += temp2 * x2;
     dnoise_dy += temp2 * y2;
     dnoise_dz += temp2 * z2;
 
     const temp3 = t23 * t3 * (gx3 * x3 + gy3 * y3 + gz3 * z3);
+
     dnoise_dx += temp3 * x3;
     dnoise_dy += temp3 * y3;
     dnoise_dz += temp3 * z3;
@@ -699,10 +684,10 @@ export function sdnoise4(derivatives, x, y, z, w) {
     const zs = z + s;
     const ws = w + s;
 
-    let ii, i = fastfloor(xs);
-    let jj, j = fastfloor(ys);
-    let kk, k = fastfloor(zs);
-    let ll, l = fastfloor(ws);
+    let ii, i = xs | 0;
+    let jj, j = ys | 0;
+    let kk, k = zs | 0;
+    let ll, l = ws | 0;
 
     const t = (i + j + k + l) * G4; // Factor for 4D unskewing
     const X0 = i - t; // Unskew the cell origin back to (x,y,z,w) space

package/core/process/worker/WorkerBuilder.js

@@ -125,7 +125,11 @@ WorkerBuilder.prototype.build = function () {
         '   if(method === undefined){',
         '       sendError(new Error("API named \'"+methodName+"\' was not found."));',
         '   }else{',
-        '       method.apply(null,parameters).then(sendResult, sendError);',
+        '       try{',
+        '           method.apply(null,parameters).then(sendResult, sendError);',
+        '       }catch(e){',
+        '           sendError(e);',
+        '       }',
         '   }',
         '};'
     ]);

package/editor/process/symbolic/makeParticleEmitterSymbolicDisplay.js

@@ -1,10 +1,10 @@
 import { make3DSymbolicDisplay } from "./make3DSymbolicDisplay.js";
 import { Transform } from "../../../engine/ecs/transform/Transform.js";
 import { BoxBufferGeometry, Group, Line, LineBasicMaterial, Mesh, MeshBasicMaterial } from "three";
-import { EmissionShapeType } from "../../../engine/graphics/particles/particular/engine/emitter/ParticleLayer.js";
 import { buildThreeJSHelperEntity } from "./buildThreeJSHelperEntity.js";
 import { ParticleEmitter } from "../../../engine/graphics/particles/particular/engine/emitter/ParticleEmitter.js";
 import { makeHelperSphereGeometry } from "./makeHelperSphereGeometry.js";
+import { EmissionShapeType } from "../../../engine/graphics/particles/particular/engine/emitter/EmissionShapeType.js";
 
 /**
  *

package/editor/view/ecs/components/particles/ParticleLayerController.js

@@ -1,8 +1,4 @@
 import GuiControl from "../../../../../view/controller/controls/GuiControl.js";
-import {
-    EmissionFromType,
-    EmissionShapeType
-} from "../../../../../engine/graphics/particles/particular/engine/emitter/ParticleLayer.js";
 import DatGuiController from "../DatGuiController.js";
 import Vector3Control from "../../../../../view/controller/controls/Vector3Control.js";
 import NumericIntervalControl from "../../../../../view/controller/controls/NumericIntervalControl.js";
@@ -12,6 +8,8 @@ import { ParameterTrack } from "../../../../../engine/graphics/particles/particu
 import { ParameterTrackController } from "./ParameterTrackController.js";
 import { ParticleParameters } from "../../../../../engine/graphics/particles/particular/engine/emitter/ParticleParameters.js";
 import { ParameterLookupTable } from "../../../../../engine/graphics/particles/particular/engine/parameter/ParameterLookupTable.js";
+import { EmissionFromType } from "../../../../../engine/graphics/particles/particular/engine/emitter/EmissionFromType.js";
+import { EmissionShapeType } from "../../../../../engine/graphics/particles/particular/engine/emitter/EmissionShapeType.js";
 
 class ParticleLayerController extends GuiControl {
     /**

package/engine/Engine.d.ts

@@ -9,8 +9,12 @@ import {EntityManager} from "./ecs/EntityManager";
 import View from "../view/View";
 import Ticker from "./simulation/Ticker";
 
+export interface IEngineInitializationOptions {
+    entityManager?: EntityManager
+}
+
 export default class Engine {
-    constructor(platform: EnginePlatform);
+    constructor(platform: EnginePlatform, options?: IEngineInitializationOptions);
 
     public get viewStack(): View
 

package/engine/Engine.js

@@ -52,9 +52,10 @@ class Engine {
     /**
      *
      * @param {EnginePlatform} platform
+     * @param {EntityManager} [entityManager]
      * @constructor
      */
-    constructor(platform) {
+    constructor(platform, { entityManager } = {}) {
         assert.defined(platform, 'platform');
 
         /**
@@ -81,6 +82,21 @@ class Engine {
          */
         this.performance = new MetricCollection();
 
+        const using_external_entity_manager = entityManager !== undefined;
+
+        //setup entity component system
+        if (using_external_entity_manager) {
+            // external entity manager provided
+            this.entityManager = entityManager;
+        } else {
+            this.entityManager = new EntityManager();
+        }
+
+        /**
+         *
+         * @type {Ticker}
+         */
+        this.ticker = new Ticker();
 
         this.__performacne_monitor = new PeriodicConsolePrinter(15, () => {
             const metrics = this.performance;
@@ -112,6 +128,22 @@ class Engine {
             return `FPS: ${v_fps}, RENDER: ${v_render}ms, SIMULATION: ${v_sim}ms`;
         });
 
+
+        if (!using_external_entity_manager) {
+            // subscribe simulator to common ticker
+            this.ticker.subscribe(timeDelta => {
+                const t0 = performance.now();
+                this.entityManager.simulate(timeDelta);
+
+                const t1 = performance.now();
+                const duration = (t1 - t0) / 1000;
+
+                // record frame time
+                this.performance.get(METRIC_ID_SIMULATION).record(duration);
+            });
+        }
+
+
         this.initialize();
     }
 
@@ -168,9 +200,6 @@ class Engine {
         this.localization = new Localization();
         this.localization.setAssetManager(this.assetManager);
 
-        //setup entity component system
-        const em = this.entityManager = new EntityManager();
-
 
         const innerWidth = window.innerWidth / 3;
         const innerHeight = window.innerHeight / 3;
@@ -182,7 +211,7 @@ class Engine {
          *
          * @type {GraphicsEngine}
          */
-        const ge = this.graphics = new GraphicsEngine(this.camera, em);
+        const ge = this.graphics = new GraphicsEngine(this.camera, this.entityManager);
 
         try {
             ge.start();
@@ -208,18 +237,6 @@ class Engine {
          */
         this.gui = new GUIEngine();
 
-        this.ticker = new Ticker();
-        this.ticker.subscribe(timeDelta => {
-            const t0 = performance.now();
-            this.entityManager.simulate(timeDelta);
-
-            const t1 = performance.now();
-            const duration = (t1 - t0) / 1000;
-
-            // record frame time
-            this.performance.get(METRIC_ID_SIMULATION).record(duration);
-        });
-
         /**
          * @readonly
          * @type {SceneManager}
@@ -492,6 +509,7 @@ class Engine {
 
                 const frame_delay = (t1 - t0) / 1000;
 
+                // swap variables
                 t0 = t1;
 
                 // record metric

package/engine/EngineHarness.js

@@ -24,6 +24,8 @@ import WaterSystem from "./graphics/ecs/water/WaterSystem.js";
 import KeyboardCameraController from "./input/ecs/controllers/KeyboardCameraController.js";
 import { EngineConfiguration } from "./EngineConfiguration.js";
 import { JsonAssetLoader } from "./asset/loaders/JsonAssetLoader.js";
+import { logger } from "./logging/GlobalLogger.js";
+import { ConsoleLoggerBackend } from "./logging/ConsoleLoggerBackend.js";
 
 /**
  *
@@ -77,6 +79,8 @@ export class EngineHarness {
 
         window.engine = this.engine;
 
+        logger.addBackend(new ConsoleLoggerBackend());
+
         this.p = null;
     }
 
@@ -321,7 +325,7 @@ export class EngineHarness {
 
     /**
      *
-     * @param {number} cameraEntity
+     * @param {number} [cameraEntity]
      * @param {Engine} engine
      * @param {number} [sensitivity]
      * @param {Element} domElement
@@ -335,6 +339,10 @@ export class EngineHarness {
                                                   sensitivity = 0.01
                                               }) {
 
+        if (cameraEntity === undefined) {
+            cameraEntity = ecd.getAnyComponent(Camera).entity;
+        }
+
         const em = engine.entityManager;
 
         if (em.getSystem(InputControllerSystem) === null) {

package/engine/animation/AnimationUtils.js

@@ -164,8 +164,16 @@ export function removeEntityWithMeshParticlesEffect(
     //prevent further interactions
     removeComponentsExcept(ecd, entity, [Mesh, ParticleEmitter, Trail2D, Transform]);
 
+    /**
+     *
+     * @type {Transform}
+     */
     const originalTransform = ecd.getComponent(entity, Transform);
 
+    if (originalTransform === undefined) {
+        throw new Error(`entity ${entity} doesn't have Transform`);
+    }
+
     //create particle emitter
     const effectBuilder = new EntityBuilder();
     const effectEntity = effectBuilder