@woosh/meep-engine 2.50.0 → 2.50.2

package/src/core/geom/3d/plane/is_point_within_planes.js

@@ -2,7 +2,7 @@ import { v3_distance_above_plane } from "../../v3_distance_above_plane.js";
 import { EPSILON } from "../../../math/EPSILON.js";
 
 /**
- *
+ * Checks if point lies in a volume bound by a number of planes, such a camera frustum
  * @param {number} x
  * @param {number} y
  * @param {number} z

package/src/core/geom/3d/plane/lerp_planes_to_array.js

@@ -48,4 +48,6 @@ function lerp_planes_to_array(
     const n_z = a_normal_z * scale_0 + b_normal_z * scale_1;
 
     //compute R
+
+    throw new Error("Not Implemented");
 }

package/src/core/geom/3d/plane/{plane_computeConvex3PlaneIntersection.js → plane3_compute_convex_3_plane_intersection.js}

@@ -23,7 +23,7 @@ import { v3_dot } from "../../v3_dot.js";
  * @param {number} c_constant
  * @returns {boolean} true if planes intersect, false otherwise
  */
-export function plane_computeConvex3PlaneIntersection(
+export function plane3_compute_convex_3_plane_intersection(
     result, result_offset,
     a_normal_x, a_normal_y, a_normal_z, a_constant,
     b_normal_x, b_normal_y, b_normal_z, b_constant,

package/src/core/geom/3d/plane/{plane3_computeLineSegmentIntersection.js → plane3_compute_line_segment_intersection.js}

@@ -16,7 +16,7 @@ import { v3_dot } from "../../v3_dot.js";
  * @param {number} dist
  * @returns {boolean}
  */
-export function plane3_computeLineSegmentIntersection(
+export function plane3_compute_line_segment_intersection(
     result, result_offset,
     x0, y0, z0,
     x1, y1, z1,

package/src/core/geom/3d/plane/{computePlanePlaneIntersection.js → plane3_compute_plane_intersection.js}

@@ -3,21 +3,25 @@
  Algorithm taken from http://geomalgorithms.com/a05-_intersect-1.html. See the
  section 'Intersection of 2 Planes' and specifically the subsection
  (A) Direct Linear Equation
+ TODO consolidate with {@link plane3_intersect_plane} as they seem to do the same thing
  @param {Plane} p1
  @param {Plane} p2
- @param {Vector3} point
- @param {Vector3} direction
+ @param {Vector3} out_point
+ @param {Vector3} out_direction
  @returns {boolean}
  */
-export function computePlanePlaneIntersection(p1, p2, point, direction) {
+export function plane3_compute_plane_intersection(
+    p1, p2,
+    out_point, out_direction
+) {
 
     // the cross product gives us the direction of the line at the intersection
     // of the two planes, and gives us an easy way to check if the two planes
     // are parallel - the cross product will have zero magnitude
 
-    direction.crossVectors(p1.normal, p2.normal);
+    out_direction.crossVectors(p1.normal, p2.normal);
 
-    const magnitude = direction.lengthSqr();
+    const magnitude = out_direction.lengthSqr();
 
     if (magnitude === 0) {
         return false;
@@ -28,16 +32,16 @@ export function computePlanePlaneIntersection(p1, p2, point, direction) {
     // to set as zero by seeing which has the largest absolute value in the
     // directional vector
 
-    const X = Math.abs(direction.x);
-    const Y = Math.abs(direction.y);
-    const Z = Math.abs(direction.z);
+    const X = Math.abs(out_direction.x);
+    const Y = Math.abs(out_direction.y);
+    const Z = Math.abs(out_direction.z);
 
     if (Z >= X && Z >= Y) {
-        solveIntersectingPoint('z', 'x', 'y', p1, p2, point);
+        solveIntersectingPoint('z', 'x', 'y', p1, p2, out_point);
     } else if (Y >= Z && Y >= X) {
-        solveIntersectingPoint('y', 'z', 'x', p1, p2, point);
+        solveIntersectingPoint('y', 'z', 'x', p1, p2, out_point);
     } else {
-        solveIntersectingPoint('x', 'y', 'z', p1, p2, point);
+        solveIntersectingPoint('x', 'y', 'z', p1, p2, out_point);
     }
 
     return true;

package/src/core/geom/3d/plane/{computePlaneLineIntersection.js → plane3_compute_ray_intersection.js}

@@ -15,7 +15,7 @@ import { v3_dot } from "../../v3_dot.js";
  * @param {number} dist Plane distance
  * @returns {boolean} true if intersection is found, false otherwise
  */
-export function computePlaneLineIntersection(
+export function plane3_compute_ray_intersection(
     out,
     originX, originY, originZ,
     directionX, directionY, directionZ,
@@ -29,6 +29,10 @@ export function computePlaneLineIntersection(
 
         const t = -p / denom;
 
+        if (t < 0) {
+            return false;
+        }
+
         out.set(
             directionX * t + originX,
             directionY * t + originY,

package/src/core/geom/3d/plane/plane3_intersect_plane.js

@@ -3,6 +3,20 @@ import Vector3 from "../../Vector3.js";
 const v0 = new Vector3();
 const v1 = new Vector3();
 
+/**
+ *
+ * @param {Vector3} result_point
+ * @param {Vector3} result_direction
+ * @param {number} a_normal_x
+ * @param {number} a_normal_y
+ * @param {number} a_normal_z
+ * @param {number} a_constant
+ * @param {number} b_normal_x
+ * @param {number} b_normal_y
+ * @param {number} b_normal_z
+ * @param {number} b_constant
+ * @return {boolean}
+ */
 export function plane3_intersect_plane(
     result_point,
     result_direction,

package/src/core/geom/3d/plane/{plane_three_compute_convex3_plane_intersection.js → plane3_three_compute_convex_3_plane_intersection.js}

@@ -1,7 +1,7 @@
-import { plane_computeConvex3PlaneIntersection } from "./plane_computeConvex3PlaneIntersection.js";
+import { plane3_compute_convex_3_plane_intersection } from "./plane3_compute_convex_3_plane_intersection.js";
 
 /**
- *
+ * Works with THREE.js Plane representations as inputs
  * @param {number[]} result
  * @param {number} result_offset
  * @param {Plane} a
@@ -9,12 +9,15 @@ import { plane_computeConvex3PlaneIntersection } from "./plane_computeConvex3Pla
  * @param {Plane} c
  * @returns {boolean}
  */
-export function plane_three_computeConvex3PlaneIntersection(result, result_offset, a, b, c) {
+export function plane3_three_compute_convex_3_plane_intersection(
+    result, result_offset,
+    a, b, c
+) {
     const a_normal = a.normal;
     const b_normal = b.normal;
     const c_normal = c.normal;
 
-    return plane_computeConvex3PlaneIntersection(
+    return plane3_compute_convex_3_plane_intersection(
         result,
         result_offset,
         a_normal.x, a_normal.y, a_normal.z, a.constant,

package/src/core/geom/3d/plane/planeRayIntersection.js

@@ -1,4 +1,4 @@
-import { computePlaneRayIntersection } from "./computePlaneRayIntersection.js";
+import { plane3_compute_ray_intersection } from "./plane3_compute_ray_intersection.js";
 
 /**
  *
@@ -10,5 +10,5 @@ import { computePlaneRayIntersection } from "./computePlaneRayIntersection.js";
  * @returns {boolean} true if intersection is found, false otherwise
  */
 export function planeRayIntersection(out, origin, direction, normal, dist) {
-    return computePlaneRayIntersection(out, origin.x, origin.y, origin.z, direction.x, direction.y, direction.z, normal.x, normal.y, normal.z, dist)
+    return plane3_compute_ray_intersection(out, origin.x, origin.y, origin.z, direction.x, direction.y, direction.z, normal.x, normal.y, normal.z, dist)
 }

package/src/core/geom/3d/tetrahedra/compute_bounding_simplex_3d.js

@@ -1,7 +1,7 @@
 import { v3_dot } from "../../v3_dot.js";
 import { min2 } from "../../../math/min2.js";
 import { max2 } from "../../../math/max2.js";
-import { plane_computeConvex3PlaneIntersection } from "../plane/plane_computeConvex3PlaneIntersection.js";
+import { plane3_compute_convex_3_plane_intersection } from "../plane/plane3_compute_convex_3_plane_intersection.js";
 
 /**
  * Planes used to bound the simplex
@@ -152,25 +152,25 @@ export function compute_bounding_simplex_3d(
     min_d -= padding;
 
     // let's compute intersection points for each tri-plane combination to find simplex corners
-    plane_computeConvex3PlaneIntersection(
+    plane3_compute_convex_3_plane_intersection(
         result, result_offset,
         SIMPLEX_PROJECTION_AXES[0], SIMPLEX_PROJECTION_AXES[1], SIMPLEX_PROJECTION_AXES[2], -min_a,
         SIMPLEX_PROJECTION_AXES[3], SIMPLEX_PROJECTION_AXES[4], SIMPLEX_PROJECTION_AXES[5], -min_b,
         SIMPLEX_PROJECTION_AXES[9], SIMPLEX_PROJECTION_AXES[10], SIMPLEX_PROJECTION_AXES[11], -min_d
     );
-    plane_computeConvex3PlaneIntersection(
+    plane3_compute_convex_3_plane_intersection(
         result, result_offset + 3,
         SIMPLEX_PROJECTION_AXES[3], SIMPLEX_PROJECTION_AXES[4], SIMPLEX_PROJECTION_AXES[5], -min_b,
         SIMPLEX_PROJECTION_AXES[6], SIMPLEX_PROJECTION_AXES[7], SIMPLEX_PROJECTION_AXES[8], -min_c,
         SIMPLEX_PROJECTION_AXES[9], SIMPLEX_PROJECTION_AXES[10], SIMPLEX_PROJECTION_AXES[11], -min_d
     );
-    plane_computeConvex3PlaneIntersection(
+    plane3_compute_convex_3_plane_intersection(
         result, result_offset + 6,
         SIMPLEX_PROJECTION_AXES[0], SIMPLEX_PROJECTION_AXES[1], SIMPLEX_PROJECTION_AXES[2], -min_a,
         SIMPLEX_PROJECTION_AXES[3], SIMPLEX_PROJECTION_AXES[4], SIMPLEX_PROJECTION_AXES[5], -min_b,
         SIMPLEX_PROJECTION_AXES[6], SIMPLEX_PROJECTION_AXES[7], SIMPLEX_PROJECTION_AXES[8], -min_c
     );
-    plane_computeConvex3PlaneIntersection(
+    plane3_compute_convex_3_plane_intersection(
         result, result_offset + 9,
         SIMPLEX_PROJECTION_AXES[6], SIMPLEX_PROJECTION_AXES[7], SIMPLEX_PROJECTION_AXES[8], -min_c,
         SIMPLEX_PROJECTION_AXES[0], SIMPLEX_PROJECTION_AXES[1], SIMPLEX_PROJECTION_AXES[2], -min_a,

package/src/core/geom/Vector3.d.ts

@@ -69,14 +69,16 @@ export default class Vector3 implements Vector3Like {
 
     clone(): Vector3
 
-    equals(other:Vector3Like):boolean
+    equals(other: Vector3Like): boolean
 
-    roughlyEquals(other:Vector3Like,tolerance?:number):boolean
+    roughlyEquals(other: Vector3Like, tolerance?: number): boolean
 
     normalize(): void
 
     length(): number
 
+    lengthSqr(): number
+
     lerpVectors(a: Vector3Like, b: Vector3Like, fraction: number): void
 
     distanceTo(other: Vector3Like): number

package/src/engine/ecs/EntityBlueprint.d.ts

@@ -1,3 +1,17 @@
+import EntityBuilder from "./EntityBuilder";
+
+interface Type<T> extends Function {
+    new(...args: any[]): T;
+}
+
 export class EntityBlueprint {
     static from(components: any[]): EntityBlueprint
+
+    add<T>(component: T): void
+
+    addJSON<T>(klass: Type<T>, json: any): void
+
+    clear(): void
+
+    build(seed?: object): EntityBuilder
 }

package/src/engine/ecs/EntityBlueprint.js

@@ -140,10 +140,10 @@ export class EntityBlueprint {
 
 
     /**
-     *
+     * @param {object} [templateSeed]
      * @return {EntityBuilder}
      */
-    buildEntityBuilder(templateSeed) {
+    build(templateSeed) {
         const eb = new EntityBuilder();
 
         this.componentnts.forEach((template, ComponentClass) => {

package/src/engine/ecs/EntityBlueprint.spec.js

@@ -0,0 +1,52 @@
+import { EntityBlueprint } from "./EntityBlueprint.js";
+import EntityBuilder from "./EntityBuilder.js";
+
+test("constructor does not throw", () => {
+
+    expect(() => new EntityBlueprint()).not.toThrow();
+
+});
+
+test("build empty", () => {
+    const blueprint = new EntityBlueprint();
+
+    const entity = blueprint.build();
+
+    expect(entity).toBeDefined();
+    expect(entity).toBeInstanceOf(EntityBuilder);
+    expect(entity.count).toEqual(0);
+});
+
+class DummyComponent {
+    a = 0
+
+    fromJSON({ a }) {
+        this.a = a;
+    }
+}
+
+test("a copy of the added component ends up on built entity", () => {
+
+    const blueprint = new EntityBlueprint();
+
+    blueprint.addJSON(DummyComponent, { a: 7 });
+
+    const entity = blueprint.build();
+
+    const retrieved = entity.getComponent(DummyComponent);
+
+    expect(retrieved).toBeInstanceOf(DummyComponent);
+    expect(retrieved.a).toEqual(7);
+});
+
+test("seed template", () => {
+    const blueprint = new EntityBlueprint();
+
+    blueprint.addJSON(DummyComponent, { a: '$x' });
+
+    const entity = blueprint.build({ x: 13 });
+
+    const component = entity.getComponent(DummyComponent);
+
+    expect(component.a).toEqual(13);
+});

package/src/engine/ecs/EntityBuilder.js

@@ -125,6 +125,14 @@ class EntityBuilder {
         }
     }
 
+    /**
+     * Number of attached components
+     * @return {number}
+     */
+    get count() {
+        return this.element.length;
+    }
+
     /**
      * @template T
      * @param {T} componentInstance

package/src/engine/ecs/EntityManager.d.ts

@@ -8,6 +8,7 @@ interface Type<T> extends Function {
 
 export class EntityManager {
     dataset: EntityComponentDataset
+    fixedUpdateStepSize: number
 
     getComponentTypeMap(): any[]
 

package/src/engine/ecs/EntityManager.js

@@ -329,6 +329,9 @@ EntityManager.prototype.simulate = function (timeDelta) {
     const fixed_step = this.fixedUpdateStepSize;
     const accumulatedTime = this.systemAccumulatedFixedStepTime;
 
+    assert.notNaN(fixed_step, 'fixed_step');
+    assert.greaterThan(fixed_step, 0, 'fixed_step must be greater than 0');
+
     for (let i = 0; i < system_count; i++) {
 
         const system = systems[i];
@@ -337,7 +340,7 @@ EntityManager.prototype.simulate = function (timeDelta) {
             let accumulated_time = accumulatedTime.get(system) + timeDelta;
 
 
-            while (accumulated_time > fixed_step) {
+            while (accumulated_time >= fixed_step) {
 
                 try {
                     system.fixedUpdate(fixed_step)
@@ -458,9 +461,10 @@ function validateSystem(system) {
 /**
  * If the {@link EntityManager} is already started, the system will be started automatically before being added
  * @param {System} system
+ * @returns {Promise}
  * @throws {IllegalStateException}
  */
-EntityManager.prototype.addSystem = async function (system) {
+EntityManager.prototype.addSystem = function (system) {
     assert.defined(system, "system");
     assert.isInstanceOf(system, System, 'system', 'System');
 
@@ -469,7 +473,7 @@ EntityManager.prototype.addSystem = async function (system) {
     if (existing !== null) {
         if (existing === system) {
             //system already added, do nothing
-            return;
+            return Promise.resolve();
         } else {
             throw new IllegalStateException(`Another instance of system '${computeSystemName(system)}' is already registered`);
         }
@@ -508,7 +512,7 @@ EntityManager.prototype.addSystem = async function (system) {
     if (this.state === EntityManagerState.Running) {
         //initialize the system
         startup_promise = new Promise((resolve, reject) => {
-            system.startup(this, resolve, reject);
+            this.startSystem(system, resolve, reject);
         });
     } else {
         startup_promise = Promise.resolve();
@@ -526,13 +530,13 @@ EntityManager.prototype.addSystem = async function (system) {
 
     this.on.systemAdded.send1(system);
 
-    await startup_promise;
+    return startup_promise;
 };
 
 /**
  *
  * @param {System} system
- * @returns {boolean}
+ * @returns {Promise<boolean>}
  */
 EntityManager.prototype.removeSystem = async function (system) {
     assert.defined(system, "system");
@@ -573,11 +577,13 @@ EntityManager.prototype.removeSystem = async function (system) {
     this.systemAccumulatedFixedStepTime.delete(system);
 
     this.on.systemRemoved.send1(system);
+
+    return true;
 };
 
 
 /**
- *
+ * @private
  * @param {System} system
  * @param {function(system: System)} successCallback
  * @param {function(reason:*)} errorCallback
@@ -614,13 +620,15 @@ EntityManager.prototype.stopSystem = function (system, successCallback, errorCal
 };
 
 /**
- *
+ * @private
  * @param {System} system
  * @param {function(system: System)} successCallback
  * @param {function(reason:*)} errorCallback
  */
 EntityManager.prototype.startSystem = function (system, successCallback, errorCallback) {
     assert.defined(system, "system");
+    assert.isFunction(successCallback, "successCallback");
+    assert.isFunction(errorCallback, "errorCallback");
 
     if (system.state.getValue() === System.State.RUNNING) {
         //system is already running

package/src/engine/ecs/EntityManager.spec.js

@@ -1,6 +1,7 @@
 import { EntityManager } from "./EntityManager.js";
-import { System } from "./System.js";
+import { System, SystemState } from "./System.js";
 import { jest } from '@jest/globals';
+import { IllegalStateException } from "../../core/fsm/exceptions/IllegalStateException.js";
 
 /**
  *
@@ -97,3 +98,63 @@ test("call to 'simulate' propagate to registered system", () => {
             expect(update).toHaveBeenLastCalledWith(7);
         });
 });
+
+
+test("call to 'simulate' ticks fixed update correctly", async () => {
+
+    const dummySystem = new DummySystem();
+    const fixedUpdate = jest.spyOn(dummySystem, 'fixedUpdate');
+
+    const em = await makeEm([dummySystem]);
+
+    em.fixedUpdateStepSize = 1.1;
+
+    em.simulate(3.3001);
+
+    expect(fixedUpdate).toHaveBeenCalledTimes(3);
+    expect(fixedUpdate).toHaveBeenLastCalledWith(1.1);
+});
+
+test("hasSystem", async () => {
+
+    const dummySystem = new DummySystem();
+    const em = await makeEm([]);
+
+    expect(em.hasSystem(DummySystem)).toBe(false);
+
+    await em.addSystem(dummySystem);
+
+    expect(em.hasSystem(DummySystem)).toBe(true);
+});
+
+test("addSystem", async () => {
+    const em = await makeEm([]);
+
+    const s1 = new DummySystem();
+
+    await em.addSystem(s1);
+
+    expect(s1.state.get()).toEqual(SystemState.RUNNING)
+
+    // system is already added, expect silent return
+    expect(() => em.addSystem(s1)).not.toThrow();
+
+    // 2 systems of the same class are not allowed
+    expect(() => em.addSystem(new DummySystem())).toThrow(IllegalStateException);
+});
+
+test("removeSystem", async () => {
+
+    const system = new DummySystem();
+
+    const em = await makeEm([system]);
+
+    expect(await em.removeSystem(system)).toBe(true);
+
+    expect(em.hasSystem(DummySystem)).toBe(false);
+
+    expect(system.state.get()).toEqual(SystemState.STOPPED);
+
+    // Try again, this time we expect nothing to happen
+    expect(await em.removeSystem(system)).toEqual(false);
+});

package/src/engine/ecs/System.js

@@ -155,13 +155,19 @@ Object.defineProperties(System.prototype, {
  * @readonly
  * @enum {number}
  */
-System.State = {
+export const SystemState = {
     INITIAL: 0,
     STARTING: 1,
     RUNNING: 2,
     STOPPING: 3,
     STOPPED: 4
-};
+}
+
+/**
+ * @readonly
+ * @deprecated use {@link SystemState} directly instead
+ */
+System.State = SystemState;
 
 /**
  *

package/src/engine/ecs/{Blueprint.js → storage/json/Blueprint.js}

@@ -4,7 +4,7 @@
 
 
 import EntityFactory from './EntityFactory.js';
-import { FunctionCompiler } from "../../core/function/FunctionCompiler.js";
+import { FunctionCompiler } from "../../../../core/function/FunctionCompiler.js";
 
 function Blueprint() {
     this.element = [];

package/src/engine/ecs/{EntityFactory.js → storage/json/EntityFactory.js}

@@ -1,7 +1,7 @@
 /**
  * Created by Alex on 25/08/2015.
  */
-import { FunctionCompiler } from "../../core/function/FunctionCompiler.js";
+import { FunctionCompiler } from "../../../../core/function/FunctionCompiler.js";
 
 
 function ComponentSpec(options) {

package/src/engine/ecs/storage/{JSONDeSerializer.js → json/JSONDeSerializer.js}

@@ -3,10 +3,10 @@
  */
 
 
-import Blueprint from '../Blueprint.js';
-import { assert } from "../../../core/assert.js";
-import { countTask } from "../../../core/process/task/util/countTask.js";
-import { emptyTask } from "../../../core/process/task/util/emptyTask.js";
+import Blueprint from './Blueprint.js';
+import { assert } from "../../../../core/assert.js";
+import { countTask } from "../../../../core/process/task/util/countTask.js";
+import { emptyTask } from "../../../../core/process/task/util/emptyTask.js";
 
 /**
  *

package/src/engine/ecs/storage/json/README.md

@@ -0,0 +1,5 @@
+This is a framework for json serialization/deserialization of `EntityComponentDataset`s
+
+Meep has been using binary format for datasets since ~2017
+
+This is largely obsolete.

package/src/engine/graphics/ecs/camera/Camera.js

@@ -14,7 +14,7 @@ import { frustum_from_camera } from "./frustum_from_camera.js";
 import { invertQuaternionOrientation } from "./InvertQuaternionOrientation.js";
 import { v3_distance_above_plane } from "../../../../core/geom/v3_distance_above_plane.js";
 import { ProjectionType } from "./ProjectionType.js";
-import { computePlaneRayIntersection } from "../../../../core/geom/3d/plane/computePlaneRayIntersection.js";
+import { plane3_compute_ray_intersection } from "../../../../core/geom/3d/plane/plane3_compute_ray_intersection.js";
 
 /**
  * @class
@@ -250,7 +250,7 @@ export class Camera {
 
         assert.defined(plane, 'plane');
 
-        computePlaneRayIntersection(
+        plane3_compute_ray_intersection(
             out,
             origin_x, origin_y, origin_z,
             direction_x, direction_y, direction_z,

package/src/engine/graphics/ecs/mesh-v2/ShadedGeometry.spec.js

@@ -0,0 +1,5 @@
+import { ShadedGeometry } from "./ShadedGeometry.js";
+
+test("constructor does not throw", () => {
+    expect(() => new ShadedGeometry()).not.toThrow()
+});

package/src/engine/graphics/ecs/path/entity/EntityPath.js

@@ -86,7 +86,7 @@ export class EntityPath {
         const blueprint = def.blueprint;
 
         marker.offset = offset;
-        marker.entity = blueprint.buildEntityBuilder({});
+        marker.entity = blueprint.build({});
         marker.definition = def;
 
         this.__position_marker(marker);