@woosh/meep-engine 2.33.20 → 2.33.24

package/engine/graphics/render/forward_plus/query/detailed_sphere_frustum_intersection_test.js

@@ -0,0 +1,86 @@
+import { v3_distance_sqr } from "../../../../../core/geom/v3_distance_sqr.js";
+import { biplanar_edge_mapping, triplanar_corner_mapping } from "./cube_mapping.js";
+import { line3_computeSegmentPointDistance_sqr } from "../../../../../core/geom/3d/line/line3_computeSegmentPointDistance_sqr.js";
+
+/**
+ *
+ * @param {number} radius
+ * @param {number} light_x
+ * @param {number} light_y
+ * @param {number} light_z
+ * @param {number} outside_plane_count
+ * @param {number} outside_plane_bitfield
+ * @param {number[]} points
+ * @return {boolean}
+ */
+export function detailed_sphere_frustum_intersection_test(
+    radius, light_x, light_y, light_z,
+    outside_plane_count, outside_plane_bitfield,
+    points
+) {
+
+    const radius_sqr = radius * radius;
+
+    if (outside_plane_count === 3) {
+        // nearest point in a corner, find the corner
+        const point_index = triplanar_corner_mapping[outside_plane_bitfield];
+
+        const point_address = point_index * 3;
+
+        const point_x = points[point_address];
+        const point_y = points[point_address + 1];
+        const point_z = points[point_address + 2];
+
+        const distance_to_light_sqr = v3_distance_sqr(
+            point_x, point_y, point_z,
+            light_x, light_y, light_z
+        );
+
+        // query_bvh_frustum_from_objects.checks_sphere_frustum_corner++;
+
+        // return distance_to_light_sqr <= radius_sqr;
+
+        if (distance_to_light_sqr > radius_sqr) {
+
+            // query_bvh_frustum_from_objects.rejection_sphere_count++;
+            return false;
+        }
+
+    } else if (outside_plane_count === 2) {
+        // nearest point is on an edge of two plane intersection
+        const edge_bitfield = biplanar_edge_mapping[outside_plane_bitfield];
+
+        // get 2 corners from edge bitfield
+        const corner_index_0 = edge_bitfield & 0b111;
+        const corner_address_0 = corner_index_0 * 3;
+
+        const corner_index_1 = (edge_bitfield >> 3) & 0b111;
+        const corner_address_1 = corner_index_1 * 3;
+
+        const point_0_x = points[corner_address_0];
+        const point_0_y = points[corner_address_0 + 1];
+        const point_0_z = points[corner_address_0 + 2];
+
+        const point_1_x = points[corner_address_1];
+        const point_1_y = points[corner_address_1 + 1];
+        const point_1_z = points[corner_address_1 + 2];
+
+        const distance_to_frustum_sqr = line3_computeSegmentPointDistance_sqr(
+            point_0_x, point_0_y, point_0_z,
+            point_1_x, point_1_y, point_1_z,
+            light_x, light_y, light_z
+        );
+
+        // query_bvh_frustum_from_objects.checks_sphere_frustum_edge++;
+
+        // return distance_to_frustum_sqr <= radius_sqr;
+
+        if (distance_to_frustum_sqr > radius_sqr) {
+
+            // query_bvh_frustum_from_objects.rejection_sphere_count++;
+            return false;
+        }
+    }
+
+    return true;
+}

package/engine/graphics/render/forward_plus/query/point_light_inside_volume.js

