@woosh/meep-engine 2.131.31 → 2.131.32

package/package.json

@@ -5,7 +5,7 @@
   "description": "Pure JavaScript game engine. Fully featured and production ready.",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.131.31",
+  "version": "2.131.32",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/engine/graphics/geometry/buffered/query/bvh32_geometry_nearest.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Get the nearest point on the geometry, relative to query point
+ *
+ * @param {SurfacePoint3} result
+ * @param {BinaryUint32BVH} bvh
+ * @param {number[]|ArrayLike<number>} vertices
+ * @param {number} vertex_offset Unless you're using an interleaved buffer of some kind, this will be 0
+ * @param {number} vertex_stride Unless you're using an interleaved buffer, this should be 3
+ * @param {boolean} vertex_data_normalized do we need to denormalize vertex data?
+ * @param {number[]|ArrayLike<number>|undefined} indices if this is set to undefined - implicit indexing will be used
+ * @param {number} x Query point X
+ * @param {number} y Query point Y
+ * @param {number} z Query point Z
+ * @param {number} [max_distance] limit search distance, useful for optimization
+ * @returns {boolean} true iff a point was found, false otherwise
+ */
+export function bvh32_geometry_nearest(result: SurfacePoint3, bvh: BinaryUint32BVH, vertices: number[] | ArrayLike<number>, vertex_offset: number, vertex_stride: number, vertex_data_normalized: boolean, indices: number[] | ArrayLike<number> | undefined, x: number, y: number, z: number, max_distance?: number): boolean;
+//# sourceMappingURL=bvh32_geometry_nearest.d.ts.map

package/src/engine/graphics/geometry/buffered/query/bvh32_geometry_nearest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bvh32_geometry_nearest.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/geometry/buffered/query/bvh32_geometry_nearest.js"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;;;;GAeG;AACH,8FAXW,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,iBAC1B,MAAM,iBACN,MAAM,0BACN,OAAO,WACP,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,SAAS,KACpC,MAAM,KACN,MAAM,KACN,MAAM,iBACN,MAAM,GACJ,OAAO,CAuNnB"}

package/src/engine/graphics/geometry/buffered/query/bvh32_geometry_nearest.js

