@woosh/meep-engine 2.39.7 → 2.39.11

package/core/geom/3d/triangle/computeTriangleRayIntersection.js

@@ -1,4 +1,5 @@
 import { v3_dot } from "../../v3_dot.js";
+import { assert } from "../../../assert.js";
 
 /**
  * NOTE: adapted from http://www.geometrictools.com/GTEngine/Include/Mathematics/GteIntrRay3Triangle3.h
@@ -29,6 +30,44 @@ export function computeTriangleRayIntersection(
     bx, by, bz,
     cx, cy, cz
 ) {
+    assert.isNumber(ax,'ax');
+    assert.isNumber(ay,'ay');
+    assert.isNumber(az,'az');
+
+    assert.isNumber(bx,'bx');
+    assert.isNumber(by,'by');
+    assert.isNumber(bz,'bz');
+
+    assert.isNumber(cx,'cx');
+    assert.isNumber(cy,'cy');
+    assert.isNumber(cz,'cz');
+
+    // nan checks
+    assert.notNaN(ax,'ax');
+    assert.notNaN(ay,'ay');
+    assert.notNaN(az,'az');
+
+    assert.notNaN(bx,'bx');
+    assert.notNaN(by,'by');
+    assert.notNaN(bz,'bz');
+
+    assert.notNaN(cx,'cx');
+    assert.notNaN(cy,'cy');
+    assert.notNaN(cz,'cz');
+
+    // finate number check
+    assert.isFiniteNumber(ax,'ax');
+    assert.isFiniteNumber(ay,'ay');
+    assert.isFiniteNumber(az,'az');
+
+    assert.isFiniteNumber(bx,'bx');
+    assert.isFiniteNumber(by,'by');
+    assert.isFiniteNumber(bz,'bz');
+
+    assert.isFiniteNumber(cx,'cx');
+    assert.isFiniteNumber(cy,'cy');
+    assert.isFiniteNumber(cz,'cz');
+
 
     // edge1 = a - b
     const edge1_x = bx - ax;

package/engine/Engine.js

@@ -514,8 +514,4 @@ class Engine {
  */
 Engine.prototype.isEngine = true;
 
-function printError(reason) {
-    logger.error(reason);
-}
-
 export default Engine;

package/engine/ecs/terrain/ecs/Terrain.d.ts

@@ -0,0 +1,10 @@
+import Engine from "../../../Engine";
+import {Texture} from "three";
+
+export default class Terrain {
+    fromJSON(json: any, engine: Engine): void;
+
+    toJSON(): any
+
+    buildLightMap(quality: number): Promise<Texture>
+}

package/engine/ecs/terrain/ecs/TerrainSystem.d.ts

@@ -1,7 +1,8 @@
 import {System} from "../../System";
 import {GraphicsEngine} from "../../../graphics/GraphicsEngine";
 import {AssetManager} from "../../../asset/AssetManager";
+import Terrain from "./Terrain";
 
