@woosh/meep-engine 2.33.23 → 2.33.27

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

@@ -0,0 +1,74 @@
+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 intersects the plane
+
+                outside_plane_count++;
+
+                const plane_bit_mask = 1 << j;
+
+                outside_plane_bitfield |= plane_bit_mask;
+            } else {
+                // sphere is entirely below the plane
+
+                // query_bvh_frustum_from_objects.rejection_sphere_count++;
+
+                return false;
+            }
+        }
+
+    }
+
+    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/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();
 

package/engine/graphics/shaders/TerrainShader.js

@@ -121,7 +121,6 @@ function fragment() {
     uniform float opacity;
     
     varying vec3 vViewPosition;
-
    
 
     #include <common>
@@ -364,10 +363,10 @@ function fragment() {
         
         vec3 outgoingLight = totalDiffuse + totalSpecular + totalEmissiveRadiance;
                     
-        pc_fragColor  = vec4( outgoingLight, diffuseColor.a );
+        gl_FragColor  = vec4( outgoingLight, diffuseColor.a );
       
         #if defined( TONE_MAPPING )
-            pc_fragColor.rgb = toneMapping( pc_fragColor.rgb );
+            gl_FragColor.rgb = toneMapping( pc_fragColor.rgb );
         #endif
         
         //encode fragment
@@ -378,12 +377,12 @@ function fragment() {
             #else
                 float fogFactor = smoothstep( fogNear, fogFar, fogDepth );
             #endif
-            pc_fragColor.rgb = mix( pc_fragColor.rgb, fogColor, fogFactor );
+            gl_FragColor.rgb = mix( pc_fragColor.rgb, fogColor, fogFactor );
         #endif
         
         #ifdef PREMULTIPLIED_ALPHA
             // Get get normal blending with premultipled, use with CustomBlending, OneFactor, OneMinusSrcAlphaFactor, AddEquation.
-            pc_fragColor.rgb *= pc_fragColor.a;
+            gl_FragColor.rgb *= pc_fragColor.a;
         #endif
         
         #ifdef DITHERING

package/engine/graphics/shadows/ShadowMapRenderer.js

@@ -173,13 +173,19 @@ export class ShadowMapRenderer {
 
         if (shadow.map === null) {
 
-            const pars = { format: RGBAFormat };
+            const pars = {
+                format: RGBAFormat,
+                scissorTest: false,
+                stencilBuffer: false
+            };
 
             if (!shadow.isPointLightShadow && renderer.shadowMap.type === VSMShadowMap) {
                 pars.minFilter = LinearFilter;
                 pars.magFilter = LinearFilter;
 
-                shadow.mapPass = new WebGLRenderTarget(_shadowMapSize.x, _shadowMapSize.y, pars);
+                shadow.mapPass = new WebGLRenderTarget(_shadowMapSize.x, _shadowMapSize.y, Object.assign({
+                    depthBuffer: false
+                }, pars));
 
             } else {
                 pars.minFilter = NearestFilter;

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

@@ -6,6 +6,7 @@ import { GameAssetType } from "../../../asset/GameAssetType.js";
 import { HashMap } from "../../../../core/collection/HashMap.js";
 import { strictEquals } from "../../../../core/function/Functions.js";
 import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.js";
+import { copy_Sampler2D_channel_data } from "../sampler/copy_Sampler2D_channel_data.js";
 
 const CACHE_SIZE = 4194304;
 
@@ -139,10 +140,20 @@ export class ManagedAtlas {
 
                     const image = asset.create();
 
+                    const source = new Sampler2D(image.data, image.itemSize, image.width, image.height);
                     //assert.equal(atlas.patches.filter(p => p.sampler.data === image.data).length, 0, "Atlas already contains this asset data");
 
                     //build sampler
-                    const sampler = new Sampler2D(image.data, 4, image.width, image.height);
+                    let sampler;
+
+                    if (source.itemSize !== 4) {
+                        // source image is not in RGBA layout, resample
+                        sampler = Sampler2D.uint8(4, image.width, image.height);
+                        copy_Sampler2D_channel_data(source, sampler)
+                    } else {
+                        sampler = source;
+                    }
+
                     const patch = atlas.add(sampler);
 
                     //record active patch

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

package/engine/graphics/texture/sampler/SampleTraverser.js

@@ -3,8 +3,8 @@
  */
 import QuadTree from '../../../../core/geom/2d/quad-tree/PointQuadTree.js';
 import AABB2 from '../../../../core/geom/AABB2.js';
-import { makeRangedRandom} from '../../../../core/math/MathUtils.js';
 import { seededRandom } from "../../../../core/math/random/seededRandom.js";
+import { makeRangedRandom } from "../../../../core/math/random/makeRangedRandom.js";
 
 
 const Point2 = function (x, y) {

package/engine/graphics/texture/sampler/Sampler2D.js

@@ -164,11 +164,13 @@ export function Sampler2D(data = [], itemSize = 1, width = 0, height = 0) {
      * @type {Number}
      */
     this.height = height;
+
     /**
-     *
+     * Number of channels
      * @type {Number}
      */
     this.itemSize = itemSize;
+
     /**
      *
      * @type {Array<number>|Uint8Array|Uint16Array|Int8Array|Float32Array|Float64Array}

package/engine/graphics/texture/sampler/convertTexture2Sampler2D.js

@@ -17,7 +17,7 @@ const DEFAULT_TEXTURE_HEIGHT = 512;
  * @return {Sampler2D}
  */
 export function convertTexture2Sampler2D(texture, width, height, flipY = true) {
-
+    // TODO take channel count into account
 
     if (width === undefined || height === undefined) {
 

package/engine/graphics/texture/sampler/copy_Sampler2D_channel_data.js

@@ -0,0 +1,66 @@
+/**
+ * Allows copying data from one sampler to another with unequal number of channels (a.itemSize !== b.itemSize)
+ * @example convert RGBA to RGB or R to RGB
+ * @param {Sampler2D} source
+ * @param {Sampler2D} destination
+ */
+export function copy_Sampler2D_channel_data(source, destination) {
+    if (source.width !== destination.width || source.height !== destination.height) {
+        throw new Error('Source and destination dimensions do not match');
+    }
+
+    const source_item_size = source.itemSize;
+    const destination_item_size = destination.itemSize;
+
+    const pixel_count = source.width * source.height;
+
+    const destination_data = destination.data;
+    const source_data = source.data;
+
+    let i, j;
+
+    if (source_item_size === destination_item_size) {
+        // just copy data chunk
+        destination_data.set(source_data);
+
+    } else if (source_item_size > destination_item_size) {
+
+        for (i = 0; i < pixel_count; i++) {
+            const source_sample_offset = i * source_item_size;
+            const destination_sample_offset = i * destination_item_size;
+
+            for (j = 0; j < destination_item_size; j++) {
+                destination_data[destination_sample_offset + j] = source_data[source_sample_offset + j];
+            }
+        }
+
+    } else if (source_item_size === 3 && destination_item_size === 4) {
+        // RGB -> RGBA
+        for (i = 0; i < pixel_count; i++) {
+            const i3 = i * 3;
+            const i4 = i * 4;
+
+            destination_data[i4] = source_data[i3];
+            destination_data[i4 + 1] = source_data[i3 + 1];
+            destination_data[i4 + 2] = source_data[i3 + 2];
+
+            destination_data[i4] = 255; // fill alpha
+        }
+    } else if (source_item_size === 2 && destination_item_size === 4) {
+        //RA -> RGBA
+        for (i = 0; i < pixel_count; i++) {
+            const i2 = i * 2;
+            const i4 = i * 4;
+
+            const r = source_data[i2];
+
+            destination_data[i4] = r;
+            destination_data[i4 + 1] = r;
+            destination_data[i4 + 2] = r;
+
+            destination_data[i4 + 3] = source_data[i2 + 1]; // fill alpha
+        }
+    } else {
+        throw new Error('Unsupported channel layout combination');
+    }
+}

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

@@ -1,7 +1,7 @@
 import { seededRandom } from "../../../../core/math/random/seededRandom.js";
 import { Sampler2D } from "./Sampler2D.js";
 import { computeUnsignedDistanceField } from "./distanceField.js";
-import { randomIntegerBetween} from "../../../../core/math/MathUtils.js";
+import { randomIntegerBetween } from "../../../../core/math/random/randomIntegerBetween.js";
 
 describe('computeUnsignedDistanceField', () => {
     test('empty', () => {