@woosh/meep-engine 2.65.0 → 2.67.0

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

@@ -3,75 +3,45 @@
  */
 
 
-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";
-
-
-/**
- *
- * @type {*[]}
- */
-const scratch_array = [];
+import { IncrementalDeltaSet } from "../visibility/IncrementalDeltaSet.js";
+import { RenderLayerState } from "./RenderLayerState.js";
 
 export class RenderLayer {
-    constructor() {
-        /**
-         *
-         * @type {BinaryNode}
-         */
-        this.bvh = new BinaryNode();
-        this.bvh.setNegativelyInfiniteBounds();
-
-        /**
-         *
-         * @type {RenderLayerState}
-         */
-        this.state = new RenderLayerState();
 
-        /**
-         *
-         * @type {String|null}
-         */
-        this.name = null;
+    /**
+     *
+     * @type {RenderLayerState}
+     */
+    state = new RenderLayerState();
 
-        /**
-         * Layer is managed externally, visibility will not be updated in the rendering engine
-         * @deprecated
-         * @type {boolean}
-         */
-        this.managed = false;
+    /**
+     *
+     * @type {String|null}
+     */
+    name = null;
 
-        /**
-         *
-         * @type {function(*): Object3D}
-         */
-        this.extractRenderable = passThrough;
+    /**
+     * Layer is managed externally, visibility will not be updated in the rendering engine
+     * @deprecated
+     * @type {boolean}
+     */
+    managed = false;
 
-        /**
-         * @deprecated use CameraView's visible set instead
-         * Contains visible elements across all views, if element is in at least one view - it will be here
-         * @deprecated
-         * @type {IncrementalDeltaSet<THREE.Object3D>}
-         */
-        this.visibleSet = new IncrementalDeltaSet(compare_three_objects);
+    /**
+     *
+     * @type {function(*): Object3D}
+     */
+    extractRenderable = passThrough;
 
-        /**
-         *
-         * @type {RenderPassType|number}
-         */
-        this.renderPass = RenderPassType.Opaque;
-    }
+    /**
+     * @deprecated use CameraView's visible set instead
+     * Contains visible elements across all views, if element is in at least one view - it will be here
+     * @deprecated
+     * @type {IncrementalDeltaSet<THREE.Object3D>}
+     */
+    visibleSet = new IncrementalDeltaSet(compare_three_objects);
 
     /**
      * @deprecated
@@ -92,6 +62,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 +70,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;
-    }
-}

package/src/engine/graphics/ecs/camera/CameraClippingPlaneComputer.js

@@ -1,138 +0,0 @@
-import { Frustum as ThreeFrustum } from "three";
-import { v3_dot } from "../../../../core/geom/vec3/v3_dot.js";
-import { isValueBetweenInclusive } from "../../../../core/math/interval/isValueBetweenInclusive.js";
-import { frustum_from_camera } from "./frustum_from_camera.js";
-import { is_valid_distance_value } from "./is_valid_distance_value.js";
-
-const CLIPPING_EPSILON = 0.001;
-
-const CLIPPING_NEAR_MIN = 0.5;
-
-const CLIPPING_FAR_DEFAULT = 100;
-
-export class CameraClippingPlaneComputer {
-    constructor() {
-        /**
-         *
-         * @type {Camera}
-         */
-        this.camera = null;
-
-        /**
-         *
-         * @type {RenderLayerManager}
-         */
-        this.layers = null;
-
-        /**
-         * Prevents minor shrinkage of the frustum. This variable controls the threshold at which the shrinkage should occur.
-         * @example value 0 would result is unconditional shrinkage
-         * @example value 1 would result in shrinkage occurring never
-         * @type {number}
-         */
-        this.hysteresis = 0.5;
-
-        /**
-         *
-         * @type {Frustum}
-         * @private
-         */
-        this.__frustum = new ThreeFrustum();
-
-
-        this.near = 0;
-        this.far = 0;
-    }
-
-    /**
-     *
-     * @param {RenderLayer} layer
-     * @private
-     */
-    __processLayer(layer) {
-        if (!layer.state.visible) {
-            return;
-        }
-
-        layer.computeNearFarClippingPlanes(this.__frustum, this.near, this.far, this.__updateClippingPlanes, this);
-    }
-
-    /**
-     *
-     * @param {number} z0
-     * @param {number} z1
-     * @private
-     */
-    __updateClippingPlanes(z0, z1) {
-        if (z0 < this.near && z0 !== Number.NEGATIVE_INFINITY) {
-            this.near = z0;
-        }
-        if (z1 > this.far && z1 !== Number.POSITIVE_INFINITY) {
-            this.far = z1;
-        }
-    }
-
-    compute() {
-        const camera = this.camera;
-
-        /**
-         *
-         * @type {number}
-         */
-        const hysteresis = this.hysteresis;
-
-        //quantify hysteresis
-        const oldNear = camera.near;
-        const oldFar = camera.far;
-        const oldClippingPlaneDistance = Math.abs(oldFar - oldNear);
-
-        const shrinkThreshold = hysteresis * oldClippingPlaneDistance;
-
-        frustum_from_camera(camera, this.__frustum);
-
-        // compute plane constant (D) to move "near" plane to intersect camera position
-        const nearPlane = this.__frustum.planes[5];
-        const near_plane_normal = nearPlane.normal;
-        const camera_position = camera.position;
-
-        nearPlane.constant = -v3_dot(
-            camera_position.x,
-            camera_position.y,
-            camera_position.z,
-            near_plane_normal.x,
-            near_plane_normal.y,
-            near_plane_normal.z
-        );
-
-        this.far = Number.NEGATIVE_INFINITY;
-        this.near = Number.POSITIVE_INFINITY;
-
-        this.layers.traverse(this.__processLayer, this);
-
-        //offset clipping planes by a small margin to prevent clipping of parallel planar surfaces
-        this.near -= CLIPPING_EPSILON;
-        this.far += CLIPPING_EPSILON;
-
-        //clip near
-        if (!is_valid_distance_value(this.near) || this.near < CLIPPING_NEAR_MIN) {
-            //use a default
-            //NOTE: values smaller than 0.001 seem to lead to glitchy rendering where polygons clip through one another
-            this.near = CLIPPING_NEAR_MIN;
-        }
-
-        if (!is_valid_distance_value(this.far) || this.far < 0) {
-            //use a default
-            this.far = CLIPPING_FAR_DEFAULT;
-        }
-
-        //hysteresis check
-        if (isValueBetweenInclusive(this.near - oldNear, 0, shrinkThreshold)) {
-            this.near = oldNear;
-        }
-
-        if (isValueBetweenInclusive(oldFar - this.far, 0, shrinkThreshold)) {
-            this.far = oldFar;
-        }
-
-    }
-}