@woosh/meep-engine 2.33.22 → 2.33.23

package/core/bvh2/traversal/__detailed_box_volume_intersection.js

@@ -6,7 +6,6 @@ import { aabb3_edge_corner_mapping } from "../aabb3/aabb3_edge_corner_mapping.js
 import { __process_point_if_within_planes } from "./__process_point_if_within_planes.js";
 import { plane_computeConvex3PlaneIntersection } from "../../geom/3d/plane/plane_computeConvex3PlaneIntersection.js";
 import { EPSILON } from "../../math/MathUtils.js";
-import Vector3 from "../../geom/Vector3.js";
 
 /**
  *
@@ -26,7 +25,11 @@ const scratch_aabb_planes = new Float32Array(24);
  */
 const scratch_corner_out_bitfields = new Uint32Array(8);
 
-const scratch_v3 = new Vector3();
+/**
+ *
+ * @type {number[]}
+ */
+const scratch_v3_array = new Float32Array(3);
 
 /**
  *
@@ -183,7 +186,7 @@ export function __detailed_box_volume_intersection(
             const c = planes[plane_address + 3];
 
             const edge_intersects = plane3_computeLineSegmentIntersection(
-                scratch_v3,
+                scratch_v3_array, 0,
                 corner_0_x, corner_0_y, corner_0_z,
                 corner_1_x, corner_1_y, corner_1_z,
                 nx, ny, nz, c
@@ -192,7 +195,7 @@ export function __detailed_box_volume_intersection(
             if (edge_intersects) {
                 // a possible candidate, let's see if this point is within rest of the planes
                 __process_point_if_within_planes(
-                    scratch_v3.x, scratch_v3.y, scratch_v3.z,
+                    scratch_v3_array[0], scratch_v3_array[1], scratch_v3_array[2],
                     (plane_mask ^ plane_bit_mask),
                     planes,
                     plane_count,
@@ -230,7 +233,7 @@ export function __detailed_box_volume_intersection(
             const cp_1 = next_orthogonal_plane_index * 4;
 
             const intersection_exists = plane_computeConvex3PlaneIntersection(
-                scratch_v3,
+                scratch_v3_array, 0,
                 aabb_plane_nx, aabb_plane_ny, aabb_plane_nz, aabb_plane_constant,
                 planes[cp_0], planes[cp_0 + 1], planes[cp_0 + 2], planes[cp_0 + 3],
                 planes[cp_1], planes[cp_1 + 1], planes[cp_1 + 2], planes[cp_1 + 3]
@@ -238,14 +241,14 @@ export function __detailed_box_volume_intersection(
 
             if (intersection_exists) {
 
-                const point_within_box = box.containsPointWithTolerance(scratch_v3.x, scratch_v3.y, scratch_v3.z, EPSILON);
+                const point_within_box = box.containsPointWithTolerance(scratch_v3_array[0], scratch_v3_array[1], scratch_v3_array[2], EPSILON);
 
                 if (point_within_box) {
                     // point is within the AABB bounds
 
                     // ThreeClippingPlaneComputingBVHVisitor.DEBUG_POINTS_2.send3(scratch_v3.x, scratch_v3.y, scratch_v3.z);
 
-                    callback.call(thisArg, scratch_v3.x, scratch_v3.y, scratch_v3.z);
+                    callback.call(thisArg, scratch_v3_array[0], scratch_v3_array[1], scratch_v3_array[2]);
                 }
             }
         }

package/core/geom/3d/frustum/frustum3_computeNearestPointToPoint.js

@@ -14,6 +14,12 @@ const scratch_v3_0 = new Vector3();
 
 const scratch_v3_1 = new Vector3();
 
+/**
+ *
+ * @type {number[]}
+ */
+const scratch_v3_array = [];
+
 /**
  *
  * @param {Vector3} result
@@ -94,7 +100,9 @@ export function frustum3_computeNearestPointToPoint(result, planes, target_x, ta
         const plane_1 = planes[plane_1_index];
         const plane_2 = planes[plane_2_index];
 
-        plane_three_computeConvex3PlaneIntersection(result, plane_0, plane_1, plane_2);
+        plane_three_computeConvex3PlaneIntersection(scratch_v3_array, 0, plane_0, plane_1, plane_2);
+
+        result.readFromArray(scratch_v3_array, 0)
     }
 
     return false;

package/core/geom/3d/plane/plane_computeConvex3PlaneIntersection.js

@@ -2,19 +2,21 @@ import { v3_dot } from "../../v3_dot.js";
 
 /**
  *
- * @param {Vector3} result
+ * @param {number[]} result
+ * @param {number} result_offset
  * @param {Plane} a
  * @param {Plane} b
  * @param {Plane} c
  * @returns {boolean}
  */