@@ -0,0 +1,73 @@
+import { detailed_sphere_frustum_intersection_test } from "./detailed_sphere_frustum_intersection_test.js";
+
+/**
+ *
+ * @param {number} light_x
+ * @param {number} light_y
+ * @param {number} light_z
+ * @param {number} radius
+ * @param {number[]} points
+ * @param {number[]|Float32Array|Float64Array} planes
+ * @returns {boolean}
+ */
+export function point_light_inside_volume(
+    light_x, light_y, light_z, radius,
+    points, planes
+) {
+    let j = 0;
+    let outside_plane_count = 0;
+    let outside_plane_bitfield = 0;
+
+    // validate if the sphere intersects the plane-bound space
+
+    // query_bvh_frustum_from_objects.checks_sphere++;
+
+    for (; j < 6; j++) {
+
+        const plane_address = j * 4;
+
+        const plane_normal_x = planes[plane_address];
+        const plane_normal_y = planes[plane_address + 1];
+        const plane_normal_z = planes[plane_address + 2];
+        const plane_constant = planes[plane_address + 3];
+
+        /*
+         compute distance from the center of the sphere to the plane
+         NOTE: inlined computation of distance from point to plane
+         */
+        const distance = (plane_normal_x * light_x + plane_normal_y * light_y + plane_normal_z * light_z) + plane_constant;
+
+        // query_bvh_frustum_from_objects.checks_sphere_plane++;
+
+        if (distance < 0) {
+            // center of the sphere is below the plane
+
+            if (distance < -radius) {
+                // sphere is entirely below the plane
+
+                // query_bvh_frustum_from_objects.rejection_sphere_count++;
+
+                return false;
+            }
+
+            // sphere intersects the plane
+
+            outside_plane_count++;
+
+            const plane_bit_mask = 1 << j;
+
+            outside_plane_bitfield |= plane_bit_mask;
+        }
+
+    }
+
+    if (outside_plane_count < 2) {
+        return true;
+    } else {
+        return detailed_sphere_frustum_intersection_test(
+            radius, light_x, light_y, light_z,
+            outside_plane_count, outside_plane_bitfield,
+            points
+        );
+    }
+}

package/engine/graphics/render/forward_plus/query/query_bvh_frustum_from_objects.js

@@ -0,0 +1,131 @@
+import { aabb3_computeDistanceAbovePlane } from "../../../../../core/geom/3d/aabb/aabb3_computeDistanceAbovePlane.js";
+import { point_light_inside_volume } from "./point_light_inside_volume.js";
+import { spot_light_inside_volume } from "./spot_light_inside_volume.js";
+
+/**
+ *
+ * @type {(BinaryNode|LeafNode)[]}
+ */
+const stack = [];
+
+let stackPointer = 0;
+
+/**
+ * Most of the data is in flat continuous array for cache coherence
+ * @param {PointLightData[]} destination
+ * @param {number} destination_offset
+ * @param {BinaryNode<PointLightData>} root
+ * @param {number[]|Float32Array|Float64Array} planes
+ * @param {number[]|Float32Array|Float64Array} points
+ * @returns {number} number of items added to the destination, non-negative integer
+ */
+export function query_bvh_frustum_from_objects(
+    destination,
+    destination_offset,
+    root, planes, points
+) {
+    let i = 0;
+    let j = 0;
+    // read out points
+    const stackOffset = stackPointer;
+
+    stack[stackPointer] = root;
+
+    stackPointer++;
+
+    stack_loop:while (stackPointer-- > stackOffset) {
+
+        // query_bvh_frustum_from_objects.iteration_count++;
+
+        const n = stack[stackPointer];
+
+        if (n.isBinaryNode === true) {
+
+            for (j = 0; j < 6; j++) {
+
+                const plane_address = j * 4;
+
+                const plane_normal_x = planes[plane_address];
+                const plane_normal_y = planes[plane_address + 1];
+                const plane_normal_z = planes[plane_address + 2];
+                const plane_constant = planes[plane_address + 3];
+
+                const distanceAbovePlane = aabb3_computeDistanceAbovePlane(
+                    plane_normal_x, plane_normal_y, plane_normal_z, plane_constant,
+                    n.x0, n.y0, n.z0,
+                    n.x1, n.y1, n.z1
+                );
+
+                if (distanceAbovePlane < 0) {
+                    // node is below the plane
+
+                    // query_bvh_frustum_from_objects.rejection_count++;
+
+                    continue stack_loop;
+                }
+            }
+
+
+            if (n.right !== null) {
+                stack[stackPointer] = n.right;
+                stackPointer++;
+            }
+
+            if (n.left !== null) {
+                stack[stackPointer] = n.left;
+                stackPointer++
+            }
+
+        } else {
+
+            // leaf node
+
+            /**
+             *
+             * @type {PointLightData}
+             */
+            const light_data = n.object;
+
+            const light = light_data.light;
+
+            if (light.isPointLight) {
+
+                const light_position = light.position;
+
+                const light_x = light_position.x;
+                const light_y = light_position.y;
+                const light_z = light_position.z;
+
+                const radius = light.radius.getValue();
+
+                if (!point_light_inside_volume(light_x, light_y, light_z, radius, points, planes)) {
+                    continue;
+                }
+            } else if (light.isSpotLight) {
+                if (!spot_light_inside_volume(light, points, planes)) {
+                    continue;
+                }
+            }
+
+            destination[destination_offset + i] = light_data;
+
+            i++;
+        }
+
+    }
+
+    //drop the stack frame
+    stackPointer = stackOffset;
+
+    return i;
+}
+
+query_bvh_frustum_from_objects.iteration_count = 0;
+query_bvh_frustum_from_objects.rejection_count = 0;
+query_bvh_frustum_from_objects.rejection_sphere_count = 0;
+query_bvh_frustum_from_objects.plane_tests = 0;
+query_bvh_frustum_from_objects.plane_tests_early_exits = 0;
+query_bvh_frustum_from_objects.checks_sphere = 0;
+query_bvh_frustum_from_objects.checks_sphere_plane = 0;
+query_bvh_frustum_from_objects.checks_sphere_frustum_corner = 0;
+query_bvh_frustum_from_objects.checks_sphere_frustum_edge = 0;

