@woosh/meep-engine 2.35.15 → 2.36.0

package/core/bvh2/bvh3/ExplicitBinaryBoundingVolumeHierarchy.spec.js

@@ -0,0 +1,142 @@
+import { ExplicitBinaryBoundingVolumeHierarchy, NULL_NODE } from "./ExplicitBinaryBoundingVolumeHierarchy.js";
+
+test("constructor doesn't throw", () => {
+    expect(() => new ExplicitBinaryBoundingVolumeHierarchy()).not.toThrow();
+});
+
+test("initial root is NULL", () => {
+    const bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+
+    expect(bvh.root).toBe(NULL_NODE);
+});
+
+test("allocate a node", () => {
+    const bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+
+    const id = bvh.allocate_node();
+
+    expect(typeof id).toBe("number");
+    expect(Number.isInteger(id)).toBe(true);
+    expect(id).toBeGreaterThanOrEqual(0);
+});
+
+test("set/get aabb", () => {
+    const bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+
+    const node = bvh.allocate_node();
+
+    bvh.node_set_aabb(node, [1, -2, 3, -5, 7, 11]);
+
+    const result = [];
+
+    bvh.node_get_aabb(node, result);
+
+    expect(result).toEqual([
+        1, -2, 3, -5, 7, 11
+    ]);
+});
+
+test("insert one leaf", () => {
+    const bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+
+    const node = bvh.allocate_node();
+
+    bvh.insert_leaf(node);
+
+    expect(bvh.root).toBe(node);
+});
+
+test("node reuse after de-allocation", () => {
+
+    const bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+
+    const a = bvh.allocate_node();
+
+    bvh.release_node(a);
+
+    const b = bvh.allocate_node();
+
+    expect(b).toEqual(a);
+});
+
+test("insert two leaves", () => {
+
+    const bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+
+    const a = bvh.allocate_node();
+    bvh.insert_leaf(a);
+
+    const b = bvh.allocate_node();
+    bvh.insert_leaf(b);
+
+    const nodes = [];
+    bvh.collect_nodes_all(nodes, 0);
+
+    expect(nodes).toContain(a);
+    expect(nodes).toContain(b);
+});
+
+
+test("set/get user data", () => {
+
+    const bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+
+    const a = bvh.allocate_node();
+
+    bvh.node_set_user_data(a, 42);
+
+    expect(bvh.node_get_user_data(a)).toBe(42);
+});
+
+test("remove single leaf", () => {
+    const bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+
+    const a = bvh.allocate_node();
+    bvh.insert_leaf(a);
+
+    bvh.remove_leaf(a);
+
+    const nodes = [];
+    bvh.collect_nodes_all(nodes, 0);
+
+    expect(nodes).not.toContain(a);
+});
+
+test("add and remove 5 nodes", () => {
+
+    const bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+
+    const leaves = [];
+    const removed_leaves = [];
+
+    for (let i = 0; i < 5; i++) {
+        const a = bvh.allocate_node();
+        bvh.insert_leaf(a);
+
+        leaves.push(a);
+    }
+
+    while (leaves.length > 0) {
+        const nodes = [];
+        bvh.collect_nodes_all(nodes, 0);
+
+        for (let j = 0; j < leaves.length; j++) {
+            const leaf = leaves[j];
+            expect(nodes).toContain(leaf);
+        }
+
+        const leaf = leaves.shift();
+
+        bvh.remove_leaf(leaf);
+
+        removed_leaves.push(leaf);
+
+    }
+
+    const nodes = [];
+    bvh.collect_nodes_all(nodes, 0);
+    for (let i = 0; i < removed_leaves.length; i++) {
+        expect(nodes).not.toContain(removed_leaves[i]);
+    }
+
+});

package/core/bvh2/bvh3/bvh_query_leaves_generic.js

