@woosh/meep-engine 2.33.4 → 2.33.5

package/core/bvh2/aabb3/AABB3.js

@@ -8,6 +8,7 @@ import { computeAABB3PlaneSide } from "../../geom/3d/aabb/computeAABB3PlaneSide.
 import computeMortonCode from "../../geom/3d/morton/Morton.js";
 import { _boxSurfaceArea2, intersectRay, intersectSegment } from "./AABB3Math.js";
 import { aabb3_build_corners } from "../../geom/3d/aabb/aabb3_build_corners.js";
+import { assert } from "../../assert.js";
 
 
 /**
@@ -724,7 +725,9 @@ AABB3.prototype.getCorners = function (result) {
  * @param {number} offset
  */
 AABB3.prototype.writeToArray = function (result, offset) {
-    result[offset + 0] = this.x0;
+    assert.isNonNegativeInteger(offset, 'offset');
+
+    result[offset] = this.x0;
     result[offset + 1] = this.y0;
     result[offset + 2] = this.z0;
 

package/core/collection/array/copyArray.js

@@ -25,9 +25,9 @@ export function copyArray(source, target) {
  * Follows Java System.arraycopy interface
  * Copy data from one array to another
  * @template T
- * @param {T[]|ArrayLike<T>|TypedArray} source The source array
+ * @param {T[]|ArrayLike<T>|TypedArray|Uint8ClampedArray|Uint8Array} source The source array
  * @param {number} source_position Starting position where to copy from inside the source array
- * @param {T[]|ArrayLike<T>|TypedArray} destination The destination array
+ * @param {T[]|ArrayLike<T>|TypedArray|Uint8ClampedArray|Uint8Array} destination The destination array
  * @param {number} destination_position Starting position where to copy to inside the destination array
  * @param {number} length How many elements should be copied
  */

package/core/collection/table/RowFirstTableSpec.js

@@ -234,6 +234,14 @@ export function RowFirstTableSpec(types, endianType = EndianType.BigEndian) {
     }
 }
 
+/**
+ *
+ * @return {number}
+ */
+RowFirstTableSpec.prototype.getColumnCount = function () {
+    return this.types.length;
+}
+
 /**
  *
  * @param {RowFirstTableSpec} other

package/core/geom/3d/aabb/aabb3_compute_projected_area.js

@@ -10,6 +10,7 @@
 
 
 /**
+ * NOTE: Consider using an optimized aabb projection method based on Jim Arvo's Graphics Gems algorithm: https://stackoverflow.com/a/58630206/3973586
  * Almost everything is inlined for speed
  * @param {number[]} aabb_corners
  * @param {number[]|mat4|Float32Array} projection_matrix

package/core/geom/3d/aabb/aabb3_estimate_projected_area2.js

@@ -0,0 +1,59 @@
+const scratch_aabb = new Float32Array(4);
+
+
+/**
+ * NOTE: tends to overestimate the area
+ * @param {number[]} aabb
+ * @param {number[]} matrix
+ * @return {number}
+ */
+export function aabb3_estimate_projected_area2(aabb, matrix) {
+    // extract translation from matrix
+    scratch_aabb[0] = scratch_aabb[2] = matrix[12];
+    scratch_aabb[1] = scratch_aabb[3] = matrix[13];
+
+    // apply 3x3 matrix transform
+    for (let i = 0; i < 2; i++) {
+        for (let j = 0; j < 3; j++) {
+
+            const m_a = i * 4 + j;
+            const m_v = matrix[m_a];
+
+            const a = m_v * aabb[j];
+            const b = m_v * aabb[j + 3];
+
+            if (a < b) {
+                scratch_aabb[i] += a;
+                scratch_aabb[i + 2] += b;
+            } else {
+                scratch_aabb[i] += b;
+                scratch_aabb[i + 2] += a;
+            }
+        }
+    }
+
+
+    const x1 = scratch_aabb[2];
+    const x0 = scratch_aabb[0];
+
+    const dx = x1 - x0;
+
+    const y1 = scratch_aabb[3];
+    const y0 = scratch_aabb[1];
+
+    const dy = y1 - y0;
+    const a = dx * dy;
+
+    const cx = (aabb[0] + aabb[3]) * 0.5;
+    const cy = (aabb[1] + aabb[4]) * 0.5;
+    const cz = (aabb[2] + aabb[5]) * 0.5;
+
+    /* compute W projection value, using conservative estimate
+       @see https://twitter.com/SebAaltonen/status/1332332808979832832
+       @see https://gist.github.com/slembcke/b2b2af4dede1d5702a635dc2d0e45d54
+    */
+    const w = matrix[3] * cx + matrix[7] * cy + matrix[11] * cz + matrix[15];
+    const d = 0.5 / Math.abs(w);
+
+    return a * d * d;
+}

package/core/geom/3d/aabb/aabb3_matrix4_project.js

@@ -0,0 +1,33 @@
+
+/**
+ * NOTE: Based on Transforming Axis-Aligned Bounding Boxes by Jim Arvo from "Graphics Gems", Academic Press, 1990
+ * @param {number[]} result
+ * @param {number[]} aabb
+ * @param {number[]} matrix 4x4 matrix
+ */
+export function aabb3_matrix4_project(result, aabb, matrix) {
+    // extract translation from matrix
+    result[0] = result[3] = matrix[12];
+    result[1] = result[4] = matrix[13];
+    result[2] = result[5] = matrix[14];
+
+    // apply 3x3 matrix transform
+    for (let i = 0; i < 3; i++) {
+        for (let j = 0; j < 3; j++) {
+
+            const m_a = i * 4 + j;
+            const m_v = matrix[m_a];
+
+            const a = m_v * aabb[j];
+            const b = m_v * aabb[j + 3];
+
+            if (a < b) {
+                result[i] += a;
+                result[i + 3] += b;
+            } else {
+                result[i] += b;
+                result[i + 3] += a;
+            }
+        }
+    }
+}

package/core/geom/3d/aabb/aabb3_matrix4_project.spec.js

@@ -0,0 +1,41 @@
+import { aabb3_matrix4_project } from "./aabb3_matrix4_project.js";
+
+test('identity', () => {
+    const r = [];
+
+    aabb3_matrix4_project(r, [1, 2, 3, 5, 7, 9], [
+        1, 0, 0, 0,
+        0, 1, 0, 0,
+        0, 0, 1, 0,
+        0, 0, 0, 1
+    ]);
+
+    expect(r).toEqual([1, 2, 3, 5, 7, 9]);
+});
+
+test('translation case', () => {
+    const r = [];
+
+    aabb3_matrix4_project(r, [1, 2, 3, 5, 7, 9], [
+        1, 0, 0, 0,
+        0, 1, 0, 0,
+        0, 0, 1, 0,
+        13, -17, 23, 1
+    ]);
+
+    expect(r).toEqual([14, -15, 26, 18, -10, 32]);
+});
+
+
+test('scale case', () => {
+    const r = [];
+
+    aabb3_matrix4_project(r, [1, 2, 3, 5, 7, 9], [
+        -1, 0, 0, 0,
+        0, 2, 0, 0,
+        0, 0, -3, 0,
+        0, 0, 0, 1
+    ]);
+
+    expect(r).toEqual([-5, 4, -27, -1, 14, -9]);
+});

package/engine/graphics/GraphicsEngine.js

@@ -4,16 +4,11 @@
 
 
 import {
-    CubeTextureLoader,
     Group,
     LinearEncoding,
     NoToneMapping,
-    PMREMGenerator,
     Raycaster as ThreeRaycaster,
     Scene as ThreeScene,
-    sRGBEncoding,
-    TextureLoader,
-    UnsignedByteType,
     Vector3 as ThreeVector3,
     VSMShadowMap,
     WebGLRenderer,
@@ -38,29 +33,13 @@ import { renderTextureToScreenQuad } from "./render/utils/renderTextureToScreenQ
 import { globalMetrics } from "../metrics/GlobalMetrics.js";
 import { MetricsCategory } from "../metrics/MetricsCategory.js";
 import Vector1 from "../../core/geom/Vector1.js";
-import { noop } from "../../core/function/Functions.js";
 import { NormalFrameBuffer } from "./render/buffer/buffers/NormalFrameBuffer.js";
 import { MaterialManager } from "./material/manager/MaterialManager.js";
 import { CoalesceTextures } from "./material/manager/compilers/CoalesceTextures.js";
 import { ShadowMapRenderer } from "./shadows/ShadowMapRenderer.js";
 import { CameraViewManager } from "./render/view/CameraViewManager.js";
 import { StandardFrameBuffers } from "./StandardFrameBuffers.js";
-import { computeFileExtension } from "../../core/FilePath.js";
-import { EXRLoader } from "three/examples/jsm/loaders/EXRLoader.js";
-
-/**
- *
- * @param {String} path
- * @param {String} format
- * @returns {String[]}
- */
-export function buildCubeURLs(path, format) {
-    return [
-        path + "posx" + format, path + "negx" + format,
-        path + "posy" + format, path + "negy" + format,
-        path + "posz" + format, path + "negz" + format
-    ];
-}
+import { load_environment_map } from "./texture/cubemap/load_environment_map.js";
 
 /**
  *
@@ -261,56 +240,6 @@ GraphicsEngine.prototype.getRenderer = function () {
     return this.renderer;
 };
 
-/**
- *
- * @param {string[]|string} paths
- * @return {Promise<THREE.CubeTexture>}
- */
-function load_cube_texture(paths) {
-    // piece-wise cubemap, a collection of images for each face
-    const cubeTextureLoader = new CubeTextureLoader();
-    return new Promise((resolve, reject) => {
-        cubeTextureLoader.load(
-            paths,
-            texture => {
-                resolve(texture);
-            },
-            noop,
-            reject
-        );
-    });
-}
-
-/**
- *
- * @param {string} path
- * @return {Promise<THREE.Texture>}
- */
-function load_exr_texture(path) {
-    return new Promise((resolve, reject) => {
-        new EXRLoader()
-            .setDataType(UnsignedByteType)
-            .load(path, texture => {
-                resolve(texture);
-            }, noop, reject);
-    })
-}
-
-/**
- *
- * @param {string} path
- * @return {Promise<THREE.Texture>}
- */
-function load_standard_texture(path) {
-    return new Promise((resolve, reject) => {
-        new TextureLoader()
-            .load(path, texture => {
-                texture.encoding = sRGBEncoding;
-                resolve(texture);
-            }, noop, reject);
-    })
-}
-
 /**
  *
  * @param {string[]|string} paths URLs to faces of the cubemap
@@ -318,52 +247,16 @@ function load_standard_texture(path) {
  */
 GraphicsEngine.prototype.loadEnvironmentMap = async function (paths) {
 
-    const pmremGenerator = new PMREMGenerator(this.renderer);
-    let cube_rt;
-
-    if (Array.isArray(paths)) {
-        /**
-         *
-         * @type {THREE.CubeTexture}
-         */
-        const cube_texture = await load_cube_texture(paths);
-
-        cube_texture.encoding = sRGBEncoding;
-
-        // generate pre-filtered cubemap
-        pmremGenerator.compileCubemapShader();
-
-        cube_rt = pmremGenerator.fromCubemap(cube_texture);
-
-        // cleanup
-        cube_texture.dispose();
-    } else if (typeof paths === 'string') {
-        // single cubemap
-        const extension = computeFileExtension(paths).toLowerCase();
-        let texture;
-        if (extension === 'exr') {
-            texture = await load_exr_texture(paths);
-        } else if (extension === 'jpg') {
-            texture = await load_standard_texture(paths);
-        } else {
-            // unsupported extension
-            throw new Error(`Unsupported cube map texture extension '${extension}'`);
-        }
-        cube_rt = pmremGenerator.fromEquirectangular(texture);
-
-        texture.dispose();
-    } else {
-        throw new Error(`Unsupported parameter format: '${paths}'`);
-    }
-
-    pmremGenerator.dispose();
-
-    // assign environment
-    const t = cube_rt.texture;
-    this.scene.environment = t;
+    const { filtered } = await load_environment_map({
+        path: paths,
+        renderer: this.renderer,
+        original: false,
+        filtered: true
+    });
 
+    this.scene.environment = filtered;
 
-    return t;
+    return filtered;
 }
 
 GraphicsEngine.prototype.updateSize = function () {

package/engine/graphics/filter/FlipArrayInPlace.js

@@ -0,0 +1,25 @@
+/**
+ * @param {Uint8Array} input
+ * @param {number} width
+ * @param {number} height
+ * @param {number} channel_count
+ */
+export function flipArrayInPlace(input, width, height, channel_count = 4) {
+    const rowLength = width * channel_count;
+    let t, x0, x1;
+    let i = 0;
+    const l = height >> 1;
+
+    for (; i < l; i++) {
+        //swap lines
+        const k = (height - i - 1) * rowLength;
+        const m = i * rowLength;
+        for (let j = 0; j < rowLength; j++) {
+            x0 = m + j;
+            x1 = k + j;
+            t = input[x0];
+            input[x0] = input[x1];
+            input[x1] = t;
+        }
+    }
+}

package/engine/graphics/filter/FlipArrayViaCanvas.js

@@ -0,0 +1,13 @@
+function flipArrayViaCanvas(input, width, height) {
+    const canvas = document.createElement("canvas");
+    const c = canvas.getContext('2d');
+    const imageData = c.createImageData(width, height);
+    imageData.data.set(input);
+    c.putImageData(imageData, 0, 0);
+    c.translate(0, height);
+    c.scale(1, -1);
+    c.drawImage(canvas, 0, 0);
+    const imgd = c.getImageData(0, 0, width, height);
+
+    return imgd.data;
+}

package/engine/graphics/filter/ImageFilter.js

@@ -3,59 +3,25 @@
  */
 
 
-import {
-    LinearFilter,
-    Mesh,
-    OrthographicCamera,
-    PlaneBufferGeometry,
-    Scene,
-    ShaderMaterial,
-    WebGLRenderTarget
-} from 'three';
-
-export function flipArrayInPlace(input, width, height) {
-    const rowLength = width * 4;
-    let t, x0, x1;
-    let i = 0;
-    const l = height >> 1;
-    for (; i < l; i++) {
-        //swap lines
-        const k = (height - i - 1) * rowLength;
-        const m = i * rowLength;
-        for (let j = 0; j < rowLength; j++) {
-            x0 = m + j;
-            x1 = k + j;
-            t = input[x0];
-            input[x0] = input[x1];
-            input[x1] = t;
-        }
-    }
-}
-
-function flipArrayViaCanvas(input, width, height) {
-    const canvas = document.createElement("canvas");
-    const c = canvas.getContext('2d');
-    const imageData = c.createImageData(width, height);
-    imageData.data.set(input);
-    c.putImageData(imageData, 0, 0);
-    c.translate(0, height);
-    c.scale(1, -1);
-    c.drawImage(canvas, 0, 0);
-    const imgd = c.getImageData(0, 0, width, height);
-
-    return imgd.data;
-}
+import { LinearFilter, Mesh, OrthographicCamera, Scene, ShaderMaterial, WebGLRenderTarget } from 'three';
+import { FULL_SCREEN_TRIANGLE_GEOMETRY } from "../geometry/FULL_SCREEN_TRIANGLE_GEOMETRY.js";
 
 /**
  *
  * @param {WebGLRenderer} renderer
  * @param {number} width
  * @param {number} height
- * @param processShader
+ * @param {{vertexShader:string,fragmentShader:string, uniforms?:Object, defines?:Object}} processShader
  * @param {Uint8Array} [destination]
  * @return {{array: Uint8Array, renderer: WebGLRenderer}}
  */
-function processTexture(renderer, width, height, processShader, destination) {
+function processTexture(
+    renderer,
+    width,
+    height,
+    processShader,
+    destination
+) {
     if (destination === undefined) {
         destination = new Uint8Array(width * height * 4);
     }
@@ -72,9 +38,10 @@ function processTexture(renderer, width, height, processShader, destination) {
     material.lights = false;
     material.fog = false;
 
-    const quad = new Mesh(new PlaneBufferGeometry(2, 2), material);
+    const quad = new Mesh(FULL_SCREEN_TRIANGLE_GEOMETRY, material);
 
     scene.add(quad);
+
     //render
     const renderTargetOptions = {
         generateMipmaps: false,
@@ -82,28 +49,30 @@ function processTexture(renderer, width, height, processShader, destination) {
         stencilBuffer: false,
         depthBuffer: false
     };
+
     const renderTarget = new WebGLRenderTarget(width, height, renderTargetOptions);
 
+    const __rt = renderer.getRenderTarget(); // remember old renderer state
+
     renderer.setRenderTarget(renderTarget);
 
     renderer.render(scene, camera);
 
     const gl = renderer.getContext();
+
     //void readPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, ArrayBufferView? pixels)
     gl.readPixels(0, 0, width, height, gl.RGBA, gl.UNSIGNED_BYTE, destination);
 
-    renderer.setRenderTarget(null);
+    // restore renderer state
+    renderer.setRenderTarget(__rt);
 
-    //reorder lines in the buffer to make Y axis match
-
-    //uint8Array = flipArrayViaCanvas(uint8Array, width, height);
-    //
+    // cleanup resources
     renderTarget.dispose();
     material.dispose();
+
     return {
         array: destination,
         graphics: renderer
-        //renderTarget: renderTarget
     };
 }
 

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

@@ -40,8 +40,8 @@ export class MicronGeometryBufferAttributeSpec {
     equals(other) {
         return this.type === other.type
             && this.itemSize === other.itemSize
-            && this.name === other.name
             && this.normalized === other.normalized
+            && this.name === other.name
             ;
     }
 

package/engine/graphics/micron/prototypeVirtualGeometry.js

@@ -535,7 +535,7 @@ function createScene(geometry, m1, scale) {
     geometry.computeVertexNormals();
 
 
-    const grid_size = 10;
+    const grid_size = 100;
     const grid_spacing = 2000;
 
     for (let i = 0; i < grid_size; i++) {

package/engine/graphics/micron/render/VirtualGeometryBuilder.js

@@ -48,10 +48,10 @@ export class VirtualGeometryBuilder {
 
         /**
          *
-         * @type {WeakMap<ThreeMicronMesh, ActivePatchList>}
+         * @type {ActivePatchList}
          * @private
          */
-        this.__acls = new WeakMap();
+        this.__acl = new ActivePatchList();
 
         /**
          * How much error to accept when deciding to subdivide a cluster
@@ -76,12 +76,8 @@ export class VirtualGeometryBuilder {
         this.__flags__enforce_dependency_splits = true;
     }
 
-    /**
-     * Drop all cached data, forcing a complete rebuild next time
-     * Useful for testing and debugging
-     */
-    dropCache() {
-        this.__acls = new WeakMap();
+    dropCache(){
+        this.__acl.clear();
     }
 
     /**
@@ -137,15 +133,7 @@ export class VirtualGeometryBuilder {
             const micron_geometry = object.geometry;
             if (micron_geometry !== undefined) {
                 // get acl
-
-                const acls = this.__acls;
-
-                let acl = acls.get(object);
-
-                if (acl === undefined) {
-                    acl = new ActivePatchList();
-                    acls.set(object, acl);
-                }
+                const acl = this.__acl;
 
                 acl.initializeFromGeometry(micron_geometry);
 

package/engine/graphics/micron/render/instanced/AttributeDataTexture.js

@@ -2,14 +2,12 @@ import { assert } from "../../../../../core/assert.js";
 import { MICRON_PATCH_SIZE_MAX } from "../../build/MICRON_PATCH_SIZE_MAX.js";
 import { typed_array_copy } from "../../../../../core/collection/array/typed/typed_array_copy.js";
 import { channelCountToThreeTextureFormat } from "../../../texture/channelCountToThreeTextureFormat.js";
-import {
-    computeThreeTextureInternalFormatFromDataType,
-    computeThreeTextureTypeFromDataType
-} from "../../../render/forward_plus/TextureBackedMemoryRegion.js";
 import { DataTexture, NearestFilter } from "three";
 import { DataTypeByteSizes } from "../../../../../core/collection/table/RowFirstTableSpec.js";
 import { DataType } from "../../../../../core/collection/table/DataType.js";
 import { compute_micron_buffer_array_constructor } from "../../build/compute_micron_buffer_array_constructor.js";
+import { computeThreeTextureTypeFromDataType } from "../../../render/forward_plus/data/computeThreeTextureTypeFromDataType.js";
+import { computeThreeTextureInternalFormatFromDataType } from "../../../render/forward_plus/data/computeThreeTextureInternalFormatFromDataType.js";
 
 /**
  *