package/engine/graphics/render/forward_plus/query/query_bvh_frustum_from_texture.js

@@ -0,0 +1,129 @@
+import { aabb3_computeDistanceAbovePlane } from "../../../../../core/geom/3d/aabb/aabb3_computeDistanceAbovePlane.js";
+import { point_light_inside_volume } from "./point_light_inside_volume.js";
+import { BVH_BINARY_NODE_SIZE, BVH_LEAF_NODE_SIZE } from "../../../../../core/bvh2/binary/2/BinaryUint32BVH.js";
+
+/**
+ *
+ * @type {number[]}
+ */
+const stack = [];
+
+/**
+ * Most of the data is in flat continuous array for cache coherence
+ * @param {number[]} destination
+ * @param {number} destination_offset
+ * @param {BinaryUint32BVH} root
+ * @param {number[]|Uint8ClampedArray} source_data
+ * @param {number[]|Float32Array|Float64Array} planes
+ * @param {number[]|Float32Array|Float64Array} points
+ * @returns {number} number of items added to the destination, non-negative integer
+ */
+export function query_bvh_frustum_from_texture(
+    destination,
+    destination_offset,
+    root,
+    source_data,
+    planes, points
+) {
+
+    let stackPointer = 1;
+    let result = 0;
+
+    /**
+     * After performing empirical tests, stack-based depth-first traversal turns out faster than using a queue
+     * @type {number}
+     */
+    stack[0] = 0;
+
+    const binary_node_count = root.getBinaryNodeCount();
+    const last_valid_index = binary_node_count + root.getLeafNodeCount();
+    const data_view = root.getDataView();
+
+    stack_loop:while (stackPointer-- > 0) {
+
+        // query_bvh_frustum_from_objects.iteration_count++;
+        const node_index = stack[stackPointer];
+
+        if (node_index < binary_node_count) {
+            // is intermediate node
+            const node_address = node_index * BVH_BINARY_NODE_SIZE;
+
+            const n_x0 = data_view.getFloat32(node_address);
+            const n_y0 = data_view.getFloat32(node_address + 4);
+            const n_z0 = data_view.getFloat32(node_address + 8);
+            const n_x1 = data_view.getFloat32(node_address + 12);
+            const n_y1 = data_view.getFloat32(node_address + 16);
+            const n_z1 = data_view.getFloat32(node_address + 20);
+
+            for (let j = 0; j < 6; j++) {
+
+                const plane_address = j * 4;
+
+                const plane_normal_x = planes[plane_address];
+                const plane_normal_y = planes[plane_address + 1];
+                const plane_normal_z = planes[plane_address + 2];
+                const plane_constant = planes[plane_address + 3];
+
+                const distanceAbovePlane = aabb3_computeDistanceAbovePlane(
+                    plane_normal_x, plane_normal_y, plane_normal_z, plane_constant,
+                    n_x0, n_y0, n_z0,
+                    n_x1, n_y1, n_z1
+                );
+
+                if (distanceAbovePlane < 0) {
+                    // node is below the plane
+
+                    // query_bvh_frustum_from_objects.rejection_count++;
+
+                    continue stack_loop;
+                }
+
+                // TODO under current scheme we can reserve 6 bit in what we push onto the stack for plane mask (allows us to skip some planar tests)
+            }
+
+            const left_index = (node_index << 1) + 1;
+            const right_index = left_index + 1;
+
+            if (left_index < last_valid_index) {
+                stack[stackPointer] = left_index;
+                stackPointer++;
+            }
+
+            if (right_index < last_valid_index) {
+                stack[stackPointer] = right_index;
+                stackPointer++;
+            }
+
+
+        } else {
+            // leaf node
+            const leaf_index = node_index - binary_node_count;
+            const node_address = leaf_index * BVH_LEAF_NODE_SIZE + binary_node_count * BVH_BINARY_NODE_SIZE;
+
+            const light_index = data_view.getUint32(node_address + 24);
+
+            const light_address = light_index * 8;
+
+            // TODO figure out light type from address
+
+
+            const light_x = source_data[light_address];
+            const light_y = source_data[light_address + 1];
+            const light_z = source_data[light_address + 2];
+
+            const radius = source_data[light_address + 3];
+
+            if (!point_light_inside_volume(light_x, light_y, light_z, radius, points, planes)) {
+                continue;
+            }
+
+            // write to output
+            destination[destination_offset + result] = light_index;
+
+            result++;
+        }
+
+    }
+
+    return result;
+}