-export default class TerrainSystem extends System {
+export default class TerrainSystem extends System<Terrain> {
     constructor(graphics: GraphicsEngine, assetManager: AssetManager)
 }

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

@@ -23,6 +23,9 @@ export const ProjectionType = {
     Orthographic: "orthographic"
 };
 
+/**
+ * @class
+ */
 export class Camera {
     constructor() {
         /**
@@ -176,7 +179,7 @@ export class Camera {
         // assert.ok(y >= -1, `Y(=${y}) must be greater than or equal to -1.0, not a clip-space coordinate`);
         // assert.ok(y <= 1, `Y(=${y}) must be less than or equal to 1.0, not a clip-space coordinate`);
 
-        if (camera.isPerspectiveCamera) {
+        if (camera.isPerspectiveCamera || camera.isOrthographicCamera) {
             scratch_v3_1.setFromMatrixPosition(camera.matrixWorld.elements);
 
             scratch_v3_0.set(x, y, 0.5);
@@ -197,9 +200,7 @@ export class Camera {
             source.copy(scratch_v3_1);
             direction.copy(scratch_v3_0);
 
-        } else if (camera.isOrthographicCamera) {
-            throw new Error('Unsupported camera type: "Orthographic" ');
-        } else {
+        }  else {
             throw new Error('Unsupported camera type');
         }
     }

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

@@ -70,6 +70,7 @@ import { BasicMaterialDefinition } from "./tube/BasicMaterialDefinition.js";
 import '../../../../../../../css/game.scss';
 import { GizmoRenderingPlugin } from "../../render/gizmo/GizmoRenderingPlugin.js";
 import { PathNormalType } from "./tube/PathNormalType.js";
+import { Camera, ProjectionType } from "../camera/Camera.js";
 
 const engineHarness = new EngineHarness();
 
@@ -427,6 +428,11 @@ function makePath({
 function main(engine) {
     EngineHarness.buildBasics({ engine });
 
+    const ecd = engine.entityManager.dataset;
+
+    const cam = ecd.getAnyComponent(Camera);
+    // cam.component.projectionType.set(ProjectionType.Orthographic);
+
     makePath({
         points: [
             3, 1, 1,
@@ -437,7 +443,7 @@ function main(engine) {
             3, 1, 8
         ],
         interp: InterpolationType.Linear
-    }).build(engine.entityManager.dataset);
+    }).build(ecd);
 
     makePath({
         points: [
@@ -447,7 +453,7 @@ function main(engine) {
             16.719999313354492, 3.130000114440918, -6.889999866485596
         ],
         interp: InterpolationType.Linear
-    }).build(engine.entityManager.dataset);
+    }).build(ecd);
 }
 
 init(engineHarness);

package/engine/graphics/ecs/path/tube/TubePathStyle.js

@@ -116,6 +116,23 @@ export class TubePathStyle {
         return r;
     }
 
+    /**
+     *
+     * @param {string|{r:number,g:number,b:number}} color
+     * @param material_type
+     * @param material
+     * @param opacity
+     * @param width
+     * @param radial_resolution
+     * @param resolution
+     * @param cast_shadow
+     * @param receive_shadow
+     * @param path_mask
+     * @param cap_type
+     * @param shape
+     * @param path_normal
+     * @param path_normal_type
+     */
     fromJSON({
                  color = DEFAULT_COLOR,
                  material_type,
@@ -148,7 +165,7 @@ export class TubePathStyle {
         assert.greaterThanOrEqual(path_mask.length, 2, 'path_mask length bust be at least 2');
         assert.ok(path_mask.length % 2 === 0, 'path_mask length bust be multiple of 2');
         assert.enum(cap_type, CapType, 'cap_type');
-        assert.enum(path_normal_type, 'path_normal_type');
+        assert.enum(path_normal_type, PathNormalType, 'path_normal_type');
 
         if (shape === undefined) {
             // legacy API, using circle

package/engine/graphics/geometry/buffered/query/RaycastNearestHitComputingVisitor.js

@@ -4,6 +4,7 @@ import Vector3 from "../../../../../core/geom/Vector3.js";
 import { computeTriangleRayIntersection } from "../../../../../core/geom/3d/triangle/computeTriangleRayIntersection.js";
 import { GeometrySpatialAcceleratorVisitor } from "./GeometryVisitor.js";
 import { aabb3_intersects_ray } from "../../../../../core/bvh2/aabb3/aabb3_intersects_ray.js";
+import { assert } from "../../../../../core/assert.js";
 
 export class RaycastNearestHitComputingVisitor extends GeometrySpatialAcceleratorVisitor {
     constructor() {
@@ -18,14 +19,14 @@ export class RaycastNearestHitComputingVisitor extends GeometrySpatialAccelerato
         this.__nearest_distance = Number.POSITIVE_INFINITY;
 
         /**
-         *
+         * @readonly
          * @type {SurfacePoint3}
          * @private
          */
         this.__nearest_hit = new SurfacePoint3();
 
         /**
-         *
+         * @readonly
          * @type {SurfacePoint3}
          * @private
          */
@@ -39,7 +40,18 @@ export class RaycastNearestHitComputingVisitor extends GeometrySpatialAccelerato
          */
         this.__hit_found = false;
 
+        /**
+         * @readonly
+         * @type {Vector3}
+         * @private
+         */
         this.__ray_origin = new Vector3();
+
+        /**
+         * @readonly
+         * @type {Vector3}
+         * @private
+         */
         this.__ray_direction = new Vector3();
     }
 
@@ -98,6 +110,8 @@ export class RaycastNearestHitComputingVisitor extends GeometrySpatialAccelerato
 
             const indices = this.__buffer_indices;
 
+            assert.lessThan(index3 + 2, indices.length, 'triangle index overflow, possibly geometry changed but tree was not rebuilt?');
+
             const a = indices[index3];
             const b = indices[index3 + 1];
             const c = indices[index3 + 2];
@@ -111,6 +125,10 @@ export class RaycastNearestHitComputingVisitor extends GeometrySpatialAccelerato
             const b_address = b * stride + offset;
             const c_address = c * stride + offset;
 
+            assert.lessThan(a_address + 2, vertices.length, 'a-vertex overflow');
+            assert.lessThan(b_address + 2, vertices.length, 'b-vertex overflow');
+            assert.lessThan(c_address + 2, vertices.length, 'c-vertex overflow');
+
             const ax = vertices[a_address];
             const ay = vertices[a_address + 1];
             const az = vertices[a_address + 2];
@@ -123,8 +141,10 @@ export class RaycastNearestHitComputingVisitor extends GeometrySpatialAccelerato
             const cy = vertices[c_address + 1];
             const cz = vertices[c_address + 2];
 
+            const temp_hit = this.__temp_hit;
+
             if (computeTriangleRayIntersection(
-                this.__temp_hit,
+                temp_hit,
                 rayOrigin.x,
                 rayOrigin.y,
                 rayOrigin.z,
@@ -135,10 +155,10 @@ export class RaycastNearestHitComputingVisitor extends GeometrySpatialAccelerato
                 bx, by, bz,
                 cx, cy, cz
             )) {
-                const d = this.__temp_hit.position.distanceSqrTo(rayOrigin);
+                const d = temp_hit.position.distanceSqrTo(rayOrigin);
 
                 if (d < this.__nearest_distance) {
-                    this.__nearest_hit.copy(this.__temp_hit);
+                    this.__nearest_hit.copy(temp_hit);
                     this.__nearest_distance = d;
 
                     this.__hit_found = true;

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