-export function plane_three_computeConvex3PlaneIntersection(result, a, b, c) {
+export function plane_three_computeConvex3PlaneIntersection(result, result_offset, a, b, c) {
     const a_normal = a.normal;
     const b_normal = b.normal;
     const c_normal = c.normal;
 
     return plane_computeConvex3PlaneIntersection(
         result,
+        result_offset,
         a_normal.x, a_normal.y, a_normal.z, a.constant,
         b_normal.x, b_normal.y, b_normal.z, b.constant,
         c_normal.x, c_normal.y, c_normal.z, c.constant,
@@ -23,7 +25,8 @@ export function plane_three_computeConvex3PlaneIntersection(result, a, b, c) {
 
 /**
  * NOTE: Based on Intersection of 3 planes, Graphics Gems 1 pg 305
- * @param {Vector3} result
+ * @param {Float32Array|number[]|vec3} result
+ * @param {number} result_offset
  * @param {number} a_normal_x
  * @param {number} a_normal_y
  * @param {number} a_normal_z
@@ -39,7 +42,7 @@ export function plane_three_computeConvex3PlaneIntersection(result, a, b, c) {
  * @returns {boolean} true if planes intersect, false otherwise
  */
 export function plane_computeConvex3PlaneIntersection(
-    result,
+    result, result_offset,
     a_normal_x, a_normal_y, a_normal_z, a_constant,
     b_normal_x, b_normal_y, b_normal_z, b_constant,
     c_normal_x, c_normal_y, c_normal_z, c_constant
@@ -74,18 +77,14 @@ export function plane_computeConvex3PlaneIntersection(
     const d = 1 / determinant;
 
     const neg_a_constant = -a_constant;
-    const neg_b_constant = -b_constant;
-    const neg_c_constant = -c_constant;
 
-    const x = (bxc_x * neg_a_constant + cxa_x * neg_b_constant + axb_x * neg_c_constant) * d;
-    const y = (bxc_y * neg_a_constant + cxa_y * neg_b_constant + axb_y * neg_c_constant) * d;
-    const z = (bxc_z * neg_a_constant + cxa_z * neg_b_constant + axb_z * neg_c_constant) * d;
+    const x = (bxc_x * neg_a_constant - cxa_x * b_constant - axb_x * c_constant) * d;
+    const y = (bxc_y * neg_a_constant - cxa_y * b_constant - axb_y * c_constant) * d;
+    const z = (bxc_z * neg_a_constant - cxa_z * b_constant - axb_z * c_constant) * d;
 
-    result.set(
-        x,
-        y,
-        z
-    );
+    result[result_offset] = x;
+    result[result_offset + 1] = y;
+    result[result_offset + 2] = z;
 
     return true;
 }

package/core/geom/3d/voxel/DenseBitVolume3D.js

@@ -0,0 +1,87 @@
+import Vector3 from "../../Vector3.js";
+import { BitSet } from "../../../binary/BitSet.js";
+
+export class DenseBitVolume3D {
+    constructor() {
+        this.size = new Vector3(1, 1, 1);
+
+        this.__data = new BitSet();
+        this.__data.preventShrink();
+    }
+
+    clear() {
+        this.__data.reset();
+    }
+
+    resize(x, y, z) {
+        // TODO consider how we can resize while keeping the data
+        this.clear();
+
+        this.size.set(x, y, z);
+    }
+
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @return {number}
+     * @private
+     */
+    __compute_address(x, y, z) {
+
+        const size = this.size;
+
+        const dx = size.x;
+        const dy = size.y;
+
+        return y * dx + z * dx * dy + x;
+    }
+
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @return {boolean}
+     */
+    get(x, y, z) {
+        const address = this.__compute_address(x, y, z);
+
+        return this.__data.get(address)
+    }
+
+    /**
+     *
+     * @param {boolean} value
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     */
+    set(value, x, y, z) {
+        const address = this.__compute_address(x, y, z);
+
+        this.__data.set(address, value);
+    }
+
+    /**
+     *
+     * @param {number} u x-coordinate, normalized to [0,1] range
+     * @param {number} v y-coordinate, normalized to [0,1] range
+     * @param {number} w z-coordinate, normalized to [0,1] range
+     * @returns {boolean}
+     */
+    sampleNearest(u, v, w) {
+        const s = this.size;
+
+        const dx = s.x;
+        const dy = s.y;
+        const dz = s.z;
+
+        const x = Math.round(dx * u) % dx
+        const y = Math.round(dy * v) % dy
+        const z = Math.round(dz * w) % dz
+
+        return this.get(x, y, z);
+    }
+}

package/core/geom/3d/voxel/buildVolumeFromProjectedGeometry.js

@@ -0,0 +1,23 @@
+/**
+ * Build a world-space oriented volume
+ * @param {DenseBitVolume3D} volume
+ * @param {AABB3} bounds
+ * @param {{raycast:function(source_x:number, source_y:number, source_z:number, direction_x:number, direction_y:number, direction_z:number):number}} sampler
+ * @param {number[]} frustum 3d frustum, defined as series of 6 planes in order: normal_x, normal_y, normal_z, plane_offset
+ */
+export function buildVolumeFromProjectedGeometry({ volume, sampler, frustum }) {
+    // get frustum corners
+
+    // get first hits from "front" plane to seed the volume
+    for (let x = 0; x < 64; x++) {
+        for (let y = 0; y < 64; y++) {
+
+        }
+    }
+
+    // fit volume to the frustum
+
+    // create a connectivity graph to identify disconnected regions
+
+    // clear out disconnected regions starting from smallest until only one is left
+}

package/core/geom/Plane.js

@@ -192,7 +192,8 @@ export function computePlaneLineIntersection(out, originX, originY, originZ, dir
 
 /**
  *
- * @param {Vector3} result
+ * @param {Float32Array|number[]|vec3} result
+ * @param {number} result_offset
  * @param {number} x0
  * @param {number} y0
  * @param {number} z0
@@ -205,30 +206,34 @@ export function computePlaneLineIntersection(out, originX, originY, originZ, dir
  * @param {number} dist
  * @returns {boolean}
  */
-export function plane3_computeLineSegmentIntersection(result, x0, y0, z0, x1, y1, z1, normalX, normalY, normalZ, dist) {
+export function plane3_computeLineSegmentIntersection(
+    result, result_offset,
+    x0, y0, z0,
+    x1, y1, z1,
+    normalX, normalY, normalZ, dist
+) {
+
     const directionX = x1 - x0;
     const directionY = y1 - y0;
     const directionZ = z1 - z0;
 
     const denom = v3_dot(directionX, directionY, directionZ, normalX, normalY, normalZ);
 
-    const p = v3_dot(normalX, normalY, normalZ, x0, y0, z0) + dist;
-
     if (denom === 0) {
         return false;
     }
 
+    const p = v3_dot(normalX, normalY, normalZ, x0, y0, z0) + dist;
+
     const t = -p / denom;
 
     if (t < 0 || t > 1) {
         return false;
     }
 
-    result.set(
-        directionX * t + x0,
-        directionY * t + y0,
-        directionZ * t + z0
-    );
+    result[result_offset] = directionX * t + x0;
+    result[result_offset + 1] = directionY * t + y0;
+    result[result_offset + 2] = directionZ * t + z0;
 
     return true;
 

package/core/primitives/array/computeIntegerArrayHash.js

@@ -7,7 +7,7 @@
 export function computeIntegerArrayHash(data, offset, length) {
     const end = offset + length;
 
-    let hash = 0;
+    let hash = length;
 
     for (let i = offset; i < end; i++) {
         const singleValue = data[i];

package/engine/asset/loaders/material/computeImageBitmapEquality.js

@@ -79,6 +79,17 @@ function obtainCanvasCtx(width, height) {
     return gl;
 }
 
+/**
+ *
+ * @param {ImageBitmap} bitmap
+ * @return {Sampler2D}
+ */
+export function sampler_from_bitmap(bitmap) {
+    const ctx = obtainCanvasCtx(bitmap.width, bitmap.height);
+
+    return obtainSampler(bitmap, ctx);
+}
+
 /**
  *
  * @param {ImageBitmap} a

package/engine/asset/loaders/material/computeImageBitmapHash.js

@@ -1,47 +1,41 @@
 import { min2 } from "../../../../core/math/min2.js";
-import { computeIntegerArrayHash } from "../../../../core/primitives/array/computeIntegerArrayHash.js";
+import { sampler_from_bitmap } from "./computeImageBitmapEquality.js";
 
-let canvas = null;
-let canvasContext = null;
 
 /**
  *
- * @returns {CanvasRenderingContext2D}
+ * @param {ImageBitmap} bitmap
+ * @returns {number}
  */
-function getCanvasContext() {
+export function computeImageBitmapHash(bitmap) {
 
-    if (canvasContext === null) {
-        canvas = document.createElement('canvas');
+    const w = min2(bitmap.width, 8);
+    const h = min2(bitmap.height, 8);
 
-        canvas.height = 8;
-        canvas.width = 8;
+    const sampler = sampler_from_bitmap(bitmap);
 
-        canvasContext = canvas.getContext('2d');
+    const sampler_data = sampler.data;
+    const item_size = sampler.itemSize;
 
-    }
+    let hash = 0;
 
-    return canvasContext;
+    for (let y = 0; y < h; y++) {
 
-}
+        const row_size = y * sampler.width;
 
-/**
- *
- * @param {ImageBitmap} bitmap
- * @returns {number}
- */
-export function computeImageBitmapHash(bitmap) {
-    const ctx = getCanvasContext();
+        for (let x = 0; x < w; x++) {
 
-    const w = min2(bitmap.width, 8);
-    const h = min2(bitmap.height, 8);
+            const texel_index = x + row_size;
+            const address = texel_index * item_size;
 
-    ctx.clearRect(0, 0, w, h);
+            for (let i = 0; i < item_size; i++) {
 
-    ctx.drawImage(bitmap, 0, 0, w, h, 0, 0, w, h);
+                const v = sampler_data[address];
 
-    const imageData = ctx.getImageData(0, 0, w, h);
-
-    const data = imageData.data;
+                hash = (hash << 5) - hash + v;
+            }
+        }
+    }
 
-    return computeIntegerArrayHash(data, 0, data.length);
+    return hash;
 }

package/engine/ecs/util/hideEntityGracefully.js

@@ -15,10 +15,23 @@ import { DelayBehavior } from "../../intelligence/behavior/util/DelayBehavior.js
 import { Light } from "../../graphics/ecs/light/Light.js";
 import { TransitionPropertyVectorXBehavior } from "../../../../model/game/story/behaviors/generic/TransitionPropertyVectorXBehavior.js";
 
+/**
+ * @readonly
+ * @type {number}
+ */
 const SHUTDOWN_GRACE_PERIOD = 60;
 
+/**
+ *
+ * @type {Map<Class|function, function(T,entity?:EntityBuilder,createEntity?:function,createEntityContext?:*):number>}
+ */
 const component_shutdown = new Map();
 
+/**
+ * @template T
+ * @param {Class<T>} type
+ * @param {function(T,entity?:EntityBuilder,createEntity?:function,createEntityContext?:*):number} method
+ */
 function addShutdown(type, method) {
     component_shutdown.set(type, method);
 }
@@ -152,6 +165,11 @@ addShutdown(SoundEmitter, (soundEmitter, builder, createEntity, createEntityThis
  * @return {number} duration in seconds until the entity is completely hidden
  */
 export function hideEntityGracefully(builder, createEntity, createEntityThisArg) {
+    if (!builder.isBuilt) {
+        // already destroyed
+        return 0;
+    }
+
     let delay = 0;
 
     const components = builder.element;

package/engine/graphics/GraphicsEngine.js

@@ -345,23 +345,6 @@ GraphicsEngine.prototype.start = function () {
 
     const webGLRenderer = this.renderer = new WebGLRenderer(rendererParameters);
 
-    let g = 0;
-    let t = 0;
-    webGLRenderer.info.memory = {
-        get geometries() {
-            return g;
-        },
-        set geometries(v) {
-            g = v;
-        },
-        get textures() {
-            return t;
-        },
-        set textures(v) {
-            t = v;
-        }
-    };
-
     //print GPU info
     const GPU_NAME = this.getGPUName();
 

package/engine/graphics/camera/testClippingPlaneComputation.js

@@ -95,11 +95,11 @@ function makeConfig(engine) {
         new TopDownCameraControllerSystem(graphics),
         new TopDownCameraLanderSystem(),
         new CameraSystem(graphics.scene, graphics),
-        new MeshSystem(graphics, assetManager),
+        new MeshSystem(engine),
         new ClingToTerrainSystem(),
         new TerrainSystem(graphics, assetManager),
         new WaterSystem(graphics),
-        new Trail2DSystem(graphics, assetManager),
+        new Trail2DSystem(engine),
         new Foliage2System(assetManager, graphics),
         new ViewportPositionSystem(graphics.viewport.size),
         new GridPosition2TransformSystem(),