@woosh/meep-engine 2.65.0 → 2.66.0

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

@@ -1,27 +1,27 @@
+import { BVH_BINARY_NODE_SIZE, BVH_LEAF_NODE_SIZE } from "../../../../../core/bvh2/binary/2/BinaryUint32BVH.js";
+import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../../../core/collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
 import {
     aabb3_compute_distance_above_plane_max
 } from "../../../../../core/geom/3d/aabb/aabb3_compute_distance_above_plane_max.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";
-import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../../../core/collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
 
 const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
 
 /**
  *
- * @param {DataView} data_view
+ * @param {Float32Array} data
  * @param {number} address
  * @param {ArrayLike<number>|number[]} planes
  * @return {boolean}
  */
-function frustum_check(data_view, address, planes) {
-    const n_x0 = data_view.getFloat32(address);
-    const n_y0 = data_view.getFloat32(address + 4);
-    const n_z0 = data_view.getFloat32(address + 8);
+function frustum_check(data, address, planes) {
+    const n_x0 = data[address];
+    const n_y0 = data[address + 1];
+    const n_z0 = data[address + 2];
 
-    const n_x1 = data_view.getFloat32(address + 12);
-    const n_y1 = data_view.getFloat32(address + 16);
-    const n_z1 = data_view.getFloat32(address + 20);
+    const n_x1 = data[address + 3];
+    const n_y1 = data[address + 4];
+    const n_z1 = data[address + 5];
 
     for (let plane_address = 0; plane_address < 24; plane_address += 4) {
 
@@ -54,7 +54,7 @@ function frustum_check(data_view, address, planes) {
  * Most of the data is in flat continuous array for cache coherence
  * @param {number[]} destination
  * @param {number} destination_offset
- * @param {BinaryUint32BVH} root
+ * @param {BinaryUint32BVH} bvh
  * @param {number[]|Uint8ClampedArray} source_data
  * @param {number[]|Float32Array|Float64Array} planes
  * @param {number[]|Float32Array|Float64Array} points
@@ -63,13 +63,13 @@ function frustum_check(data_view, address, planes) {
 export function query_bvh_frustum_from_texture(
     destination,
     destination_offset,
-    root,
+    bvh,
     source_data,
     planes, points
 ) {
     let result = 0;
 
-    const binary_node_count = root.getBinaryNodeCount();
+    const binary_node_count = bvh.getBinaryNodeCount();
 
     if (binary_node_count <= 0) {
         // this should not happen
@@ -88,8 +88,10 @@ export function query_bvh_frustum_from_texture(
      */
     stack[stack_top] = 0;
 
-    const last_valid_index = binary_node_count + root.getLeafNodeCount();
-    const data_view = root.getDataView();
+    const last_valid_index = binary_node_count + bvh.getLeafNodeCount();
+
+    const float32 = bvh.float32;
+    const uint32 = bvh.uint32;
 
     do {
         stack.pointer--;
@@ -101,7 +103,7 @@ export function query_bvh_frustum_from_texture(
             // is intermediate node
             const node_address = node_index * BVH_BINARY_NODE_SIZE;
 
-            if (!frustum_check(data_view, node_address, planes)) {
+            if (!frustum_check(float32, node_address, planes)) {
                 continue;
             }
 
@@ -124,7 +126,7 @@ export function query_bvh_frustum_from_texture(
 
             const node_address = leaf_index * BVH_LEAF_NODE_SIZE + binary_node_count * BVH_BINARY_NODE_SIZE;
 
-            const light_descriptor = data_view.getUint32(node_address + 24);
+            const light_descriptor = uint32[node_address + 6];
 
             const light_type = light_descriptor & 3;
 
@@ -148,7 +150,7 @@ export function query_bvh_frustum_from_texture(
             } else if (light_type === 3) {
                 // decal
 
-                if (!frustum_check(data_view, node_address, planes)) {
+                if (!frustum_check(float32, node_address, planes)) {
                     continue;
                 }
 
@@ -162,7 +164,7 @@ export function query_bvh_frustum_from_texture(
             result++;
         }
 
-    }while (stack.pointer > stack_top)
+    } while (stack.pointer > stack_top)
 
     return result;
 }

package/src/engine/graphics/render/layers/RenderLayer.d.ts

@@ -1,15 +1,21 @@
-import {BinaryNode} from "../../../../core/bvh2/BinaryNode";
-import {RenderLayerState} from "./RenderLayerState";
 import {Object3D} from "three";
+import {BinaryNode} from "../../../../core/bvh2/BinaryNode";
 import {IncrementalDeltaSet} from "../visibility/IncrementalDeltaSet";
+import {RenderLayerState} from "./RenderLayerState";
 
 export class RenderLayer {
+    /**
+     * @deprecated
+     */
     bvh: BinaryNode
     name: string
     state: RenderLayerState
 
     managed: boolean
 
+    /**
+     * @deprecated
+     */
     extractRenderable(leafData: any): Object3D
 
     /**

package/src/engine/graphics/render/layers/RenderLayer.js

@@ -4,18 +4,10 @@
 
 
 import { BinaryNode } from '../../../../core/bvh2/BinaryNode.js';
-import { RenderPassType } from "../RenderPassType.js";
-import { IncrementalDeltaSet } from "../visibility/IncrementalDeltaSet.js";
 import { passThrough } from "../../../../core/function/Functions.js";
-import { traverseBinaryNodeUsingVisitor } from "../../../../core/bvh2/traversal/traverseBinaryNodeUsingVisitor.js";
-import {
-    ThreeClippingPlaneComputingBVHVisitor
-} from "../../../../core/bvh2/traversal/ThreeClippingPlaneComputingBVHVisitor.js";
-import { RenderLayerState } from "./RenderLayerState.js";
 import { compare_three_objects } from "../../three/compare_three_objects.js";
-import {
-    queryBinaryNode_FrustumIntersections_Data
-} from "../../../../core/bvh2/traversal/queryBinaryNode_FrustumIntersections.js";
+import { IncrementalDeltaSet } from "../visibility/IncrementalDeltaSet.js";
+import { RenderLayerState } from "./RenderLayerState.js";
 
 
 /**
@@ -27,7 +19,7 @@ const scratch_array = [];
 export class RenderLayer {
     constructor() {
         /**
-         *
+         * @deprecated
          * @type {BinaryNode}
          */
         this.bvh = new BinaryNode();
@@ -65,12 +57,6 @@ export class RenderLayer {
          * @type {IncrementalDeltaSet<THREE.Object3D>}
          */
         this.visibleSet = new IncrementalDeltaSet(compare_three_objects);
-
-        /**
-         *
-         * @type {RenderPassType|number}
-         */
-        this.renderPass = RenderPassType.Opaque;
     }
 
     /**
@@ -92,6 +78,7 @@ export class RenderLayer {
     /**
      * Compute near and far clipping planes for a camera given a frustum.
      * Note: near plane is frustum.planes[4], far plane is frustum.planes[5]
+     * @deprecated
      * @param {Frustum} frustum
      * @param {number} near
      * @param {number} far
@@ -99,62 +86,17 @@ export class RenderLayer {
      * @param [thisArg]
      */
     computeNearFarClippingPlanes(frustum, near, far, callback, thisArg) {
-        const tree = this.bvh;
-
-        bvh_visitor_ClippingPlanes.setFrustum(frustum);
-        bvh_visitor_ClippingPlanes.near = near;
-        bvh_visitor_ClippingPlanes.far = far;
-
-        if (!tree.isEmpty()) {
-
-            // only do the actual traversal if the tree is not empty
-            traverseBinaryNodeUsingVisitor(tree, bvh_visitor_ClippingPlanes);
-
-        }
-
-        callback.call(thisArg, bvh_visitor_ClippingPlanes.near, bvh_visitor_ClippingPlanes.far);
-
+        throw new Error('deprecated');
     }
 
     /**
-     *
+     @deprecated
      * @param {THREE.Object3D[]} destination
      * @param {number} destination_offset
      * @param {CameraView} view
      * @returns {number} Number of records added to destination
      */
     buildVisibleSet(destination, destination_offset, view) {
-        const frustum = view.frustum;
-
-        const reader = this.extractRenderable;
-
-        if (typeof reader !== "function") {
-            // no reader method
-            return 0;
-        }
-
-        const intersection_count = queryBinaryNode_FrustumIntersections_Data(scratch_array, 0, this.bvh, frustum);
-
-        let additions = 0;
-        let i = 0;
-
-        for (; i < intersection_count; i++) {
-            const datum = scratch_array[i];
-
-            const object3D = reader(datum);
-
-            if (!object3D) {
-                // null or undefined
-                continue;
-            }
-
-            destination[additions + destination_offset] = object3D;
-
-            additions++;
-        }
-
-        return additions;
+        throw new Error('deprecated');
     }
 }
-
-const bvh_visitor_ClippingPlanes = new ThreeClippingPlaneComputingBVHVisitor();

package/src/engine/graphics/render/make_bvh_visibility_builder.js

@@ -0,0 +1,64 @@
+import { assert } from "../../../core/assert.js";
+import {
+    bvh_query_user_data_overlaps_frustum
+} from "../../../core/bvh2/bvh3/query/bvh_query_user_data_overlaps_frustum.js";
+
+/**
+ * Assumes that BVH stored entity IDs
+ * @param {EntityManager} em
+ * @param {BVH} bvh
+ * @param {function(Object3D[],number,number,EntityComponentDataset)} extract
+ * @param {*} [extract_context]
+ * @returns {(function(Object3D[], number, CameraView): number)|*}
+ */
+export function make_bvh_visibility_builder(em, bvh, extract, extract_context) {
+    assert.defined(em, 'em');
+    assert.defined(bvh, 'bvh');
+    assert.isFunction(extract, 'extract');
+
+    const scratch_array = [];
+
+    /**
+     *
+     * @param {THREE.Object3D[]} destination
+     * @param {number} destination_offset
+     * @param {CameraView} view
+     * @returns {number} Number of records added to destination
+     */
+    function compute(destination, destination_offset, view) {
+
+        if (em === null) {
+            return 0;
+        }
+
+        const dataset = em.dataset;
+
+        if (dataset === null) {
+            return 0;
+        }
+
+        const matches = bvh_query_user_data_overlaps_frustum(
+            scratch_array, 0,
+            bvh, view.frustum
+        );
+
+        let additions = 0;
+
+        for (let i = 0; i < matches; i++) {
+            const entity = scratch_array[i];
+
+            const offset = destination_offset + additions;
+
+            const elements_from_entity = extract.call(extract_context, destination, offset, entity, dataset);
+
+            assert.isNonNegativeInteger(elements_from_entity, 'additions');
+
+            additions += elements_from_entity;
+        }
+
+        return additions;
+    }
+
+    return compute;
+
+}

package/src/engine/graphics/three/expand_aabb_by_transformed_three_object.js

@@ -1,8 +1,8 @@
-import { ensureGeometryBoundingBox } from "../util/ensureGeometryBoundingBox.js";
-import { aabb3_matrix4_project } from "../../../core/geom/3d/aabb/aabb3_matrix4_project.js";
 import { aabb3_array_combine } from "../../../core/geom/3d/aabb/aabb3_array_combine.js";
-import { m4_multiply } from "../../../core/geom/3d/matrix/m4_multiply.js";
 import { aabb3_from_threejs_geometry } from "../../../core/geom/3d/aabb/aabb3_from_threejs_geometry.js";
+import { aabb3_matrix4_project } from "../../../core/geom/3d/aabb/aabb3_matrix4_project.js";
+import { m4_multiply } from "../../../core/geom/3d/matrix/m4_multiply.js";
+import { ensureGeometryBoundingBox } from "../util/ensureGeometryBoundingBox.js";
 
 const scratch_aabb3_array_0 = new Float32Array(6);
 const scratch_aabb3_array_1 = new Float32Array(6);
@@ -27,7 +27,7 @@ export function expand_aabb_by_transformed_three_object(result, object, transfor
 
         aabb3_matrix4_project(scratch_aabb3_array_1, scratch_aabb3_array_0, transform);
 
-        aabb3_array_combine(result, result, scratch_aabb3_array_1);
+        aabb3_array_combine(result,0, result,0, scratch_aabb3_array_1,0);
     }
 
     const children = object.children;

package/src/engine/graphics/trail/x/RibbonX.js

@@ -5,7 +5,11 @@ import {
     InterleavedBuffer,
     InterleavedBufferAttribute
 } from "three";
+import { assert } from "../../../../core/assert.js";
 import { RowFirstTable } from "../../../../core/collection/table/RowFirstTable.js";
+import { aabb3_array_set } from "../../../../core/geom/3d/aabb/aabb3_array_set.js";
+import { max2 } from "../../../../core/math/max2.js";
+import { min2 } from "../../../../core/math/min2.js";
 import {
     RIBBON_ATTRIBUTE_ADDRESS_ALPHA,
     RIBBON_ATTRIBUTE_ADDRESS_COLOR,
@@ -16,7 +20,6 @@ import {
     RIBBON_ATTRIBUTE_ADDRESS_THICKNESS,
     ribbon_attributes_spec
 } from "./ribbon_attributes_spec.js";
-import { assert } from "../../../../core/assert.js";
 
 
 export class RibbonX {
@@ -438,16 +441,22 @@ export class RibbonX {
 
     /**
      * NOTE: takes trail thickness into account
-     * @param {AABB3} result
+     * @param {AABB3|ArrayLike<number>} result
      */
     computeBoundingBox(result) {
 
         const n = this.getCount() * 2;
 
-        result.setNegativelyInfiniteBounds();
-
         const data = this.__data;
 
+        let _x0 = Infinity;
+        let _y0 = Infinity;
+        let _z0 = Infinity;
+
+        let _x1 = -Infinity;
+        let _y1 = -Infinity;
+        let _z1 = -Infinity;
+
         for (let i = 0; i < n; i += 2) {
             const thickness = data.readCellValue(i, RIBBON_ATTRIBUTE_ADDRESS_THICKNESS);
             const half_thickness = thickness / 2;
@@ -456,9 +465,21 @@ export class RibbonX {
             const y = data.readCellValue(i, RIBBON_ATTRIBUTE_ADDRESS_POSITION + 1);
             const z = data.readCellValue(i, RIBBON_ATTRIBUTE_ADDRESS_POSITION + 2);
 
-            result._expandToFit(x - half_thickness, y - half_thickness, z - half_thickness, x + half_thickness, y + half_thickness, z + half_thickness);
+            _x0 = min2(_x0, x - half_thickness);
+            _y0 = min2(_y0, y - half_thickness);
+            _z0 = min2(_z0, z - half_thickness);
+            _x1 = max2(_x1, x + half_thickness);
+            _y1 = max2(_y1, y + half_thickness);
+            _z1 = max2(_z1, z + half_thickness);
+
         }
 
+        aabb3_array_set(
+            result, 0,
+            _x0, _y0, _z0,
+            _x1, _y1, _z1
+        );
+
     }
 
 

package/src/core/bvh2/binary/tiny/TinyBVH.js

@@ -1,221 +0,0 @@
-import { AABB3 } from "../../aabb3/AABB3.js";
-
-/**
- *
- * @param {AABB3} bounds
- * @param {number} type
- * @param {number} x0
- * @param {number} y0
- * @param {number} z0
- * @param {number} x1
- * @param {number} y1
- * @param {number} z1
- */
-function build_common_part(bounds, type, x0, y0, z0, x1, y1, z1) {
-    const bounds_x0 = bounds.x0;
-    const bounds_x1 = bounds.x1;
-
-    const bounds_y0 = bounds.y0;
-    const bounds_y1 = bounds.y1;
-
-    const bounds_z0 = bounds.z0;
-    const bounds_z1 = bounds.z1;
-
-    const range_x = bounds_x1 - bounds_x0;
-    const range_y = bounds_y1 - bounds_y0;
-    const range_z = bounds_z1 - bounds_z0;
-
-    const n_x0 = range_x * (x0 - bounds_x0);
-    const n_x1 = range_x * (x1 - bounds_x0);
-
-    const n_y0 = range_y * (y0 - bounds_y0);
-    const n_y1 = range_y * (y1 - bounds_y0);
-
-    const n_z0 = range_z * (z0 - bounds_z0);
-    const n_z1 = range_z * (z1 - bounds_z0);
-
-    const _x0 = n_x0 * 32;
-    const _x1 = Math.ceil(n_x1 * 32);
-
-    const _y0 = n_y0 * 32;
-    const _y1 = Math.ceil(n_y1 * 32);
-
-    const _z0 = n_z0 * 32;
-    const _z1 = Math.ceil(n_z1 * 32);
-
-    return (type << 30)
-        | ((_x0 << 25) & 0b00111110000000000000000000000000)
-        | ((_y0 << 20) & 0b00000001111100000000000000000000)
-        | ((_z0 << 15) & 0b00000000000011111000000000000000)
-        | ((_x1 << 10) & 0b00000000000000000111110000000000)
-        | ((_y1 << 5) & 0b00000000000000000000001111100000)
-        | ((_z1) & 0b00000000000000000000000000011111)
-        ;
-}
-
-const scratch_aabb3_0 = new AABB3(0, 0, 0, 0, 0, 0);
-
-/**
- * This is WiP
- * TODO implement
- * The idea is to have fixed precision of bounds at each level, so the deeper the hierarchy - the more precise the bounds, at the same time take up very little space
- * Binary layout:
- *      * common:  2[type],5[x0],5[y0],5[z0],5[x1],5[y1],5[z1]
- *      * leaf: common, 16[id]
- *      * intermediate: common
- */
-export class TinyBVH {
-    constructor() {
-        /**
-         *
-         * @type {DataView|null}
-         */
-        this.view = null;
-
-        this.leaf_count = 0;
-        this.leaf_nodes_offset = 0;
-
-        /**
-         *
-         * @type {AABB3}
-         */
-        this.bounds = new AABB3(0, 0, 0, 0, 0, 0);
-    }
-
-    initialize(length) {
-
-        this.leaf_count = length;
-
-        const two_log = Math.log2(length);
-
-        const two_leaf_limit = Math.pow(2, Math.ceil(two_log));
-
-        const binary_node_count = two_leaf_limit - 1;
-
-        this.leaf_nodes_offset = binary_node_count * 4;
-    }
-
-
-    /**
-     *
-     * @param {number} length
-     * @param {function} factory
-     */
-    initialize(length, factory) {
-        this.leaf_count = length;
-
-        const two_log = Math.log2(length);
-
-        const two_leaf_limit = Math.pow(2, Math.ceil(two_log));
-
-        const binary_node_count = two_leaf_limit - 1;
-
-        this.leaf_nodes_offset = binary_node_count * 4;
-
-        const view = this.view;
-
-        // initialize bounds
-        this.bounds.setNegativelyInfiniteBounds();
-
-        // actual full bounds of each node
-        const proper_leaf_bounds = new Float32Array((length + binary_node_count) * 6);
-
-        const morton_codes = new Uint32Array(length);
-
-        const leaf_index_mapping = new Uint32Array(length);
-
-        // collect leaf data
-        for (let i = 0; i < length; i++) {
-            const id = factory(i, scratch_aabb3_0);
-
-            const address = this.leaf_nodes_offset + i * 8;
-
-            // write leaf ID
-            view.setUint32(address + 4, id);
-
-            const bounds_address_offset = (binary_node_count + i) * 6;
-
-            proper_leaf_bounds[bounds_address_offset] = scratch_aabb3_0.x0;
-            proper_leaf_bounds[bounds_address_offset + 1] = scratch_aabb3_0.y0;
-            proper_leaf_bounds[bounds_address_offset + 2] = scratch_aabb3_0.z0;
-
-            proper_leaf_bounds[bounds_address_offset + 3] = scratch_aabb3_0.x1;
-            proper_leaf_bounds[bounds_address_offset + 4] = scratch_aabb3_0.y1;
-            proper_leaf_bounds[bounds_address_offset + 5] = scratch_aabb3_0.z1;
-
-            morton_codes[i] = scratch_aabb3_0.computeMortonCode();
-
-            leaf_index_mapping[i] = i;
-        }
-
-        leaf_index_mapping.sort((a, b) => {
-            return morton_codes[a] - morton_codes[b];
-        });
-
-
-        let level = Math.floor(Math.log2(binary_node_count));
-
-        let level_node_count = Math.pow(2, level);
-        let offset = (level_node_count - 1)
-
-        let i;
-        for (i = 0; i < level_node_count; i++) {
-            const child_offset = i * 2;
-
-            const child_index_0 = child_offset;
-            const child_index_1 = child_offset + 1;
-
-            if (child_index_0 < length) {
-                const leaf_index_0 = leaf_index_mapping[child_index_0];
-                const address_0 = leaf_index_0 * 8 + this.leaf_nodes_offset;
-
-                view.setUint16(address_0,)
-            }
-        }
-
-        for (; level >= 0; level--) {
-            level_node_count = Math.pow(2, level);
-            let parent_index = level_node_count - 1;
-
-            for (i = 0; i < level_node_count; i++) {
-                const child_index_0 = (parent_index << 1) + 1;
-                const child_index_1 = child_index_0 + 1;
-
-
-            }
-
-            parent_index++;
-        }
-
-    }
-
-    /**
-     *
-     * @param {number} index
-     * @param {number} id
-     * @param {number} x0
-     * @param {number} y0
-     * @param {number} z0
-     * @param {number} x1
-     * @param {number} y1
-     * @param {number} z1
-     */
-    setLeaf(index, id, x0, y0, z0, x1, y1, z1) {
-        const address = this.leaf_nodes_offset + index * 8;
-
-        const view = this.view;
-
-        const part_0 = build_common_part(this.bounds, 0, x0, y0, z0, x1, y1, z1);
-
-        view.setUint32(address, part_0);
-        view.setUint32(address + 4, id);
-    }
-
-    /**
-     *
-     * @param {DataView} view
-     */
-    attach(view) {
-        this.view = view;
-    }
-}