@woosh/meep-engine 2.60.0 → 2.60.1

package/build/meep.module.js

@@ -69552,6 +69552,84 @@ function computeSystemName(system) {
     return system.constructor.name;
 }
 
+/**
+ *
+ * @param {Vector3} out Result will be written here
+ * @param {number} originX Ray origin
+ * @param {number} originY Ray origin
+ * @param {number} originZ Ray origin
+ * @param {number} directionX Ray direction
+ * @param {number} directionY Ray direction
+ * @param {number} directionZ Ray direction
+ * @param {number} normalX Plane normal
+ * @param {number} normalY Plane normal
+ * @param {number} normalZ Plane normal
+ * @param {number} dist Plane distance
+ * @returns {boolean} true if intersection is found, false otherwise
+ */
+function plane3_compute_ray_intersection(
+    out,
+    originX, originY, originZ,
+    directionX, directionY, directionZ,
+    normalX, normalY, normalZ, dist
+) {
+    const denom = v3_dot(directionX, directionY, directionZ, normalX, normalY, normalZ);
+
+    const p = v3_dot(normalX, normalY, normalZ, originX, originY, originZ) + dist;
+
+    if (denom !== 0) {
+
+        const t = -p / denom;
+
+        if (t < 0) {
+            return false;
+        }
+
+        out.set(
+            directionX * t + originX,
+            directionY * t + originY,
+            directionZ * t + originZ
+        );
+
+        return true;
+
+    } else {
+
+        if (p === 0) {
+
+            out.set(originX, originY, originZ);
+
+            return true;
+
+        } else {
+
+            //no intersection
+            return false;
+
+        }
+
+    }
+}
+
+/**
+ * Orthogonal distance of a point to a plane, the distance is positive when the point lies above the plane and negative when the point is below
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @param {number} normalX
+ * @param {number} normalY
+ * @param {number} normalZ
+ * @param {number} planeConstant
+ * @returns {number}
+ */
+function v3_distance_above_plane(
+    x, y, z,
+    normalX, normalY, normalZ, planeConstant
+) {
+    // this is the same as v4_dot(v4(x,y,z,1.0), v4(plane.normal, plane.constant));
+    return v3_dot(normalX, normalY, normalZ, x, y, z) + planeConstant;
+}
+
 class ObservedBoolean extends Boolean {
     /**
      *
@@ -69792,21 +69870,6 @@ ObservedEnum.prototype.fromJSON = function (obj) {
     this.set(obj);
 };
 
-//
-
-/**
- *
- * @param {Vector3} result
- * @param {Vector3} input
- * @param {number[]} projection_matrix_inverse inverse of projection matrix
- * @param {number[]} world_matrix world transform
- */
-function unprojectPoint(result, input, projection_matrix_inverse, world_matrix) {
-    result.copy(input);
-    result.applyMatrix4(projection_matrix_inverse);
-    result.applyMatrix4(world_matrix);
-}
-
 const matrix4 = new Matrix4();
 
 /**
@@ -69850,25 +69913,6 @@ function invertQuaternionOrientation(output, input) {
     output.setFromRotationMatrix(m4_scratch);
 }
 
-/**
- * Orthogonal distance of a point to a plane, the distance is positive when the point lies above the plane and negative when the point is below
- * @param {number} x
- * @param {number} y
- * @param {number} z
- * @param {number} normalX
- * @param {number} normalY
- * @param {number} normalZ
- * @param {number} planeConstant
- * @returns {number}
- */
-function v3_distance_above_plane(
-    x, y, z,
-    normalX, normalY, normalZ, planeConstant
-) {
-    // this is the same as v4_dot(v4(x,y,z,1.0), v4(plane.normal, plane.constant));
-    return v3_dot(normalX, normalY, normalZ, x, y, z) + planeConstant;
-}
-
 /**
  *
  * @enum {String}
@@ -69879,63 +69923,19 @@ const ProjectionType = {
     Orthographic: "orthographic"
 };
 
+//
+
 /**
  *
- * @param {Vector3} out Result will be written here
- * @param {number} originX Ray origin
- * @param {number} originY Ray origin
- * @param {number} originZ Ray origin
- * @param {number} directionX Ray direction
- * @param {number} directionY Ray direction
- * @param {number} directionZ Ray direction
- * @param {number} normalX Plane normal
- * @param {number} normalY Plane normal
- * @param {number} normalZ Plane normal
- * @param {number} dist Plane distance
- * @returns {boolean} true if intersection is found, false otherwise
+ * @param {Vector3} result
+ * @param {Vector3} input
+ * @param {number[]} projection_matrix_inverse inverse of projection matrix
+ * @param {number[]} world_matrix world transform
  */
-function plane3_compute_ray_intersection(
-    out,
-    originX, originY, originZ,
-    directionX, directionY, directionZ,
-    normalX, normalY, normalZ, dist
-) {
-    const denom = v3_dot(directionX, directionY, directionZ, normalX, normalY, normalZ);
-
-    const p = v3_dot(normalX, normalY, normalZ, originX, originY, originZ) + dist;
-
-    if (denom !== 0) {
-
-        const t = -p / denom;
-
-        if (t < 0) {
-            return false;
-        }
-
-        out.set(
-            directionX * t + originX,
-            directionY * t + originY,
-            directionZ * t + originZ
-        );
-
-        return true;
-
-    } else {
-
-        if (p === 0) {
-
-            out.set(originX, originY, originZ);
-
-            return true;
-
-        } else {
-
-            //no intersection
-            return false;
-
-        }
-
-    }
+function unprojectPoint(result, input, projection_matrix_inverse, world_matrix) {
+    result.copy(input);
+    result.applyMatrix4(projection_matrix_inverse);
+    result.applyMatrix4(world_matrix);
 }
 
 /**
@@ -69977,7 +69977,7 @@ class Camera {
          *
          * @type {ObservedBoolean}
          */
-        this.active = new ObservedBoolean(false);
+        this.active = new ObservedBoolean(true);
 
         /**
          * Near clipping plane
@@ -77701,9 +77701,15 @@ function rewriteMaterial(shader) {
     `+shader.fragmentShader;
 }
 
+/**
+ * @typedef {Object} CacheKey
+ * @property {Material} color
+ * @property {Material} depth
+ */
+
 /**
  * @readonly
- * @type {Cache<Material, {color:Material, depth:Material}>}
+ * @type {Cache<Material,CacheKey>}
  */
 const material_cache = new Cache({
     maxWeight: 1024,
@@ -77718,14 +77724,14 @@ class InstancedMeshGroup {
     constructor() {
         /**
          * Instanced geometry
-         * @type {THREE.InstancedBufferGeometry|null}
+         * @type {InstancedBufferGeometry|null}
          * @private
          */
         this.__threeGeometry = null;
 
         /**
          * Geometry of a single instance
-         * @type {THREE.BufferGeometry|null}
+         * @type {BufferGeometry|null}
          * @private
          */
         this.__threeInstanceGeometry = null;
@@ -77753,7 +77759,12 @@ class InstancedMeshGroup {
          */
         this.growConstant = 16;
 
+        /**
+         *
+         * @type {number}
+         */
         this.shrinkFactor = 0.5;
+
         /**
          * Minimum capacity reduction for shrinkage to occur
          * @type {number}
@@ -77918,7 +77929,7 @@ class InstancedMeshGroup {
     /**
      *
      * @param {THREE.Material|THREE.ShaderMaterial} sourceMaterial
-     * @returns {{depth: Material, color: Material}}
+     * @returns {CacheKey}
      */
     #buildMaterial(sourceMaterial) {
         //console.warn(`building material : {id:${sourceMaterial.id}, name: ${sourceMaterial.name}, type: ${sourceMaterial.type}`)

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.60.0",
+  "version": "2.60.1",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/geom/3d/sphere/harmonics/sh3_dering_optimize_positive.js

@@ -53,17 +53,17 @@ function factorial(n, d = 1) {
 }
 
 const F_PI = 3.14159265358979323846264338327950288;
-const F_2_PI = 0.636619772367581343075535053490057448;
 const F_2_SQRTPI = 1.12837916709551257389615890312154517;
 const F_SQRT2 = 1.41421356237309504880168872420969808;
 const F_SQRT1_2 = 0.707106781186547524400844362104849039;
 const M_SQRT_3 = 1.7320508076;
 
 /**
- * SH scaling factors:
- *  returns sqrt((2*l + 1) / 4*pi) * sqrt( (l-|m|)! / (l+|m|)! )
+ * SH scaling factors
  */
 function Kml(m, l) {
+    //  returns sqrt((2*l + 1) / 4*pi) * sqrt( (l-|m|)! / (l+|m|)! )
+
     m = m < 0 ? -m : m;  // abs() is not constexpr
     const K = (2 * l + 1) * factorial((l - m), (l + m));
     return Math.sqrt(K) * (F_2_SQRTPI * 0.25);

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

@@ -3,18 +3,18 @@
  */
 
 
-import ObservedBoolean from "../../../../core/model/ObservedBoolean.js";
-import ObservedEnum from "../../../../core/model/ObservedEnum.js";
-import { Frustum } from 'three';
-import { assert } from "../../../../core/assert.js";
+import {Frustum} from 'three';
+import {assert} from "../../../../core/assert.js";
+import {plane3_compute_ray_intersection} from "../../../../core/geom/3d/plane/plane3_compute_ray_intersection.js";
+import {v3_distance_above_plane} from "../../../../core/geom/vec3/v3_distance_above_plane.js";
 import Vector1 from "../../../../core/geom/Vector1.js";
-import { unprojectPoint } from "./unprojectPoint.js";
 import Vector3 from "../../../../core/geom/Vector3.js";
-import { frustum_from_camera } from "./frustum_from_camera.js";
-import { invertQuaternionOrientation } from "./InvertQuaternionOrientation.js";
-import { v3_distance_above_plane } from "../../../../core/geom/vec3/v3_distance_above_plane.js";
-import { ProjectionType } from "./ProjectionType.js";
-import { plane3_compute_ray_intersection } from "../../../../core/geom/3d/plane/plane3_compute_ray_intersection.js";
+import ObservedBoolean from "../../../../core/model/ObservedBoolean.js";
+import ObservedEnum from "../../../../core/model/ObservedEnum.js";
+import {frustum_from_camera} from "./frustum_from_camera.js";
+import {invertQuaternionOrientation} from "./InvertQuaternionOrientation.js";
+import {ProjectionType} from "./ProjectionType.js";
+import {unprojectPoint} from "./unprojectPoint.js";
 
 /**
  * @class
@@ -51,7 +51,7 @@ export class Camera {
          *
          * @type {ObservedBoolean}
          */
-        this.active = new ObservedBoolean(false);
+        this.active = new ObservedBoolean(true);
 
         /**
          * Near clipping plane

package/src/engine/graphics/geometry/instancing/InstancedMeshGroup.js

@@ -21,9 +21,15 @@ import { array_copy } from "../../../../core/collection/array/array_copy.js";
 import { Cache } from "../../../../core/cache/Cache.js";
 import { computeMaterialHash } from "../../../asset/loaders/material/computeMaterialHash.js";
 
+/**
+ * @typedef {Object} CacheKey
+ * @property {Material} color
+ * @property {Material} depth
+ */
+
 /**
  * @readonly
- * @type {Cache<Material, {color:Material, depth:Material}>}
+ * @type {Cache<Material,CacheKey>}
  */
 const material_cache = new Cache({
     maxWeight: 1024,
@@ -38,14 +44,14 @@ export class InstancedMeshGroup {
     constructor() {
         /**
          * Instanced geometry
-         * @type {THREE.InstancedBufferGeometry|null}
+         * @type {InstancedBufferGeometry|null}
          * @private
          */
         this.__threeGeometry = null;
 
         /**
          * Geometry of a single instance
-         * @type {THREE.BufferGeometry|null}
+         * @type {BufferGeometry|null}
          * @private
          */
         this.__threeInstanceGeometry = null;
@@ -73,7 +79,12 @@ export class InstancedMeshGroup {
          */
         this.growConstant = 16;
 
+        /**
+         *
+         * @type {number}
+         */
         this.shrinkFactor = 0.5;
+
         /**
          * Minimum capacity reduction for shrinkage to occur
          * @type {number}
@@ -238,7 +249,7 @@ export class InstancedMeshGroup {
     /**
      *
      * @param {THREE.Material|THREE.ShaderMaterial} sourceMaterial
-     * @returns {{depth: Material, color: Material}}
+     * @returns {CacheKey}
      */
     #buildMaterial(sourceMaterial) {
         //console.warn(`building material : {id:${sourceMaterial.id}, name: ${sourceMaterial.name}, type: ${sourceMaterial.type}`)