@woosh/meep-engine 2.156.0 → 2.158.0

package/editor/view/node-graph/connection_wire_geometry.js

@@ -0,0 +1,107 @@
+import { line2_distance_to_point_sqr } from "../../../src/core/geom/2d/line/line2_distance_to_point_sqr.js";
+import { spline3_hermite } from "../../../src/core/math/spline/spline3_hermite.js";
+import { spline3_hermite_bounds } from "../../../src/core/math/spline/spline3_hermite_bounds.js";
+import { spline3_hermite_to_bezier } from "../../../src/core/math/spline/spline3_hermite_to_bezier.js";
+
+/*
+ * A connection wire is a cubic hermite spline in graph space: it leaves the source port
+ * horizontally, arrives at the target port horizontally, and is level vertically at both ends.
+ * This module is the single definition of that shape, shared by drawing, culling and hit-testing.
+ */
+
+/**
+ * Horizontal reach of a wire out of each endpoint, in graph units
+ * @type {number}
+ */
+export const WIRE_BEND_OFFSET_X = 100;
+
+/**
+ * Hermite tangent magnitude along X. Bezier control points sit at p ± m/3,
+ * which places them at ±{@link WIRE_BEND_OFFSET_X} from the endpoints.
+ * @type {number}
+ */
+const WIRE_TANGENT_X = WIRE_BEND_OFFSET_X * 3;
+
+/**
+ * Evaluate a point along a wire
+ * @param {Vector2} result
+ * @param {number} t position along the wire, in [0,1]
+ * @param {number} x0 source endpoint
+ * @param {number} y0
+ * @param {number} x1 target endpoint
+ * @param {number} y1
+ */
+export function wire_point(result, t, x0, y0, x1, y1) {
+    result.set(
+        spline3_hermite(t, x0, x1, WIRE_TANGENT_X, WIRE_TANGENT_X),
+        spline3_hermite(t, y0, y1, 0, 0)
+    );
+}
+
+/**
+ * Compute exact AABB of a wire
+ * @param {number[]|Float64Array} result 4 values: [x0, y0, x1, y1]
+ * @param {number} x0 source endpoint
+ * @param {number} y0
+ * @param {number} x1 target endpoint
+ * @param {number} y1
+ */
+export function wire_bounds(result, x0, y0, x1, y1) {
+    spline3_hermite_bounds(result, 0, 2, x0, x1, WIRE_TANGENT_X, WIRE_TANGENT_X);
+    spline3_hermite_bounds(result, 1, 2, y0, y1, 0, 0);
+}
+
+/**
+ * Convert a wire into a cubic bezier control polygon
+ * @param {number[]|Float64Array} result 8 values: [x0,y0, cx1,cy1, cx2,cy2, x1,y1]
+ * @param {number} x0 source endpoint
+ * @param {number} y0
+ * @param {number} x1 target endpoint
+ * @param {number} y1
+ */
+export function wire_to_bezier(result, x0, y0, x1, y1) {
+    spline3_hermite_to_bezier(result, 0, 2, x0, x1, WIRE_TANGENT_X, WIRE_TANGENT_X);
+    spline3_hermite_to_bezier(result, 1, 2, y0, y1, 0, 0);
+}
+
+/**
+ * Number of segments a wire is flattened into for distance queries
+ * @type {number}
+ */
+const DISTANCE_SAMPLE_COUNT = 32;
+
+/**
+ * Distance from a point to a wire.
+ * The wire is flattened into segments; precision is ample for cursor hit-testing.
+ * @param {number} px query point
+ * @param {number} py
+ * @param {number} x0 source endpoint
+ * @param {number} y0
+ * @param {number} x1 target endpoint
+ * @param {number} y1
+ * @returns {number}
+ */
+export function wire_distance_to_point(px, py, x0, y0, x1, y1) {
+    let prev_x = x0;
+    let prev_y = y0;
+
+    let best_sqr = Infinity;
+
+    for (let i = 1; i <= DISTANCE_SAMPLE_COUNT; i++) {
+        const t = i / DISTANCE_SAMPLE_COUNT;
+
+        const cx = spline3_hermite(t, x0, x1, WIRE_TANGENT_X, WIRE_TANGENT_X);
+        const cy = spline3_hermite(t, y0, y1, 0, 0);
+
+        const d_sqr = line2_distance_to_point_sqr(prev_x, prev_y, cx, cy, px, py);
+
+        if (d_sqr < best_sqr) {
+            best_sqr = d_sqr;
+        }
+
+        prev_x = cx;
+        prev_y = cy;
+    }
+
+    return Math.sqrt(best_sqr);
+}