@@ -0,0 +1,252 @@
+import { assert } from "../../../../../core/assert.js";
+import {
+    typed_array_value_denormalize
+} from "../../../../../core/collection/array/typed/typed_array_value_denormalize.js";
+import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../../../core/collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
+import {
+    aabb3_unsigned_distance_sqr_to_point
+} from "../../../../../core/geom/3d/aabb/aabb3_unsigned_distance_sqr_to_point.js";
+import {
+    computeTriangleClosestPointToPointBarycentric
+} from "../../../../../core/geom/3d/triangle/computeTriangleClosestPointToPointBarycentric.js";
+import { v3_compute_triangle_normal } from "../../../../../core/geom/3d/triangle/v3_compute_triangle_normal.js";
+import { v3_distance_sqr } from "../../../../../core/geom/vec3/v3_distance_sqr.js";
+
+const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
+
+/**
+ *
+ * @type {number[]}
+ */
+const v3_scratch_0 = [];
+
+/**
+ * Get the nearest point on the geometry, relative to query point
+ *
+ * @param {SurfacePoint3} result
+ * @param {BinaryUint32BVH} bvh
+ * @param {number[]|ArrayLike<number>} vertices
+ * @param {number} vertex_offset Unless you're using an interleaved buffer of some kind, this will be 0
+ * @param {number} vertex_stride Unless you're using an interleaved buffer, this should be 3
+ * @param {boolean} vertex_data_normalized do we need to denormalize vertex data?
+ * @param {number[]|ArrayLike<number>|undefined} indices if this is set to undefined - implicit indexing will be used
+ * @param {number} x Query point X
+ * @param {number} y Query point Y
+ * @param {number} z Query point Z
+ * @param {number} [max_distance] limit search distance, useful for optimization
+ * @returns {boolean} true iff a point was found, false otherwise
+ */
+export function bvh32_geometry_nearest(
+    result,
+    bvh,
+    vertices, vertex_offset, vertex_stride,
+    vertex_data_normalized,
+    indices,
+    x, y, z,
+    max_distance = Infinity,
+) {
+
+    let nearest_distance_sqr = max_distance * max_distance;
+
+    let got_a_hit = false;
+
+    const binary_node_count = bvh.binary_node_count;
+
+    if (binary_node_count <= 0) {
+        // this should not happen
+        return false;
+    }
+
+    /**
+     *
+     * @type {number}
+     */
+    const stack_top = stack.pointer++;
+
+    /**
+     * After performing empirical tests, stack-based depth-first traversal turns out faster than using a queue
+     * @type {number}
+     */
+    stack[stack_top] = 0;
+
+    const last_valid_index = binary_node_count + bvh.leaf_node_count;
+
+    const float32 = bvh.float32;
+    const uint32 = bvh.uint32;
+
+    do {
+        stack.pointer--;
+
+        // query_bvh_frustum_from_objects.iteration_count++;
+        const node_index = stack[stack.pointer];
+
+        const node_address = bvh.getNodeAddress(node_index);
+
+        const is_intermediate_node = node_index < binary_node_count;
+
+        if (is_intermediate_node) {
+            // is intermediate node
+
+            const left_index = (node_index << 1) + 1;
+            const right_index = left_index + 1;
+
+            if (right_index < last_valid_index) {
+
+                const child_1_address = bvh.getNodeAddress(left_index);
+
+                const distance_sqr_to_child1 = aabb3_unsigned_distance_sqr_to_point(
+                    float32[child_1_address], float32[child_1_address + 1], float32[child_1_address + 2],
+                    float32[child_1_address + 3], float32[child_1_address + 4], float32[child_1_address + 5],
+                    x, y, z
+                );
+
+                const child_2_address = bvh.getNodeAddress(right_index);
+
+                const distance_sqr_to_child2 = aabb3_unsigned_distance_sqr_to_point(
+                    float32[child_2_address], float32[child_2_address + 1], float32[child_2_address + 2],
+                    float32[child_2_address + 3], float32[child_2_address + 4], float32[child_2_address + 5],
+                    x, y, z
+                );
+
+                if (distance_sqr_to_child1 < distance_sqr_to_child2) {
+
+                    if (distance_sqr_to_child2 < nearest_distance_sqr) {
+                        stack[stack.pointer++] = right_index;
+                    }
+
+                    if (distance_sqr_to_child1 < nearest_distance_sqr) {
+                        stack[stack.pointer++] = left_index;
+                    }
+
+                } else {
+
+                    if (distance_sqr_to_child1 < nearest_distance_sqr) {
+                        stack[stack.pointer++] = left_index;
+                    }
+
+                    if (distance_sqr_to_child2 < nearest_distance_sqr) {
+                        stack[stack.pointer++] = right_index;
+                    }
+
+                }
+            } else if (left_index < last_valid_index) {
+                stack[stack.pointer++] = left_index;
+            }
+
+
+        } else {
+
+            // leaf node
+            // read triangle data
+            const triangle_index = uint32[node_address + 6];
+            const index3 = triangle_index * 3;
+
+            let a, b, c;
+            if (indices !== undefined) {
+                assert.lessThan(index3 + 2, indices.length, 'triangle index overflow, possibly geometry changed but tree was not rebuilt?');
+
+                a = indices[index3];
+                b = indices[index3 + 1];
+                c = indices[index3 + 2];
+            } else {
+                // implicit indices
+                a = index3;
+                b = index3 + 1;
+                c = index3 + 2;
+            }
+
+            const a_address = a * vertex_stride + vertex_offset;
+            const b_address = b * vertex_stride + vertex_offset;
+            const c_address = c * vertex_stride + vertex_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');
+
+            let ax = vertices[a_address];
+            let ay = vertices[a_address + 1];
+            let az = vertices[a_address + 2];
+
+            let bx = vertices[b_address];
+            let by = vertices[b_address + 1];
+            let bz = vertices[b_address + 2];
+
+            let cx = vertices[c_address];
+            let cy = vertices[c_address + 1];
+            let cz = vertices[c_address + 2];
+
+            // denormalize if necessary
+            if (vertex_data_normalized) {
+                ax = typed_array_value_denormalize(ax, vertices);
+                ay = typed_array_value_denormalize(ay, vertices);
+                az = typed_array_value_denormalize(az, vertices);
+
+                bx = typed_array_value_denormalize(bx, vertices);
+                by = typed_array_value_denormalize(by, vertices);
+                bz = typed_array_value_denormalize(bz, vertices);
+
+                cx = typed_array_value_denormalize(cx, vertices);
+                cy = typed_array_value_denormalize(cy, vertices);
+                cz = typed_array_value_denormalize(cz, vertices);
+            }
+
+            // denormalize if necessary
+            if (vertex_data_normalized) {
+                ax = typed_array_value_denormalize(ax, vertices);
+                ay = typed_array_value_denormalize(ay, vertices);
+                az = typed_array_value_denormalize(az, vertices);
+
+                bx = typed_array_value_denormalize(bx, vertices);
+                by = typed_array_value_denormalize(by, vertices);
+                bz = typed_array_value_denormalize(bz, vertices);
+
+                cx = typed_array_value_denormalize(cx, vertices);
+                cy = typed_array_value_denormalize(cy, vertices);
+                cz = typed_array_value_denormalize(cz, vertices);
+            }
+
+            computeTriangleClosestPointToPointBarycentric(
+                v3_scratch_0, 0,
+                x, x, x,
+                ax, ay, az,
+                bx, by, bz,
+                cx, cy, cz
+            );
+
+            const u = v3_scratch_0[0];
+            const v = v3_scratch_0[1];
+            const w = 1 - u - v;
+
+            // construct edge
+
+            const contact_x = ax * u + bx * v + cx * w;
+            const contact_y = ay * u + by * v + cy * w;
+            const contact_z = az * u + bz * v + cz * w;
+
+            const distance_to_triangle_sqr = v3_distance_sqr(
+                contact_x, contact_y, contact_z,
+                x, y, z
+            );
+
+            if (distance_to_triangle_sqr >= nearest_distance_sqr) {
+                continue;
+            }
+
+            nearest_distance_sqr = distance_to_triangle_sqr;
+
+            result.position.set(contact_x, contact_y, contact_z);
+
+            v3_compute_triangle_normal(result.normal, 0,
+                ax, ay, az,
+                bx, by, bz,
+                cx, cy, cz
+            );
+
+            result.index = triangle_index;
+
+            got_a_hit = true;
+        }
+    } while (stack.pointer > stack_top);
+
+    return got_a_hit;
+}