package/engine/graphics/render/forward_plus/query/spot_light_inside_volume.js

@@ -0,0 +1,33 @@
+import { computeConePlaneSide } from "../../../../../core/geom/3d/cone/computeConePlaneSide.js";
+
+/**
+ *
+ * @param {SpotLight} light
+ * @param {number[]} points
+ * @param {number[]|Float32Array|Float64Array} planes
+ * @returns {boolean}
+ */
+export function spot_light_inside_volume(light, points, planes) {
+    for (let j = 0; j < 6; j++) {
+
+        const plane_address = j * 4;
+
+        const plane_normal_x = planes[plane_address];
+        const plane_normal_y = planes[plane_address + 1];
+        const plane_normal_z = planes[plane_address + 2];
+        const plane_constant = planes[plane_address + 3];
+
+        const side = computeConePlaneSide(
+            plane_normal_x, plane_normal_y, plane_normal_z, plane_constant,
+            light.position.x, light.position.y, light.position.z,
+            light.direction.x, light.direction.y, light.direction.z,
+            light.angle.getValue(), light.distance.getValue()
+        );
+
+        if (side < 0) {
+            return false;
+        }
+    }
+
+    return true;
+}

package/engine/graphics/render/forward_plus/read_frustum_corner.js

@@ -0,0 +1,14 @@
+/**
+ *
+ * @param {number[]|Float32Array|Float64Array} source
+ * @param {number} source_index
+ * @param {number[]|Float32Array|Float64Array} destination
+ * @param {number} destination_offset
+ */
+export function read_frustum_corner(source, source_index, destination, destination_offset) {
+    const address = source_index * 3;
+
+    destination[destination_offset] = source[address];
+    destination[destination_offset + 1] = source[address + 1];
+    destination[destination_offset + 2] = source[address + 2];
+}

package/engine/graphics/render/forward_plus/testClusterEquality.js

@@ -0,0 +1,22 @@
+/**
+ *
+ * @param {number[]} light_data
+ * @param {number} count
+ * @param {number[]|Uint32Array|Uint16Array|Uint8Array|Uint8ClampedArray} light_lookup_texture_data
+ * @param {number} address
+ * @returns {boolean}
+ */
+export function testClusterEquality(light_data, count, light_lookup_texture_data, address) {
+    for (let i = 0; i < count; i++) {
+
+        const existing_light_address = light_lookup_texture_data[address + i];
+
+        const datum = light_data[i] * 2;
+
+        if (datum !== existing_light_address) {
+            return false;
+        }
+    }
+
+    return true;
+}

