@woosh/meep-engine 2.33.23 → 2.33.27

package/view/minimap/gl/buildMaterial.js

@@ -0,0 +1,94 @@
+import {
+    DataTexture,
+    LinearMipMapLinearFilter,
+    NearestFilter,
+    NormalBlending,
+    RGBAFormat,
+    ShaderMaterial,
+    Vector2 as ThreeVector2
+} from "three";
+
+/**
+ *
+ * @return {ShaderMaterial}
+ */
+export function buildMaterial() {
+    function vertexShader() {
+        return `
+            attribute float size;
+            attribute vec4 aPatch;
+            
+			varying vec4 vPatch;
+			
+			uniform vec2 resolution;
+			
+			vec2 extractScale2D(mat4 matrix){
+			    float sx = length(matrix[0].xy);
+			    float sz = length(matrix[2].xy);
+			
+			    return vec2(sx, sz);
+			}
+			
+			void main() {
+			    vPatch = aPatch;
+				vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );
+				
+				//extract scale
+				vec2 scale =  extractScale2D(projectionMatrix);
+
+                float radius = size / 2.0;
+							
+				gl_Position = projectionMatrix * mvPosition;
+				gl_PointSize = resolution.y * radius * max(scale.x, scale.y);
+			}`;
+    }
+
+    function fragmentShader() {
+        return `
+            uniform sampler2D atlas;
+            
+			varying vec4 vPatch;
+			void main() {
+			    vec2 uv = gl_PointCoord*vPatch.zw + vPatch.xy;
+			    vec4 texel = texture2D( atlas, uv );
+			    
+			    if(texel.a == 0.0){
+			        discard;
+			    }
+			    
+				gl_FragColor = texel;
+			}`;
+    }
+
+
+    const dataTexture = new DataTexture(new Uint8Array(4), 1, 1, RGBAFormat);
+    dataTexture.flipY = false;
+    dataTexture.generateMipmaps = true;
+    dataTexture.minFilter = LinearMipMapLinearFilter;
+    dataTexture.magFilter = NearestFilter;
+
+    const uniforms = {
+        atlas: {
+            type: 't',
+            value: dataTexture
+        },
+        resolution: {
+            type: 'v2',
+            value: new ThreeVector2()
+        }
+    };
+
+    const material = new ShaderMaterial({
+        uniforms,
+        vertexShader: vertexShader(),
+        fragmentShader: fragmentShader(),
+        blending: NormalBlending,
+        lights: false,
+        fog: false,
+        depthTest: false,
+        transparent: true,
+        vertexColors: false
+    });
+
+    return material;
+}

package/engine/graphics/micron/format/MicronGeometryBufferAttributeSpec.js

@@ -1,71 +0,0 @@
-import { DataType } from "../../../../core/collection/table/DataType.js";
-import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.js";
-import { DataTypeByteSizes } from "../../../../core/collection/table/DataTypeByteSizes.js";
-
-export class MicronGeometryBufferAttributeSpec {
-    constructor() {
-        /**
-         *
-         * @type {string}
-         */
-        this.name = "";
-        /**
-         *
-         * @type {DataType}
-         */
-        this.type = DataType.Float32;
-        /**
-         *
-         * @type {number}
-         */
-        this.itemSize = 1;
-
-        /**
-         * Normalized values will be automatically converted to float32 in the shader
-         * This gives good optimization opportunities for things like normal vectors
-         * @type {boolean}
-         */
-        this.normalized = false;
-    }
-
-    hash() {
-        return computeStringHash(this.name);
-    }
-
-    /**
-     *
-     * @param {MicronGeometryBufferAttributeSpec} other
-     * @returns {boolean}
-     */
-    equals(other) {
-        return this.type === other.type
-            && this.itemSize === other.itemSize
-            && this.normalized === other.normalized
-            && this.name === other.name
-            ;
-    }
-
-    /**
-     *
-     * @returns {number}
-     */
-    getByteSize() {
-        return this.itemSize * DataTypeByteSizes[this.type];
-    }
-
-    /**
-     *
-     * @param {MicronGeometryBufferAttributeSpec} a
-     * @param {MicronGeometryBufferAttributeSpec} b
-     * @return {number}
-     */
-    static byName(a, b) {
-        return a.name.localeCompare(b.name);
-    }
-}
-
-/**
- * @readonly
- * @type {boolean}
- */
-MicronGeometryBufferAttributeSpec.prototype.isMicronGeometryBufferAttributeSpec = true;

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