package/src/engine/input/devices/PointerDevice.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PointerDevice.d.ts","sourceRoot":"","sources":["../../../../../src/engine/input/devices/PointerDevice.js"],"names":[],"mappings":"AA2LA;;;;;GAKG;AACH,mDAJW,OAAO,SACP,UAAU,GAAC,KAAK,WAChB,OAAO,QAejB;AAED;;;;;GAKG;AACH;IAiFI;;;;OAIG;IACH,wBAHW,WAAW,EAsBrB;IAvGD;;;;OAIG;IACH,mBAFU,OAAO,CAEQ;IAIzB;;OAEG;IACH;;;;QAII;;WAEG;aADO,OAAO,OAAO,EAAE,CAAC,UAAU,GAAC,UAAU,CAAC,CAAC;;;;;;;;MAUpD;IAeF;;;OAGG;IACH,kBAAkB;IAElB;;;;OAIG;IACH,kBAFU,iBAAiB,EAAE,CAEL;IAExB;;;OAGG;IACH,yCAEC;IAED;;;OAGG;IACH,0CAEC;IAED;;;OAGG;IACH,2CAEC;IA2GD;;;OAGG;IACH,oBAFY,OAAO,CAIlB;IAED;;;OAGG;IACH,6BAsBC;IAED,0BAEC;IAED;;;;OAIG;IACH,qCAHW,OAAO,SACP,UAAU,GAAC,KAAK,QAI1B;IAED,cA6BC;IAED,aAsBC;;CACJ;oBArfmB,+BAA+B;mBADhC,uCAAuC;kCAOxB,wBAAwB"}
+{"version":3,"file":"PointerDevice.d.ts","sourceRoot":"","sources":["../../../../../src/engine/input/devices/PointerDevice.js"],"names":[],"mappings":"AA6MA;;;;;GAKG;AACH,mDAJW,OAAO,SACP,UAAU,GAAC,KAAK,WAChB,OAAO,QAejB;AAED;;;;;GAKG;AACH;IAiFI;;;;OAIG;IACH,wBAHW,WAAW,EAsBrB;IAvGD;;;;OAIG;IACH,mBAFU,OAAO,CAEQ;IAIzB;;OAEG;IACH;;;;QAII;;WAEG;aADO,OAAO,OAAO,EAAE,CAAC,UAAU,GAAC,UAAU,CAAC,CAAC;;;;;;;;MAUpD;IAeF;;;OAGG;IACH,kBAAkB;IAElB;;;;OAIG;IACH,kBAFU,iBAAiB,EAAE,CAEL;IAExB;;;OAGG;IACH,yCAEC;IAED;;;OAGG;IACH,0CAEC;IAED;;;OAGG;IACH,2CAEC;IA2GD;;;OAGG;IACH,oBAFY,OAAO,CAIlB;IAED;;;OAGG;IACH,6BAsBC;IAED,0BAEC;IAED;;;;OAIG;IACH,qCAHW,OAAO,SACP,UAAU,GAAC,KAAK,QAI1B;IAED,cA6BC;IAED,aAsBC;;CACJ;oBAvgBmB,+BAA+B;mBADhC,uCAAuC;kCAOxB,wBAAwB"}