@@ -0,0 +1,79 @@
+import { NULL_NODE } from "./ExplicitBinaryBoundingVolumeHierarchy.js";
+
+/**
+ *
+ * @type {number[]}
+ */
+const traversal_stack = [];
+
+/**
+ *
+ * @type {number}
+ */
+let traversal_cursor = 0;
+
+
+/**
+ *
+ * @param {ExplicitBinaryBoundingVolumeHierarchy} bvh
+ * @param {number[]} result
+ * @param {number} result_offset
+ * @param {BVHQuery} query
+ * @returns {number}
+ */
+export function bvh_query_leaves_generic(
+    result, result_offset,
+    bvh, query
+) {
+    const stack_frame_address = traversal_cursor;
+
+    const root = bvh.root;
+
+    if (root === NULL_NODE) {
+        return 0;
+    }
+
+    traversal_stack[traversal_cursor++] = root;
+
+    let result_cursor = result_offset;
+
+    while (traversal_cursor > stack_frame_address) {
+        traversal_cursor--;
+
+        /**
+         *
+         * @type {number}
+         */
+        const node = traversal_stack[traversal_cursor];
+
+        // test node against the ray
+        const pass = query.evaluate(node, bvh);
+
+        if (!pass) {
+            continue;
+        }
+
+        const node_is_leaf = bvh.node_is_leaf(node);
+
+        if (!node_is_leaf) {
+
+            // read in-order
+            const child1 = bvh.node_get_child1(node);
+            const child2 = bvh.node_get_child2(node);
+
+            // write to stack in reverse order, so that fist child ends up being visited first
+            traversal_stack[traversal_cursor++] = child2;
+            traversal_stack[traversal_cursor++] = child1;
+
+        } else {
+            // leaf node
+
+            result[result_cursor++] = node;
+        }
+    }
+
+    // drop stack frame
+    traversal_cursor = stack_frame_address;
+
+    return result_cursor - result_offset;
+}

package/core/bvh2/bvh3/bvh_query_leaves_ray.js

@@ -0,0 +1,95 @@
+import { aabb3_intersects_ray } from "../aabb3/aabb3_intersects_ray.js";
+import { NULL_NODE } from "./ExplicitBinaryBoundingVolumeHierarchy.js";
+
+/**
+ *
+ * @type {number[]}
+ */
+const traversal_stack = [];
+
+/**
+ *
+ * @type {number[]}
+ */
+const scratch_aabb = [];
+
+/**
+ *
+ * @type {number}
+ */
+let traversal_cursor = 0;
+
+
+/**
+ *
+ * @param {ExplicitBinaryBoundingVolumeHierarchy} bvh
+ * @param {number[]} result
+ * @param {number} result_offset
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} direction_x
+ * @param {number} direction_y
+ * @param {number} direction_z
+ * @returns {number}
+ */
+export function bvh_query_leaves_ray(
+    bvh,
+    result, result_offset,
+    origin_x, origin_y, origin_z,
+    direction_x, direction_y, direction_z
+) {
+    const stack_frame_address = traversal_cursor;
+
+    const root = bvh.root;
+
+    if (root === NULL_NODE) {
+        return 0;
+    }
+
+    traversal_stack[traversal_cursor++] = root;
+
+    let result_cursor = result_offset;
+
+    while (traversal_cursor > stack_frame_address) {
+        traversal_cursor--;
+
+        /**
+         *
+         * @type {number}
+         */
+        const node = traversal_stack[traversal_cursor];
+
+        bvh.node_get_aabb(node, scratch_aabb);
+
+        // test node against the ray
+        const intersects = aabb3_intersects_ray(
+            scratch_aabb[0], scratch_aabb[1], scratch_aabb[2],
+            scratch_aabb[3], scratch_aabb[4], scratch_aabb[5],
+            origin_x, origin_y, origin_z,
+            direction_x, direction_y, direction_z
+        );
+
+        if (!intersects) {
+            continue;
+        }
+
+        const node_is_leaf = bvh.node_is_leaf(node);
+
+        if (!node_is_leaf) {
+
+            traversal_stack[traversal_cursor++] = bvh.node_get_child1(node);
+            traversal_stack[traversal_cursor++] = bvh.node_get_child2(node);
+
+        } else {
+            // leaf node
+
+            result[result_cursor++] = node;
+        }
+    }
+
+    // drop stack frame
+    traversal_cursor = stack_frame_address;
+
+    return result_cursor - result_offset;
+}

package/core/bvh2/bvh3/query/BVHQuery.js

@@ -0,0 +1,11 @@
+export class BVHQuery {
+    /**
+     *
+     * @param {number} node
+     * @param {ExplicitBinaryBoundingVolumeHierarchy} tree
+     * @returns {boolean}
+     */
+    evaluate(node, tree) {
+        throw new Error('Not Implemented');
+    }
+}