@@ -1,357 +0,0 @@
-import { line3_computeSegmentPointDistance_sqr } from "../../../../core/geom/LineSegment.js";
-import { computeConePlaneSide } from "../../../../core/geom/3d/cone/computeConePlaneSide.js";
-import { aabb3_computeDistanceAbovePlane } from "../../../../core/geom/3d/aabb/aabb3_computeDistanceAbovePlane.js";
-import { v3_distance_sqr } from "../../../../core/geom/v3_distance_sqr.js";
-
-/**
- *
- * @type {(BinaryNode|LeafNode)[]}
- */
-const stack = [];
-
-let stackPointer = 0;
-
-const _lut_array_buffer = new ArrayBuffer(84);
-
-/**
- * Mapping from 3 plane bitfield, corresponding to intersection point of the planes
- * @type {number[]}
- */
-const triplanar_corner_mapping = new Uint8Array(_lut_array_buffer, 0, 43);
-
-triplanar_corner_mapping[0b010101] = 0;
-triplanar_corner_mapping[0b100101] = 1;
-triplanar_corner_mapping[0b011001] = 2;
-triplanar_corner_mapping[0b101001] = 3;
-triplanar_corner_mapping[0b010110] = 4;
-triplanar_corner_mapping[0b100110] = 5;
-triplanar_corner_mapping[0b011010] = 6;
-triplanar_corner_mapping[0b101010] = 7;
-
-function analytical_triplanar_corner_mapping(field) {
-    return ((field << 1) & 0b100) | ((field >> 2) & 0b10) | ((field >> 5) & 0b1);
-}
-
-/**
- * Mapping from 2 plane bitfield to 2 corner bitfield, corresponding to corner indices of intersecting planes
- * @type {number[]}
- */
-const biplanar_edge_mapping = new Uint8Array(_lut_array_buffer, 43, 41);
-
-biplanar_edge_mapping[0b000101] = 0 | (1 << 3);
-biplanar_edge_mapping[0b000110] = 4 | (5 << 3);
-
-biplanar_edge_mapping[0b001001] = 2 | (3 << 3);
-biplanar_edge_mapping[0b001010] = 6 | (7 << 3);
-
-biplanar_edge_mapping[0b010100] = 0 | (4 << 3);
-biplanar_edge_mapping[0b011000] = 2 | (6 << 3);
-
-biplanar_edge_mapping[0b100100] = 1 | (5 << 3);
-biplanar_edge_mapping[0b101000] = 3 | (7 << 3);
-
-biplanar_edge_mapping[0b010001] = 0 | (2 << 3);
-biplanar_edge_mapping[0b010010] = 4 | (6 << 3);
-
-biplanar_edge_mapping[0b100001] = 1 | (3 << 3);
-biplanar_edge_mapping[0b100010] = 5 | (7 << 3);
-
-/**
- *
- * @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}
- */
-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 = analytical_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
-        );
-
-        // queryBVH_Frustum.checks_sphere_frustum_corner++;
-
-        // return distance_to_light_sqr <= radius_sqr;
-
-        if (distance_to_light_sqr > radius_sqr) {
-
-            // queryBVH_Frustum.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
-        );
-
-        // queryBVH_Frustum.checks_sphere_frustum_edge++;
-
-        // return distance_to_frustum_sqr <= radius_sqr;
-
-        if (distance_to_frustum_sqr > radius_sqr) {
-
-            // queryBVH_Frustum.rejection_sphere_count++;
-            return false;
-        }
-    }
-
-    return true;
-}
-
-/**
- *
- * @param {PointLight} light
- * @param {number[]} points
- * @param {number[]|Float32Array|Float64Array} planes
- * @returns {boolean}
- */
-function point_light_inside_volume(light, points, planes) {
-    let j = 0;
-    let outside_plane_count = 0;
-    let outside_plane_bitfield = 0;
-
-    // validate if the sphere intersects the plane-bound space
-
-    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();
-
-    // queryBVH_Frustum.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;
-
-        // queryBVH_Frustum.checks_sphere_plane++;
-
-        if (distance < 0) {
-            // center of the sphere is below the plane
-
-            if (distance < -radius) {
-                // sphere is entirely below the plane
-
-                // queryBVH_Frustum.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
-        );
-    }
-}
-
-/**
- *
- * @param {SpotLight} light
- * @param {number[]} points
- * @param {number[]|Float32Array|Float64Array} planes
- * @returns {boolean}
- */
-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;
-}
-
-/**
- * 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 queryBVH_Frustum(
-    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) {
-
-        // queryBVH_Frustum.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
-
-                    // queryBVH_Frustum.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) {
-                if (!point_light_inside_volume(light, 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;
-}
-
-queryBVH_Frustum.iteration_count = 0;
-queryBVH_Frustum.rejection_count = 0;
-queryBVH_Frustum.rejection_sphere_count = 0;
-queryBVH_Frustum.plane_tests = 0;
-queryBVH_Frustum.plane_tests_early_exits = 0;
-queryBVH_Frustum.checks_sphere = 0;
-queryBVH_Frustum.checks_sphere_plane = 0;
-queryBVH_Frustum.checks_sphere_frustum_corner = 0;
-queryBVH_Frustum.checks_sphere_frustum_edge = 0;