@woosh/meep-engine 2.48.1 → 2.48.5

package/package.json

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

package/src/core/binary/32BitEncoder.js

@@ -1,11 +1,15 @@
+import { FunctionCompiler } from "../function/FunctionCompiler.js";
+import { assert } from "../assert.js";
+
 /**
  *
  * @param {number[]} bitCounts
  * @returns {{encode: function(...number):number, decode: function(value:number, result:number[]):void}}
  */
-import { FunctionCompiler } from "../function/FunctionCompiler.js";
-
 export function create32BitCodec(bitCounts) {
+    assert.isArray(bitCounts, 'bitCounts');
+    assert.lessThanOrEqual(bitCounts.length, 32, `at most 32 groups are supported (1 bit each), instead ${bitCounts} was requested`);
+
     const layout = [];
 
     const encoderFunctionBody = [];
@@ -15,10 +19,14 @@ export function create32BitCodec(bitCounts) {
 
     let offsetCursor = 0;
 
+    const group_count = bitCounts.length;
 
-    for (let i = 0, numVariables = bitCounts.length; i < numVariables; i++) {
+    for (let i = 0, numVariables = group_count; i < numVariables; i++) {
         const size = bitCounts[i];
 
+        assert.isNonNegativeInteger(size, `size[${i}]`);
+        assert.greaterThan(size, 0, `size[${i}] bust be greater than 0, instead was ${size}`);
+
         const offset = offsetCursor;
 
         layout.push({ offset, size });

package/src/core/binary/BinaryBuffer.js

@@ -26,64 +26,70 @@ const MIN_GROWTH_STEP = 1024;
  */
 const MAX_SAFE_UINT_VAR = 2147483647;
 
+/**
+ * @readonly
+ * @type {number}
+ */
+const DEFAULT_INITIAL_SIZE = 1024;
+
+
+/**
+ * Utility for reading/writing binary data
+ * Mostly useful for serialization/deserialization tasks
+ */
 export class BinaryBuffer {
+
     /**
      *
-     * @constructor
-     */
-    constructor() {
-        /**
-         *
-         * @type {EndianType|boolean}
-         */
-        this.endianness = EndianType.BigEndian;
-
-        /**
-         *
-         * @type {number}
-         */
-        this.position = 0;
+     * @type {EndianType|boolean}
+     */
+    endianness = EndianType.BigEndian;
 
-        /**
-         *
-         * @type {number}
-         */
-        this.length = 0;
-
-        /**
-         *
-         * @type {number}
-         */
-        this.capacity = 0;
-
-        /**
-         *
-         * @type {ArrayBuffer}
-         * @private
-         */
-        this.data = new ArrayBuffer(0);
-
-        /**
-         *
-         * @type {DataView}
-         * @private
-         */
-        this.dataView = new DataView(this.data);
+    /**
+     *
+     * @type {number}
+     */
+    position = 0;
 
-        /**
-         *
-         * @type {Uint8Array}
-         * @private
-         */
-        this.__data_uint8 = new Uint8Array(0);
+    /**
+     * @deprecated
+     * @type {number}
+     */
+    length = 0;
 
-        /**
-         *
-         * @type {number}
-         * @private
-         */
-        this.__growFactor = 1.1;
-    }
+    /**
+     *
+     * @type {number}
+     */
+    capacity = DEFAULT_INITIAL_SIZE;
+
+    /**
+     *
+     * @type {ArrayBuffer}
+     * @private
+     */
+    data = new ArrayBuffer(DEFAULT_INITIAL_SIZE);
+
+    /**
+     *
+     * @type {DataView}
+     * @private
+     */
+    dataView = new DataView(this.data);
+
+    /**
+     *
+     * @type {Uint8Array}
+     * @private
+     */
+    __data_uint8 = new Uint8Array(this.data);
+
+    /**
+     *
+     * @type {number}
+     * @private
+     */
+    __growFactor = 1.1;
 
     /**
      * Access raw underlying bytes attached to the buffer
@@ -94,21 +100,24 @@ export class BinaryBuffer {
     }
 
     /**
-     * @param {ArrayBuffer} arrayBuffer
+     * @param {ArrayBuffer} data
      */
-    fromArrayBuffer(arrayBuffer) {
-        this.data = arrayBuffer;
-        this.dataView = new DataView(arrayBuffer);
-        this.__data_uint8 = new Uint8Array(arrayBuffer);
+    fromArrayBuffer(data) {
+        assert.defined(data, 'data');
+        assert.notNull(data, 'data');
 
-        this.capacity = arrayBuffer.byteLength;
+        this.data = data;
+        this.dataView = new DataView(data);
+        this.__data_uint8 = new Uint8Array(data);
+
+        this.capacity = data.byteLength;
         //assume that all the data is useful
         this.length = this.capacity;
         this.position = 0;
     }
 
     /**
-     *
+     * Set capacity to contain data only up to current position
      * @returns {BinaryBuffer}
      */
     trim() {
@@ -122,6 +131,12 @@ export class BinaryBuffer {
      * @param {number} capacity
      */
     setCapacity(capacity) {
+        assert.isNonNegativeInteger(capacity, 'capacity');
+
+        if (capacity < this.position) {
+            throw new Error(`Attempting to set capacity(=${capacity}) below current position(=${this.position})`);
+        }
+
         const oldData = this.__data_uint8;
         const newData = new Uint8Array(capacity);
 
@@ -1117,3 +1132,9 @@ export class BinaryBuffer {
         return temp;
     }
 }
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+BinaryBuffer.prototype.isBinaryBuffer = true;

package/src/core/binary/int32_to_binary_string.js

@@ -1,3 +1,19 @@
+
+
+const RX = /\B(?=(.{8})+(?!.))/g;
+
+/**
+ * 2147483647
+ * @type {number}
+ */
+const MAX_VALUE = 2 ** 31 - 1;
+
+/**
+ * -2147483648
+ * @type {number}
+ */
+const MIN_VALUE = -1 * (2 ** 31);
+
 /**
  * @see https://stackoverflow.com/questions/9939760/how-do-i-convert-an-integer-to-binary-in-javascript
  * @example 1024    -> "00000000 00000000 00000100 00000000"
@@ -7,12 +23,21 @@
  */
 export function int32_to_binary_string(nMask) {
     // nMask must be between -2147483648 and 2147483647
-    if (nMask > 2 ** 31 - 1)
-        throw "number too large. number shouldn't be > 2**31-1"; //added
-    if (nMask < -1 * (2 ** 31))
-        throw "number too far negative, number shouldn't be < 2**31" //added
-    for (var nFlag = 0, nShifted = nMask, sMask = ''; nFlag < 32;
-         nFlag++, sMask += String(nShifted >>> 31), nShifted <<= 1) ;
-    sMask = sMask.replace(/\B(?=(.{8})+(?!.))/g, " ") // added
+    if (nMask > MAX_VALUE) {
+        throw "number too large. number shouldn't be > 2**31-1";//added
+    }
+    if (nMask < MIN_VALUE) {
+        throw "number too far negative, number shouldn't be < 2**31"//added
+    }
+
+    let nFlag = 0, nShifted = nMask, sMask = '';
+
+    for (; nFlag < 32;
+           nFlag++, sMask += String(nShifted >>> 31), nShifted <<= 1
+    ) {
+    }
+
+    sMask = sMask.replace(RX, " ") // added
+
     return sMask;
 }

package/src/core/binary/to_half_float_uint16.js

@@ -8,11 +8,13 @@ const _int32View = new Int32Array(_floatView.buffer);
  * @returns {number}
  */
 export function to_half_float_uint16(val) {
-    if (val > 65504) {
+    let _val = val;
 
-        console.warn('THREE.DataUtils.toHalfFloat(): value exceeds 65504.');
+    if (_val > 65504) {
 
-        val = 65504; // maximum representable value in float16
+        console.warn('to_half_float_uint16(): value exceeds 65504.');
+
+        _val = 65504; // maximum representable value in float16
 
     }
 
@@ -22,7 +24,7 @@ export function to_half_float_uint16(val) {
     * used, eg. in Ogre), with the additional benefit of rounding, inspired
     * by James Tursa?s half-precision code. */
 
-    _floatView[0] = val;
+    _floatView[0] = _val;
     const x = _int32View[0];
 
     let bits = (x >> 16) & 0x8000; /* Get the sign */

package/src/core/bvh2/visual/convert_bvh_to_dot_format_string.js

@@ -46,5 +46,5 @@ export function bvh_to_graph(bvh) {
  */
 export function convert_bvh_to_dot_format_string(bvh) {
     const graph = bvh_to_graph(bvh);
-    return convertGraphToDotString(graph);
+    return convertGraphToDotString({ graph: graph });
 }

package/src/core/collection/list/List.js

@@ -753,6 +753,9 @@ List.prototype.toJSON = function () {
  */
 List.prototype.fromJSON = function (json, constructor) {
     this.reset();
+
+    assert.isArray(json,'json');
+
     if (typeof constructor === "function") {
         this.addAll(json.map(function (elJSON) {
             const el = new constructor();

package/src/core/geom/3d/CircleMath.js

@@ -1,6 +1,7 @@
 import { v3_angle_between } from "../v3_angle_between.js";
 
 /**
+ * Compute 3d bounds of a circle in 3d space
  * NOTE: based on https://stackoverflow.com/questions/2592011/bounding-boxes-for-circle-and-arcs-in-3d
  * @param {AABB3} result
  * @param {number} centerX
@@ -11,7 +12,13 @@ import { v3_angle_between } from "../v3_angle_between.js";
  * @param {number} normalZ orientation of the circle
  * @param {number} radius
  */
-export function computeCircleBoundingBox(result, centerX, centerY, centerZ, normalX, normalY, normalZ, radius) {
+export function computeCircleBoundingBox(
+    result,
+    centerX, centerY, centerZ,
+    normalX, normalY, normalZ,
+    radius
+) {
+
     const ax = v3_angle_between(normalX, normalY, normalZ, 1, 0, 0);
     const ay = v3_angle_between(normalX, normalY, normalZ, 0, 1, 0);
     const az = v3_angle_between(normalX, normalY, normalZ, 0, 0, 1);
@@ -20,5 +27,9 @@ export function computeCircleBoundingBox(result, centerX, centerY, centerZ, norm
     const rY = Math.sin(ay) * radius;
     const rZ = Math.sin(az) * radius;
 
-    result.setBounds(centerX - rX, centerY - rY, centerZ - rZ, centerX + rX, centerY + rY, centerZ + rZ);
+    result.setBounds(
+        centerX - rX, centerY - rY, centerZ - rZ,
+        centerX + rX, centerY + rY, centerZ + rZ
+    );
+
 }

package/src/core/geom/3d/matrix/m4_make_translation.js

@@ -0,0 +1,15 @@
+import { array_copy } from "../../../collection/array/copyArray.js";
+import { MATRIX_4_IDENTITY } from "./MATRIX_4_IDENTITY.js";
+
+/**
+ * Create a 4x4 matrix that corresponds to translation transform
+ * @param {ArrayLike<number>} output
+ * @param {ArrayLike<number>} translation 3d vector
+ */
+export function m4_make_translation(output, translation) {
+    array_copy(MATRIX_4_IDENTITY, 0, output, 0, 16);
+
+    output[12] = translation[0];
+    output[13] = translation[1];
+    output[14] = translation[2];
+}

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

@@ -19,19 +19,10 @@ import { v3_dot } from "../../v3_dot.js";
  * @returns {number}
  */
 export function computeTrianglePlaneSide(
-    plane_normal_x,
-    plane_normal_y,
-    plane_normal_z,
-    plane_constant,
-    ax,
-    ay,
-    az,
-    bx,
-    by,
-    bz,
-    cx,
-    cy,
-    cz
+    plane_normal_x, plane_normal_y, plane_normal_z, plane_constant,
+    ax, ay, az,
+    bx, by, bz,
+    cx, cy, cz
 ) {
     let result = 0;
 

package/src/core/geom/Vector3.spec.js

@@ -35,3 +35,13 @@ test('slerp', () => {
     expect(v.y).toBeCloseTo(0.7071067811865475);
     expect(v.z).toBeCloseTo(0);
 });
+
+test('addVectors', () => {
+    const ut = new Vector3();
+
+    ut.addVectors(new Vector3(1, 3, 5), new Vector3(-7, 11, 13));
+
+    expect(ut.x).toBe(-6);
+    expect(ut.y).toBe(14);
+    expect(ut.z).toBe(18);
+});

package/src/core/graph/convertGraphToDotString.js

@@ -1,12 +1,22 @@
 import LineBuilder from "../codegen/LineBuilder.js";
 import { EdgeDirectionType } from "./Edge.js";
 
+
+function defaultNodeToDot(node){
+    return `[label="${node.toString()}"]`;
+}
+
 /**
+ * @template Node
  * Build a Graphviz DOT representation of the graph
- * @param {Graph} graph
+ * @param {Graph<Node>} graph
+ * @param {function(Node):string} nodeToDot
  * @returns {string}
  */
-export function convertGraphToDotString(graph) {
+export function convertGraphToDotString({
+                                            graph,
+                                            nodeToDot=defaultNodeToDot
+}) {
     const lb = new LineBuilder();
 
     lb.add('strict digraph Graph {');
@@ -24,7 +34,7 @@ export function convertGraphToDotString(graph) {
 
         const node = nodes[i];
 
-        lb.add(`${nodeId(i)} [label="${node.toString()}"];`);
+        lb.add(`${nodeId(i)} ${nodeToDot(node)};`);
 
     }
 

package/src/core/graph/v2/Graph.js

@@ -62,7 +62,7 @@ export class Graph {
     /**
      *
      * @param {N} node
-     * @returns {boolean}
+     * @returns {boolean} true if node was added, false if node already exists
      */
     addNode(node) {
         if (this.hasNode(node)) {
@@ -328,6 +328,22 @@ export class Graph {
         return context_a.getAnyEdgeWith(b);
     }
 
+    /**
+     *
+     * @param {N} from
+     * @param {N} to
+     * @returns {Edge<N>|undefined}
+     */
+    getAnyDirectedEdge(from, to){
+        const ctx_a = this.__nodes.get(from);
+
+        if(ctx_a === undefined){
+            return undefined;
+        }
+
+        return ctx_a.getAnyDirectionEdgeTo(to);
+    }
+
     /**
      *
      * @param {Edge<N>[]} result

package/src/core/graph/v2/NodeContainer.js

@@ -1,3 +1,5 @@
+import { EdgeDirectionType } from "../Edge.js";
+
 export class NodeContainer {
     /**
      * @template N
@@ -40,6 +42,31 @@ export class NodeContainer {
         return this.__edges;
     }
 
+    /**
+     *
+     * @return {number}
+     */
+    getIncomingEdgeCount() {
+        let r = 0;
+
+        const edges = this.__edges;
+        const edge_count = edges.length;
+
+        for (let i = 0; i < edge_count; i++) {
+            const edge = edges[i];
+
+            if (
+                (edge.first === this.node && edge.direction === EdgeDirectionType.Forward)
+                || (edge.second === this.node && edge.direction === EdgeDirectionType.Backward)
+
+            ) {
+                r++;
+            }
+        }
+
+        return r;
+    }
+
 
     /**
      *
@@ -101,6 +128,37 @@ export class NodeContainer {
         return undefined;
     }
 
+    /**
+     * Undirected edges don't count
+     * @param {N} other
+     * @returns {Edge<N>|undefined}
+     */
+    getAnyDirectionEdgeTo(other) {
+
+        /**
+         *
+         * @type {Edge[]}
+         */
+        const edges = this.__edges;
+
+        const n = edges.length;
+
+        for (let i = 0; i < n; i++) {
+            const edge = edges[i];
+
+            if (
+                (edge.second === other && edge.direction === EdgeDirectionType.Forward)
+                || (edge.first === other && edge.direction === EdgeDirectionType.Backward)
+
+            ) {
+                return edge;
+            }
+        }
+
+        // not found
+        return undefined;
+    }
+
     /**
      *
      * @param {Edge} e

package/src/core/model/ModuleRegistry.js

@@ -1,12 +1,19 @@
 import { assert } from "../assert.js";
 
 export class ModuleRegistry {
+
+    /**
+     *
+     * @type {Map<string, *>}
+     */
+    #modules = new Map();
+    /**
+     *
+     * @type {Map<*,string[]>}
+     */
+    #reverse_lookup = new Map();
+
     constructor() {
-        /**
-         *
-         * @type {Map<string, *>}
-         */
-        this.__elements = new Map();
 
         const self = this;
 
@@ -19,7 +26,7 @@ export class ModuleRegistry {
              * @returns {Class}
              */
             get(target, p, receiver) {
-                const module = self.__elements.get(p);
+                const module = self.get(p);
 
                 if (module === undefined) {
                     throw new Error(`Module '${p}' not found in the registry`);
@@ -35,7 +42,7 @@ export class ModuleRegistry {
      * @param {(name:string, module:*)=>void} visitor
      */
     traverse(visitor) {
-        this.__elements.forEach((klass, name) => visitor(name, klass));
+        this.#modules.forEach((klass, name) => visitor(name, klass));
     }
 
 
@@ -45,7 +52,7 @@ export class ModuleRegistry {
      * @returns {T}
      */
     get(name) {
-        return this.__elements.get(name);
+        return this.#modules.get(name);
     }
 
     /**
@@ -54,7 +61,7 @@ export class ModuleRegistry {
      * @returns {boolean}
      */
     has(name) {
-        return this.__elements.has(name);
+        return this.#modules.has(name);
     }
 
     /**
@@ -75,11 +82,38 @@ export class ModuleRegistry {
             return false;
         }
 
-        this.__elements.set(name, module);
+        this.#modules.set(name, module);
+
+        let names = this.#reverse_lookup.get(module);
+
+        if (names === undefined) {
+            names = [];
+            this.#reverse_lookup.set(module, names);
+        }
+
+        names.push(name);
 
         return true;
     }
 
+    /**
+     * Find all names associated with the given module
+     * @template T
+     * @param {T} module
+     * @returns {string[]}
+     * @throws if module is not registered
+     */
+    findNamesByModule(module) {
+
+        const names = this.#reverse_lookup.get(module);
+
+        if (names === undefined) {
+            throw new Error('Module not found');
+        } else {
+            return names;
+        }
+    }
+
     initialize() {
 
     }

package/src/core/model/ResourceAccessKind.js

@@ -0,0 +1,11 @@
+/**
+ * Note that values correspond to shifted specific 1 bit mask,
+ * this is intentional, to allow you to encode complex access pattern into a single integer value
+ * @readonly
+ * @enum {number}
+ */
+export const ResourceAccessKind = {
+    Read: 1,
+    Write: 2,
+    Create: 4
+};