package/engine/graphics/render/layers/RenderLayerUtils.js

@@ -1,6 +1,5 @@
-import Vector3 from "../../../../core/geom/Vector3.js";
 import { computePointDistanceToPlane } from "../../../../core/geom/Plane.js";
-import { plane_three_computeConvex3PlaneIntersection } from "../../../../core/geom/3d/plane_computeConvex3PlaneIntersection.js";
+import { plane_three_computeConvex3PlaneIntersection } from "../../../../core/geom/3d/plane/plane_computeConvex3PlaneIntersection.js";
 
 /**
  *
@@ -10,7 +9,11 @@ import { plane_three_computeConvex3PlaneIntersection } from "../../../../core/ge
  */
 export function buildPlanarRenderLayerClipPlaneComputationMethod(traversePlanes, bias = 0) {
 
-    const p = new Vector3();
+    /**
+     *
+     * @type {number[]}
+     */
+    const p = [];
 
     const adjacentPlanePairs = [
         [],
@@ -38,7 +41,7 @@ export function buildPlanarRenderLayerClipPlaneComputationMethod(traversePlanes,
             const p0 = pair[0];
             const p1 = pair[1];
 
-            const planeIntersection = plane_three_computeConvex3PlaneIntersection(p, p0, p1, objectPlane);
+            const planeIntersection = plane_three_computeConvex3PlaneIntersection(p, 0, p0, p1, objectPlane);
 
             if (!planeIntersection) {
                 //no intersection
@@ -48,7 +51,7 @@ export function buildPlanarRenderLayerClipPlaneComputationMethod(traversePlanes,
 
             const plane_normal = nearPlane.normal;
 
-            const distanceToNearPlane = computePointDistanceToPlane(p.x, p.y, p.z, plane_normal.x, plane_normal.y, plane_normal.z, nearPlane.constant);
+            const distanceToNearPlane = computePointDistanceToPlane(p[0], p[1], p[2], plane_normal.x, plane_normal.y, plane_normal.z, nearPlane.constant);
 
             //update near and far plane distances
             if (distanceToNearPlane > 0 && distanceToNearPlane < range.near) {

package/engine/graphics/render/visibility/IncrementalDeltaSet.js

@@ -2,6 +2,7 @@ import { BitSet } from "../../../../core/binary/BitSet.js";
 import Signal from "../../../../core/events/signal/Signal.js";
 import { assert } from "../../../../core/assert.js";
 import { IllegalStateException } from "../../../../core/fsm/exceptions/IllegalStateException.js";
+import { arrayQuickSort } from "../../../../core/collection/array/arrayQuickSort.js";
 
 /**
  * @readonly
@@ -68,6 +69,16 @@ export class IncrementalDeltaSet {
         this.state = IncrementalDeltaSetState.Clear;
     }
 
+
+    /**
+     *
+     * @param {function(T):number} score_function
+     * @param {*} [score_context]
+     */
+    sort(score_function, score_context) {
+        arrayQuickSort(this.elements, score_function, score_context, 0, this.size - 1);
+    }
+
     /**
      *
      * @param {V} element

package/engine/graphics/render/visibility/hiz/prototypeHiZ.js

@@ -62,7 +62,6 @@ import { buildCanvasViewFromTexture } from "./buildCanvasViewFromTexture.js";
 import { BatchOcclusionQuery } from "./query/BatchOcclusionQuery.js";
 import HeadsUpDisplay from "../../../../ecs/gui/hud/HeadsUpDisplay.js";
 import LabelView from "../../../../../view/common/LabelView.js";
-import { randomFloatBetween } from "../../../../../core/math/MathUtils.js";
 import { seededRandom } from "../../../../../core/math/random/seededRandom.js";
 import { Sampler2D } from "../../../texture/sampler/Sampler2D.js";
 import { inverseLerp } from "../../../../../core/math/inverseLerp.js";
@@ -71,6 +70,7 @@ import { max2 } from "../../../../../core/math/max2.js";
 import { min2 } from "../../../../../core/math/min2.js";
 import { buildCubeURLs } from "../../../texture/cubemap/buildCubeURLs.js";
 import { mat4 } from "gl-matrix";
+import { randomFloatBetween } from "../../../../../core/math/random/randomFloatBetween.js";
 
 const engineHarness = new EngineHarness();
 
@@ -112,7 +112,7 @@ function makeConfig(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(),

package/engine/graphics/texture/atlas/AtlasPatch.js

@@ -5,12 +5,15 @@ import AABB2 from "../../../../core/geom/AABB2.js";
 export class AtlasPatch {
     constructor() {
         /**
-         *
+         * Position in the atlas where the raw patch data is found, excludes padding
+         * @readonly
          * @type {Vector2}
          */
         this.position = new Vector2(0, 0);
+
         /**
-         *
+         * Size in pixels of the patch, excludes padding
+         * @readonly
          * @type {Vector2}
          */
         this.size = new Vector2(0, 0);
@@ -34,11 +37,13 @@ export class AtlasPatch {
         this.sampler = null;
 
         /**
+         * @readonly
          * @type {Rectangle}
          */
         this.uv = new Rectangle(0, 0, 0, 0);
 
         /**
+         * Area in the atlas where patch along with the padding is packed into
          * Used for packing inside TextureAtlas. Do not modify manually
          * @readonly
          * @protected

package/engine/graphics/texture/atlas/TextureAtlas.js

@@ -82,8 +82,8 @@ export class TextureAtlas {
      * @returns {boolean}
      */
     contains(patch) {
-        assert.notEqual(patch, null, 'patch is null');
-        assert.notEqual(patch, undefined, 'patch is undefined');
+        assert.notNull(patch, 'patch');
+        assert.defined(patch, 'patch');
         assert.ok(patch.isAtlasPatch, 'patch argument is not an AtlasPatch');
 
         return this.patches.includes(patch);
@@ -116,28 +116,32 @@ export class TextureAtlas {
      *
      * @param {number} x
      * @param {number} y
-     * @returns {boolean}
+     * @returns {boolean} true if resizing successful, false otherwise
      */
     resize(x, y) {
         //check if any patches would be cut
         const patches = this.patches;
         const numPatches = patches.length;
-        const patchBoundsViolated = patches.some(patch => {
 
-            if (!patch.getFlag(AtlasPatchFlag.Packed)) {
+        //update patch UVs
+        for (let i = 0; i < numPatches; i++) {
+            const patch = patches[i];
+
+            if (patch.getFlag(AtlasPatchFlag.Packed)) {
                 //only care about packed patches
-                return false;
-            }
 
-            const x1 = patch.position.x + patch.size.x + patch.padding;
-            const y1 = patch.position.y + patch.size.y + patch.padding;
+                const pp = patch.position;
+                const ps = patch.size;
 
-            return x1 >= x || y1 >= y;
-        });
+                const x1 = pp.x + ps.x + patch.padding;
+                const y1 = pp.y + ps.y + patch.padding;
 
-        if (patchBoundsViolated) {
-            //Resizing atlas would result in some patches not fitting
-            return false;
+                if (x1 >= x || y1 >= y) {
+                    // patch bounds would violate the desired atlas extends
+                    //Resizing atlas would result in some patches not fitting
+                    return false;
+                }
+            }
         }
 
         //update patch UVs

package/engine/graphics/texture/sampler/HarmonicDiffusionGrid.spec.js

@@ -1,6 +1,6 @@
 import { seededRandom } from "../../../../core/math/random/seededRandom.js";
 import { HarmonicDiffusionGrid } from "./HarmonicDiffusionGrid.js";
-import { randomIntegerBetween} from "../../../../core/math/MathUtils.js";
+import { randomIntegerBetween } from "../../../../core/math/random/randomIntegerBetween.js";
 
 test("constructor doesn't throw", () => {
     new HarmonicDiffusionGrid([], 0, 0);