@woosh/meep-engine 2.64.0 → 2.66.0

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;
-        }
-
-    }
-}