package/core/bvh2/bvh3/query/BVHQueryIntersectsFrustum.js

@@ -0,0 +1,36 @@
+import { BVHQuery } from "./BVHQuery.js";
+import { aabb3_array_intersects_frustum_array } from "../../aabb3/aabb3_array_intersects_frustum_array.js";
+
+const scratch_aabb = [];
+
+export class BVHQueryIntersectsFrustum extends BVHQuery {
+    constructor() {
+        super();
+
+        /**
+         * Collection of 6 planes: normal_x, normal_y, normal_z, offset
+         * @type {number[]}
+         */
+        this.frustum = [];
+    }
+
+    /**
+     *
+     * @param {number[]|ArrayLike<number>|Float32Array} frustum
+     * @returns {BVHQueryIntersectsFrustum}
+     */
+    static from(frustum) {
+        const r = new BVHQueryIntersectsFrustum();
+
+        r.frustum = frustum;
+
+        return r;
+    }
+
+    evaluate(node, tree) {
+
+        tree.node_get_aabb(node, scratch_aabb);
+
+        return aabb3_array_intersects_frustum_array(scratch_aabb, this.frustum);
+    }
+}

package/core/bvh2/bvh3/query/BVHQueryIntersectsRay.js

@@ -0,0 +1,36 @@
+import { BVHQuery } from "./BVHQuery.js";
+import { aabb3_array_intersects_ray_array } from "../../aabb3/aabb3_array_intersects_ray_array.js";
+
+const scratch_aabb = [];
+
+export class BVHQueryIntersectsRay extends BVHQuery {
+    constructor() {
+        super();
+
+        this.ray = [];
+    }
+
+    /**
+     *
+     * @param {number[]|ArrayLike<number>} ray
+     * @returns {BVHQueryIntersectsRay}
+     */
+    static from(ray){
+        const r = new BVHQueryIntersectsRay();
+
+        r.ray = ray;
+
+        return r;
+    }
+
+    evaluate(node, tree) {
+
+        tree.node_get_aabb(node, scratch_aabb);
+
+        // test node against the ray
+        return aabb3_array_intersects_ray_array(
+            scratch_aabb,
+            this.ray
+        );
+    }
+}

package/core/collection/array/copyArray.js