package/package.json

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

package/samples/generation/SampleGenerator0.js

@@ -66,6 +66,7 @@ import { GridTags } from "./grid/GridTags.js";
 import { MirGridLayers } from "./grid/MirGridLayers.js";
 import { matcher_not_play_area } from "./rules/matcher_not_play_area.js";
 import { matcher_tag_traversable } from "./rules/matcher_tag_traversable.js";
+import { matcher_tag_unoccupied } from "./rules/matcher_tag_unoccupied.js";
 import { matcher_tag_traversable_unoccupied } from "./rules/matcher_tag_traversable_unoccupied.js";
 import { mir_matcher_attack_corridor } from "./rules/mir_matcher_attack_corridor.js";
 
@@ -111,6 +112,7 @@ const gMakeEmpty = GridTaskCellularAutomata.from({
 
 const gConnectRooms = GridTaskConnectRooms.from({
     matcher: matcher_tag_traversable,
+    modifiable: matcher_tag_unoccupied,
     action: aMakePlayArea
 });
 
@@ -264,7 +266,12 @@ gPlaceStartingPoint.addDependency(gBases);
 gRuleSet1.addDependency(gBases);
 
 
-const gRoads = new GridTaskGenerateRoads();
+const gRoads = GridTaskGenerateRoads.from({
+    traversable: matcher_tag_traversable,
+    actions: [
+        GridCellActionPlaceTags.from(GridTags.Road, MirGridLayers.Tags)
+    ]
+});
 
 gRoads.addDependency(gConnectRooms);
 gRoads.addDependency(gBases);

package/src/core/binary/reinterpret_float32_as_uint32.d.ts

@@ -0,0 +1,7 @@
+/**
+ *
+ * @param {number} value
+ * @returns {number}
+ */
+export function reinterpret_float32_as_uint32(value: number): number;
+//# sourceMappingURL=reinterpret_float32_as_uint32.d.ts.map

package/src/core/binary/reinterpret_float32_as_uint32.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reinterpret_float32_as_uint32.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/reinterpret_float32_as_uint32.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,qDAHW,MAAM,GACJ,MAAM,CAKlB"}

package/src/core/binary/reinterpret_float32_as_uint32.js

@@ -0,0 +1,13 @@
+const b = new ArrayBuffer(4);
+const b_f32 = new Float32Array(b);
+const b_u32 = new Uint32Array(b);
+
+/**
+ *
+ * @param {number} value
+ * @returns {number}
+ */
+export function reinterpret_float32_as_uint32(value) {
+    b_f32[0] = value;
+    return b_u32[0];
+}

package/src/core/binary/reinterpret_uint32_as_float32.d.ts

@@ -0,0 +1,7 @@
+/**
+ *
+ * @param {number} value
+ * @returns {number}
+ */
+export function reinterpret_uint32_as_float32(value: number): number;
+//# sourceMappingURL=reinterpret_uint32_as_float32.d.ts.map

package/src/core/binary/reinterpret_uint32_as_float32.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reinterpret_uint32_as_float32.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/reinterpret_uint32_as_float32.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,qDAHW,MAAM,GACJ,MAAM,CAMlB"}

package/src/core/binary/reinterpret_uint32_as_float32.js

@@ -0,0 +1,14 @@
+const b = new ArrayBuffer(4);
+const b_f32 = new Float32Array(b);
+const b_u32 = new Uint32Array(b);
+
+/**
+ *
+ * @param {number} value
+ * @returns {number}
+ */
+export function reinterpret_uint32_as_float32(value) {
+    b_u32[0] = value;
+
+    return b_f32[0];
+}

package/src/core/bvh2/bvh3/ebvh_build_for_geometry_incremental.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ebvh_build_for_geometry_incremental.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/ebvh_build_for_geometry_incremental.js"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,2EAJW,MAAM,EAAE,GAAC,YAAY,mBACrB,MAAM,EAAE,GAAC,YAAY,eACrB,MAAM,QA8BhB"}
+{"version":3,"file":"ebvh_build_for_geometry_incremental.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/ebvh_build_for_geometry_incremental.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,2EAJW,MAAM,EAAE,GAAC,YAAY,mBACrB,MAAM,EAAE,GAAC,YAAY,eACrB,MAAM,QA8BhB"}

package/src/core/bvh2/bvh3/ebvh_build_for_geometry_incremental.js

@@ -1,6 +1,4 @@
-import {
-    compute_triangle_group_aabb3
-} from "../../../engine/graphics/sh3/path_tracer/geometry/compute_triangle_group_aabb3.js";
+import { compute_triangle_group_aabb3 } from "../../geom/3d/aabb/compute_triangle_group_aabb3.js";
 import { min2 } from "../../math/min2.js";
 
 /**

package/src/core/bvh2/bvh3/query/bvh_query_user_data_overlaps_sphere.d.ts

@@ -0,0 +1,12 @@
+/**
+ *
+ * @param {number[]|Uint32Array} result
+ * @param {number} result_offset
+ * @param {BVH} bvh
+ * @param {number} x sphere center X
+ * @param {number} y sphere center Y
+ * @param {number} z sphere center Z
+ * @param {number} radius sphere radius
+ */
+export function bvh_query_user_data_overlaps_sphere(result: number[] | Uint32Array, result_offset: number, bvh: BVH, x: number, y: number, z: number, radius: number): number;
+//# sourceMappingURL=bvh_query_user_data_overlaps_sphere.d.ts.map

package/src/core/bvh2/bvh3/query/bvh_query_user_data_overlaps_sphere.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bvh_query_user_data_overlaps_sphere.d.ts","sourceRoot":"","sources":["../../../../../../src/core/bvh2/bvh3/query/bvh_query_user_data_overlaps_sphere.js"],"names":[],"mappings":"AASA;;;;;;;;;GASG;AACH,4DARW,MAAM,EAAE,GAAC,WAAW,iBACpB,MAAM,eAEN,MAAM,KACN,MAAM,KACN,MAAM,UACN,MAAM,UA0EhB"}

package/src/core/bvh2/bvh3/query/bvh_query_user_data_overlaps_sphere.js

@@ -0,0 +1,92 @@
+//
+import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
+import { aabb3_signed_distance_sqr_to_point } from "../../../geom/3d/aabb/aabb3_signed_distance_sqr_to_point.js";
+import { NULL_NODE } from "../BVH.js";
+
+const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
+
+const scratch_aabb = new Float32Array(6);
+
+/**
+ *
+ * @param {number[]|Uint32Array} result
+ * @param {number} result_offset
+ * @param {BVH} bvh
+ * @param {number} x sphere center X
+ * @param {number} y sphere center Y
+ * @param {number} z sphere center Z
+ * @param {number} radius sphere radius
+ */
+export function bvh_query_user_data_overlaps_sphere(
+    result,
+    result_offset,
+    bvh,
+    x,
+    y,
+    z,
+    radius
+) {
+    const root = bvh.root;
+
+    if (root === NULL_NODE) {
+        return 0;
+    }
+
+    const radius_sqr = radius * radius;
+
+    /**
+     *
+     * @type {number}
+     */
+    const stack_top = stack.pointer++;
+
+    stack[stack_top] = root;
+
+    let result_cursor = result_offset;
+
+    while (stack.pointer > stack_top) {
+        stack.pointer--;
+
+        /**
+         *
+         * @type {number}
+         */
+        const node = stack[stack.pointer];
+
+        // test node against the sphere
+        bvh.node_get_aabb(node, scratch_aabb);
+
+        const distance_sqr = aabb3_signed_distance_sqr_to_point(
+            scratch_aabb[0], scratch_aabb[1], scratch_aabb[2],
+            scratch_aabb[3], scratch_aabb[4], scratch_aabb[5],
+            x, y, z
+        );
+
+        const intersection_exists = distance_sqr <= radius_sqr;
+
+        if (!intersection_exists) {
+            // fully outside
+            continue;
+        }
+
+        const node_is_leaf = bvh.node_is_leaf(node);
+
+        if (node_is_leaf) {
+            // leaf node
+            result[result_cursor++] = bvh.node_get_user_data(node);
+
+        } else {
+            // 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
+            stack[stack.pointer++] = child1;
+            stack[stack.pointer++] = child2;
+        }
+    }
+
+    // drop stack frame
+
+    return result_cursor - result_offset;
+}

package/src/core/bvh8/BVH8.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Highest triangle offset storable in a leaf slot's meta byte. The low 5 bits of a leaf meta
+ * hold the offset of the slot's first triangle relative to the node's `base_index_triangle`;
+ * values 24..31 in those bits mark internal slots, so leaf offsets must not exceed 23.
+ * @type {number}
+ */
+export const BVH8_MAX_LEAF_TRIANGLE_OFFSET: number;
+/**
+ * @see https://github.com/jan-van-bergen/GPU-Raytracer/blob/6559ae2241c8fdea0ddaec959fe1a47ec9b3ab0d/Src/BVH/BVH.h#L61
+ * @description
+ * ```c
+ * struct BVHNode8 {
+ *    Vector3 p;
+ *    byte e[3];
+ *    byte imask;
+ *
+ *    unsigned base_index_child;
+ *    unsigned base_index_triangle;
+ *
+ *    byte meta[8] = { };
+ *
+ *    byte quantized_min_x[8] = { }, quantized_max_x[8] = { };
+ *    byte quantized_min_y[8] = { }, quantized_max_y[8] = { };
+ *    byte quantized_min_z[8] = { }, quantized_max_z[8] = { };
+ * }
+ * ```
+ *
+ * Slot encoding: `meta == 0` is an empty slot. A leaf slot stores the offset of its first
+ * triangle (relative to `base_index_triangle`) in the low 5 bits (≤ {@link BVH8_MAX_LEAF_TRIANGLE_OFFSET})
+ * and a unary triangle count in bits 5..7. An internal slot `i` stores `(24 + i) | 0b00100000` and has
+ * its bit set in `imask`; the k-th internal slot in ascending slot order is node `base_index_child + k`.
+ *
+ * Two triangle addressing conventions exist, depending on the build path:
+ * - direct (`bvh8_build_for_geometry`): `base_index_triangle` + meta offsets are geometry triangle
+ *   indices; the {@link BVH8#primitives} pool is unused.
+ * - indirect ({@link BVH8Converter}): they index into {@link BVH8#primitives}, whose entries are the
+ *   BVH2 leaves' user data (geometry triangle indices).
+ * Consumers must know which build path produced the tree — see `bvh8_geometry_validate` (direct)
+ * vs `bvh8_geometry_validate_indirect` (indirect).
+ */
+export class BVH8 {
+    /**
+     *
+     * @returns {ArrayBufferLike}
+     */
+    get data_buffer(): ArrayBufferLike;
+    /**
+     *
+     * @returns {number}
+     */
+    get node_capacity(): number;
+    clear(): void;
+    /**
+     *
+     * @return {BinaryElementPool}
+     */
+    get primitives(): BinaryElementPool;
+    /**
+     *
+     * @return {BinaryElementPool}
+     */
+    get nodes(): BinaryElementPool;
+    /**
+     * Allocate a single node. The node is zeroed.
+     * @return {number}
+     */
+    allocate_node(): number;
+    /**
+     * Allocate a continuous run of nodes. Allocated nodes are zeroed — pool memory is recycled
+     * as-is across {@link BVH8#clear}, and `meta == 0` means "empty slot" to every consumer, so
+     * nodes must start from a clean state.
+     * @param {number} count
+     * @returns {number} index of the first allocated node
+     */
+    allocate_nodes(count: number): number;
+    /**
+     *
+     * @param {number} node_index
+     * @param {number[]|Float32Array} output
+     */
+    node_get_p(node_index: number, output: number[] | Float32Array): void;
+    /**
+     *
+     * @param {number} node_index
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     */
+    node_set_p(node_index: number, x: number, y: number, z: number): void;
+    /**
+     *
+     * @param {number} node_index
+     * @param {number[]|Float32Array|Uint8Array} destination
+     */
+    node_get_e(node_index: number, destination: number[] | Float32Array | Uint8Array): void;
+    node_set_e(node_index: any, ex: any, ey: any, ez: any): void;
+    node_get_imask(node_index: any): number;
+    node_set_imask(node_index: any, imask: any): void;
+    node_get_base_index_child(node_index: any): number;
+    node_set_base_index_child(node_index: any, value: any): void;
+    node_get_base_index_triangle(node_index: any): number;
+    node_set_base_index_triangle(node_index: any, value: any): void;
+    /**
+     *
+     * @param {number} node_index
+     * @param {number} child_index
+     * @returns {number}
+     */
+    node_get_meta(node_index: number, child_index: number): number;
+    node_set_meta(node_index: any, child_index: any, value: any): void;
+    node_get_quantized_min(node_index: any, child_index: any, output: any): void;
+    node_set_quantized_min(node_index: any, child_index: any, x: any, y: any, z: any): void;
+    node_get_quantized_max(node_index: any, child_index: any, output: any): void;
+    node_set_quantized_max(node_index: any, child_index: any, x: any, y: any, z: any): void;
+    /**
+     *
+     * @param {number} node_index
+     * @param {number} child_index
+     * @return {boolean}
+     */
+    node_is_child_leaf(node_index: number, child_index: number): boolean;
+    get byteSize(): number;
+    trim(): void;
+    #private;
+}
+import { BinaryElementPool } from "../geom/3d/topology/struct/binary/BinaryElementPool.js";
+//# sourceMappingURL=BVH8.d.ts.map

package/src/core/bvh8/BVH8.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BVH8.d.ts","sourceRoot":"","sources":["../../../../src/core/bvh8/BVH8.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,4CAFU,MAAM,CAEgC;AAkChD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;IAII;;;OAGG;IACH,mCAEC;IAED;;;OAGG;IACH,4BAEC;IAED,cAGC;IAED;;;OAGG;IACH,oCAEC;IAED;;;OAGG;IACH,+BAEC;IAED;;;OAGG;IACH,iBAFY,MAAM,CAIjB;IAED;;;;;;OAMG;IACH,sBAHW,MAAM,GACJ,MAAM,CAalB;IAED;;;;OAIG;IACH,uBAHW,MAAM,UACN,MAAM,EAAE,GAAC,YAAY,QAa/B;IAED;;;;;;OAMG;IACH,uBALW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QAahB;IAED;;;;OAIG;IACH,uBAHW,MAAM,eACN,MAAM,EAAE,GAAC,YAAY,GAAC,UAAU,QAW1C;IAED,6DAaC;IAED,wCAQC;IAED,kDAUC;IAED,mDAOC;IAED,6DAOC;IAED,sDAOC;IAED,gEAOC;IAED;;;;;OAKG;IACH,0BAJW,MAAM,eACN,MAAM,GACJ,MAAM,CAoBlB;IAED,mEAcC;IAGD,6EAuBC;IAED,wFAuBC;IAED,6EAuBC;IAED,wFAuBC;IAED;;;;;OAKG;IACH,+BAJW,MAAM,eACN,MAAM,GACL,OAAO,CAMlB;IAED,uBAEC;IAED,aAGC;;CACJ;kCAlbiC,wDAAwD"}