package/src/engine/input/devices/PointerDevice.js

@@ -148,6 +148,10 @@ function observeDrag(up, down, move, dragStart, dragEnd, drag) {
         move.remove(handleDragStart);
     }
 
+    /**
+     *
+     * @param {Vector2} position
+     */
     function handleDragEnd(position) {
         up.remove(handleDragEnd);
         move.remove(handleDrag);
@@ -155,6 +159,11 @@ function observeDrag(up, down, move, dragStart, dragEnd, drag) {
         dragEnd.send1(position);
     }
 
+    /**
+     *
+     * @param {Vector2} position
+     * @param {PointerEvent} event
+     */
     function handleDragStart(position, event) {
 
         move.remove(handleDragStart);
@@ -170,11 +179,20 @@ function observeDrag(up, down, move, dragStart, dragEnd, drag) {
 
     const lastDragPosition = new Vector2();
 
+    /**
+     *
+     * @param {Vector2} position
+     * @param {PointerEvent} event
+     */
     function handleDrag(position, event) {
         drag.send4(position, origin, lastDragPosition, event);
         lastDragPosition.copy(position);
     }
 
+    /**
+     *
+     * @param {Vector2} position
+     */
     function handleDown(position) {
         origin.copy(position);
         up.add(noDrag);

package/src/view/elements/progress/segmented/SegmentedResourceBarView.d.ts

@@ -1,7 +1,7 @@
 export class SegmentedResourceBarView extends View<HTMLElement> {
     /**
      *
-     * @param {(Vector1|ObservedInteger)[]} value
+     * @param {(Vector1|ObservedInteger)[]} values
      * @param {Vector1|ObservedInteger|ReactiveExpression} [max=1]
      * @param {string[]} [classList]
      */

package/src/view/elements/progress/segmented/SegmentedResourceBarView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SegmentedResourceBarView.d.ts","sourceRoot":"","sources":["../../../../../../src/view/elements/progress/segmented/SegmentedResourceBarView.js"],"names":[],"mappings":"AAUA;IACI;;;;;OAKG;IACH,wCAJW,CAAC,OAAO,kBAAgB,CAAC,EAAE,EA4HrC;IAjHG;;;;OAIG;IACH,yBAA8B;IAE9B;;;;OAIG;IACH,oBAAsB;IAGtB;;;OAGG;IACH,YAFU,qBAAqB,CAEH;IAG5B,mBAAuC;IAQvC,qBAAiE;IAGjE,2BAAuB;IASvB,sBAAyD;IAIzD,yBAAoC;IAMpC;;;OAGG;IACH,gBAFU,QAAQ,CAsChB;IAWF;;;;OAIG;IACH,uBAA2C;IAqB/C,eAGC;IAED,qBAQC;IAED,wBAGC;IAED,uBAkGC;IAED,mBAyBC;CACJ;iBA3SgB,kBAAkB;iBAMlB,0CAA0C;sBAHrC,oBAAoB;2BADf,qBAAqB;qBAK3B,6BAA6B;oBAN9B,kCAAkC"}
+{"version":3,"file":"SegmentedResourceBarView.d.ts","sourceRoot":"","sources":["../../../../../../src/view/elements/progress/segmented/SegmentedResourceBarView.js"],"names":[],"mappings":"AAWA;IACI;;;;;OAKG;IACH,wCAJW,CAAC,OAAO,kBAAgB,CAAC,EAAE,EA+HrC;IAjHG;;;;OAIG;IACH,yBAA8B;IAE9B;;;;OAIG;IACH,oBAAsB;IAGtB;;;OAGG;IACH,YAFU,qBAAqB,CAEH;IAG5B,mBAAuC;IAQvC,qBAAiE;IAGjE,2BAAuB;IASvB,sBAAyD;IAIzD,yBAAoC;IAMpC;;;OAGG;IACH,gBAFU,QAAQ,CAsChB;IAWF;;;;OAIG;IACH,uBAA2C;IAqB/C,eAGC;IAED,qBAQC;IAED,wBAGC;IAED,uBAkGC;IAED,mBAyBC;CACJ;iBAzSgB,kBAAkB;iBALlB,0CAA0C;sBAOrC,oBAAoB;2BADf,qBAAqB;qBAH3B,6BAA6B;oBAF9B,kCAAkC"}

package/src/view/elements/progress/segmented/SegmentedResourceBarView.js

@@ -1,17 +1,18 @@
-import View from "../../../View.js";
+import { assert } from "../../../../core/assert.js";
+import List from "../../../../core/collection/list/List.js";
 import Vector1 from "../../../../core/geom/Vector1.js";
+import { clamp01 } from "../../../../core/math/clamp01.js";
+import ListView from "../../../common/ListView.js";
+import { DomSizeObserver } from "../../../util/DomSizeObserver.js";
+import View from "../../../View.js";
 import { CanvasView } from "../../CanvasView.js";
 import EmptyView from "../../EmptyView.js";
-import { DomSizeObserver } from "../../../util/DomSizeObserver.js";
 import { RESOURCE_BAR_SEGMENTS } from "./RESOURCE_BAR_SEGMENTS.js";
-import List from "../../../../core/collection/list/List.js";
-import ListView from "../../../common/ListView.js";
-import { clamp01 } from "../../../../core/math/clamp01.js";
 
 export class SegmentedResourceBarView extends View {
     /**
      *
-     * @param {(Vector1|ObservedInteger)[]} value
+     * @param {(Vector1|ObservedInteger)[]} values
      * @param {Vector1|ObservedInteger|ReactiveExpression} [max=1]
      * @param {string[]} [classList]
      */
@@ -22,6 +23,9 @@ export class SegmentedResourceBarView extends View {
                 }) {
         super();
 
+        assert.isArray(values, 'values');
+        assert.defined(max, 'max');
+
         /**
          *
          * @type {(Vector1|ObservedInteger)[]}