@@ -25,9 +25,9 @@ export function copyArray(source, target) {
  * Follows Java System.arraycopy interface
  * Copy data from one array to another
  * @template T
- * @param {T[]|ArrayLike<T>|TypedArray|Uint8ClampedArray|Uint8Array|Float32Array|Float64Array} source The source array
+ * @param {T[]|ArrayLike<T>|TypedArray|Uint8ClampedArray|Uint8Array|Uint32Array|Int32Array|Float32Array|Float64Array} source The source array
  * @param {number} source_position Starting position where to copy from inside the source array
- * @param {T[]|ArrayLike<T>|TypedArray|Uint8ClampedArray|Uint8Array|Float32Array|Float64Array} destination The destination array
+ * @param {T[]|ArrayLike<T>|TypedArray|Uint8ClampedArray|Uint8Array|Uint32Array|Int32Array|Float32Array|Float64Array} destination The destination array
  * @param {number} destination_position Starting position where to copy to inside the destination array
  * @param {number} length How many elements should be copied
  */

package/core/collection/array/typed/uint_array_for_count.js

@@ -0,0 +1,17 @@
+/**
+ *
+ * @param {number} count
+ * @returns {function}
+ */
+export function UintArrayForCount(count) {
+
+    if (count <= 256) {
+        return Uint8Array;
+    } else if (count <= 65536) {
+        return Uint16Array;
+    } else if (count <= 4294967295) {
+        return Uint32Array;
+    } else {
+        throw new Error(`Unsupported size ${count}`)
+    }
+}

package/core/collection/table/RowFirstTable.js

@@ -75,7 +75,16 @@ RowFirstTable.prototype.initialize = function () {
     this.types = spec.types;
     this.bytesPerRecord = spec.bytesPerRecord;
 
+    /**
+     *
+     * @type {function(DataView, number, number[]): void}
+     */
     this.readRowMethod = spec.readRowMethod;
+
+    /**
+     *
+     * @type {function(DataView, number, number[]): void}
+     */
     this.writeRowMethod = spec.writeRowMethod;
 };
 
@@ -180,12 +189,12 @@ RowFirstTable.prototype.resize = function (rowCount) {
  * @param {number} value
  */
 RowFirstTable.prototype.writeCellValue = function (rowIndex, columnIndex, value) {
-    const spec = this.spec;
-
     const bytesPerRecord = this.bytesPerRecord;
 
     const rowAddress = rowIndex * bytesPerRecord;
 
+    const spec = this.spec;
+
     const cellWriters = spec.cellWriters;
 
     const cellWriter = cellWriters[columnIndex];
@@ -200,12 +209,12 @@ RowFirstTable.prototype.writeCellValue = function (rowIndex, columnIndex, value)
  * @returns {number}
  */
 RowFirstTable.prototype.readCellValue = function (rowIndex, columnIndex) {
-    const spec = this.spec;
-
     const bytesPerRecord = this.bytesPerRecord;
 
     const rowAddress = rowIndex * bytesPerRecord;
 
+    const spec = this.spec;
+
     const cellReaders = spec.cellReaders;
 
     const cellReader = cellReaders[columnIndex];
@@ -225,14 +234,14 @@ RowFirstTable.prototype.removeRows = function (index, rowCount) {
 
     const data = this.data;
 
-    const bytesPerRecord = this.bytesPerRecord;
-
     const array = new Uint8Array(data);
 
+    const bytesPerRecord = this.bytesPerRecord;
+
     //shift tail of the table forward
     const target = index * bytesPerRecord;
-    const end = this.length * bytesPerRecord;
     const start = target + rowCount * bytesPerRecord;
+    const end = this.length * bytesPerRecord;
 
     array.copyWithin(target, start, end);
 
@@ -396,6 +405,15 @@ RowFirstTable.prototype.getRow = function (index, result) {
     this.readRowMethod(this.dataView, this.bytesPerRecord * index, result);
 };
 
+/**
+ *
+ * @param {number} index
+ * @param {number[]} record
+ */
+RowFirstTable.prototype.setRow = function (index, record) {
+    this.writeRowMethod(this.dataView, this.bytesPerRecord * index, record);
+}
+
 /**
  * clear out all the data and free memory
  */

package/core/collection/table/RowFirstTableSpec.js

@@ -52,7 +52,7 @@ export const DataType2DataViewWriters = {
  *
  * @param {DataType[]} types
  * @param {EndianType} [endianType]
- * @returns {Function}
+ * @returns {(data_view:DataView, byte_offset:number, result:number[])=>void}
  */
 function genRowReader(types, endianType = EndianType.BigEndian) {
     let offset = 0;
@@ -86,7 +86,7 @@ function genRowReader(types, endianType = EndianType.BigEndian) {
  *
  * @param {DataType[]} types
  * @param {EndianType} [endianType]
- * @returns {Function}
+ * @returns {(data_view:DataView, byte_offset:number, record:number[])=>void}
  */
 function genRowWriter(types, endianType = EndianType.BigEndian) {
     let offset = 0;
@@ -195,13 +195,13 @@ export function RowFirstTableSpec(types, endianType = EndianType.BigEndian) {
 
     /**
      * @readonly
-     * @type {Function}
+     * @type {function(DataView, number, number[]): void}
      */
     this.readRowMethod = genRowReader(types, endianType);
 
     /**
      * @readonly
-     * @type {Function}
+     * @type {function(DataView, number, number[]): void}
      */
     this.writeRowMethod = genRowWriter(types, endianType);
 

package/core/geom/3d/aabb/aabb3_matrix4_project.spec.js

@@ -1,7 +1,7 @@
 import { aabb3_matrix4_project } from "./aabb3_matrix4_project.js";
-import { compose_matrix4_array } from "../../../../engine/graphics/util/composeMatrix4.js";
 import Vector3 from "../../Vector3.js";
 import Quaternion from "../../Quaternion.js";
+import { compose_matrix4_array } from "../compose_matrix4_array.js";
 
 test('identity', () => {
     const r = [];

package/{engine/graphics/util → core/geom/3d/aabb}/computeBoundingBoxFromVertexData.js

@@ -1,6 +1,6 @@
 /**
  *
- * @param {Float32Array} data
+ * @param {Float32Array} data must be x,y,z sequence
  * @param {AABB3} aabb
  */
 export function computeBoundingBoxFromVertexData(data, aabb) {

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

@@ -0,0 +1,53 @@
+/**
+ *
+ * @param {number[]|Float32Array|mat4} result
+ * @param {Vector3} position
+ * @param {Quaternion} rotation
+ * @param {Vector3} scale
+ */
+export function compose_matrix4_array(result, position, rotation, scale) {
+    const x = rotation.x;
+    const y = rotation.y;
+    const z = rotation.z;
+    const w = rotation.w;
+
+    const x2 = x + x;
+    const y2 = y + y;
+    const z2 = z + z;
+
+    const xx = x * x2;
+    const xy = x * y2;
+    const xz = x * z2;
+
+    const yy = y * y2;
+    const yz = y * z2;
+    const zz = z * z2;
+
+    const wx = w * x2;
+    const wy = w * y2;
+    const wz = w * z2;
+
+    const sx = scale.x;
+    const sy = scale.y;
+    const sz = scale.z;
+
+    result[0] = (1 - (yy + zz)) * sx;
+    result[1] = (xy + wz) * sx;
+    result[2] = (xz - wy) * sx;
+    result[3] = 0;
+
+    result[4] = (xy - wz) * sy;
+    result[5] = (1 - (xx + zz)) * sy;
+    result[6] = (yz + wx) * sy;
+    result[7] = 0;
+
+    result[8] = (xz + wy) * sz;
+    result[9] = (yz - wx) * sz;
+    result[10] = (1 - (xx + yy)) * sz;
+    result[11] = 0;
+
+    result[12] = position.x;
+    result[13] = position.y;
+    result[14] = position.z;
+    result[15] = 1;
+}

package/core/geom/Vector1.js

@@ -68,9 +68,8 @@ class Vector1 extends Number {
      * @returns {Vector1}
      */
     set(x) {
-        assert.equal(typeof x, "number", `X must be of type "number", instead was "${typeof x}"`);
-
-        assert.ok(!Number.isNaN(x), `X must be a valid number, instead was NaN`);
+        assert.isNumber( x,'x');
+        assert.notNaN(x, 'x');
 
         const oldValue = this.x;
         if (oldValue !== x) {

package/engine/asset/loaders/GLTFAssetLoader.js

@@ -406,6 +406,9 @@ export class GLTFAssetLoader extends AssetLoader {
             asset.has_root_transform = has_root_transform;
             asset.root_transform = root_transform;
 
+            // remember GLTF metadata
+            asset.gltf = gltf;
+
             if (gltf.animations !== undefined) {
                 /**
                  *

package/engine/asset/loaders/gltf/GLTFAssetTransformMikkTSpaceTangents.js

@@ -0,0 +1,27 @@
+import { AssetTransformer } from "../../AssetTransformer.js";
+import { buffer_geometry_ensure_tangents } from "../../../graphics/geometry/MikkT/buffer_geometry_ensure_tangents.js";
+
+/**
+ * Ensures that all geometries have proper tangents
+ */
+export class GLTFAssetTransformMikkTSpaceTangents extends AssetTransformer {
+    /**
+     *
+     * @param {Asset} source
+     * @param {AssetDescription} asset_description
+     * @return {Promise<Asset>}
+     */
+    async transform(source, asset_description) {
+        const root = source.create();
+
+        root.traverse(o => {
+            if (o.isMesh && o.geometry !== null) {
+                buffer_geometry_ensure_tangents(o.geometry);
+            }
+        });
+
+        return source;
+    }
+
+    static INSTANCE = new GLTFAssetTransformMikkTSpaceTangents();
+}

package/engine/ecs/EntityComponentDataset.js

@@ -56,13 +56,16 @@ function validateIndexValue(index, name) {
  * @param {BitSet} mask
  * @returns {boolean} true if mask matches completely, false otherwise
  */
-function matchComponentMask(componentOccupancy, entityIndex, componentTypeCount, mask) {
+function matchComponentMask(
+    componentOccupancy,
+    entityIndex,
+    componentTypeCount,
+    mask
+) {
     const offset = entityIndex * componentTypeCount;
 
-    let componentIndex;
-
     for (
-        componentIndex = mask.nextSetBit(0);
+        let componentIndex = mask.nextSetBit(0);
         componentIndex !== -1;
         componentIndex = mask.nextSetBit(componentIndex + 1)
     ) {