@woosh/meep-engine 2.33.5 → 2.33.6

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

@@ -2,6 +2,8 @@ import { isArrayEqual } from "../../../../core/collection/ArrayUtils.js";
 import { computeHashArray } from "../../../../core/math/MathUtils.js";
 import { invokeObjectHash } from "../../../../core/model/object/invokeObjectHash.js";
 
+const DEFAULT_HASH = 123456;
+
 export class MicronVertexDataSpec {
     constructor() {
         /**
@@ -12,9 +14,21 @@ export class MicronVertexDataSpec {
 
         /**
          *
-         * @type {RowFirstTableSpec|null}
+         * @type {number}
+         * @private
          */
-        this.data = null;
+        this.__hash = DEFAULT_HASH;
+    }
+
+    /**
+     *
+     * @param {MicronGeometryBufferAttributeSpec[]} attributes
+     */
+    setAttributes(attributes) {
+        this.attributes = attributes;
+
+        // reset hash to trigger hash update
+        this.__hash = DEFAULT_HASH;
     }
 
     /**
@@ -30,10 +44,18 @@ export class MicronVertexDataSpec {
         return isArrayEqual(this.attributes, other.attributes);
     }
 
-    hash() {
+    computeHash() {
         return computeHashArray(this.attributes, invokeObjectHash);
     }
 
+    hash() {
+        if (this.__hash === DEFAULT_HASH) {
+            this.__hash = this.computeHash();
+        }
+
+        return this.__hash;
+    }
+
     /**
      *
      * @param {string} name

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

@@ -2,19 +2,33 @@ import { Frustum, Matrix4 } from "three";
 import { array_copy } from "../../../../core/collection/array/copyArray.js";
 import Vector2 from "../../../../core/geom/Vector2.js";
 import { MicronGeometryPatchOccurrence } from "../format/MicronGeometryPatchOccurance.js";
-import { RefinementSpec } from "./RefinementSpec.js";
+import { RefinementSpec } from "./refinement/RefinementSpec.js";
 import { ActivePatchList } from "./refinement/ActivePatchList.js";
 import { ActivePatchFlags } from "./refinement/ActivePatchFlags.js";
 
-
+/**
+ * @readonly
+ * @type {RefinementSpec}
+ */
 const refinement_spec = new RefinementSpec();
 
 export class VirtualGeometryBuilder {
     constructor() {
         this.view_projection_matrix = new Matrix4();
-        this.matrix_projection = new Matrix4();
+
+        /**
+         *
+         * @type {Float32Array|number[]|mat4}
+         */
+        this.matrix_projection = new Float32Array(16);
+
         this.matrix_projection_inverse = new Matrix4();
-        this.matrix_world_inverse = new Matrix4();
+
+        /**
+         *
+         * @type {Float32Array|number[]|mat4}
+         */
+        this.matrix_world_inverse = new Float32Array(16);
 
         /**
          *
@@ -76,7 +90,7 @@ export class VirtualGeometryBuilder {
         this.__flags__enforce_dependency_splits = true;
     }
 
-    dropCache(){
+    dropCache() {
         this.__acl.clear();
     }
 
@@ -98,8 +112,10 @@ export class VirtualGeometryBuilder {
         camera.updateMatrixWorld(true);
 
         this.view_projection_matrix.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
-        this.matrix_world_inverse.copy(camera.matrixWorldInverse);
-        this.matrix_projection.copy(camera.projectionMatrix);
+
+        this.matrix_world_inverse.set(camera.matrixWorldInverse.elements);
+        this.matrix_projection.set(camera.projectionMatrix.elements);
+
         this.matrix_projection_inverse.copy(camera.projectionMatrixInverse);
 
         this.view_frustum.setFromProjectionMatrix(this.view_projection_matrix);
@@ -170,7 +186,7 @@ export class VirtualGeometryBuilder {
         apl
     ) {
 
-        refinement_spec.build(transform, this.matrix_world_inverse, this.matrix_projection);
+        refinement_spec.build(transform.elements, this.matrix_world_inverse, this.matrix_projection);
 
         const output = this.output;
 

package/engine/graphics/micron/render/refinement/ActivePatchList.js

@@ -185,6 +185,8 @@ export class ActivePatchList {
     refine(spec) {
 
         const frustum_planes = spec.frustum_f32;
+        const projection_matrix = spec.projection_matrix;
+        const error_threshold = spec.error_threshold_normalized;
 
         let record = this.records
 
@@ -199,8 +201,7 @@ export class ActivePatchList {
              check if node is in view frustum
              NOTE: following suggestion in "FastMesh: Efficient View-dependent Meshing" by Renato Pajarola et al, we can do a more coarse frustum test approximating frustum as a cone initially
              */
-            const bounding_box = node.bounding_box;
-            const in_view_frustum = aabb3_intersects_frustum(bounding_box, frustum_planes);
+            const in_view_frustum = aabb3_intersects_frustum(node.bounding_box, frustum_planes);
 
             if (!in_view_frustum) {
                 // outside of view frustum, cull
@@ -211,21 +212,6 @@ export class ActivePatchList {
                 continue;
             }
 
-            // compute projected bounds of the patch
-            // const patch_screen_area = compute_projected_area(bounding_box, spec);
-
-            // const patch_is_too_small_to_be_seen = patch_screen_area < spec.error_threshold;
-            //
-            // if (patch_is_too_small_to_be_seen) {
-            //     // the whole patch is too small, cull
-            //     if (prev_is_visible) {
-            //         record.clearFlag(ActivePatchFlags.Visible);
-            //     }
-            //
-            //     // try to merge with sibling
-            //     continue;
-            // }
-
             if (!prev_is_visible) {
                 record.setFlag(ActivePatchFlags.Visible);
             }
@@ -243,22 +229,17 @@ export class ActivePatchList {
                 // not the lowest level of LOD, see if subdivision might be necessary
 
                 // compute average triangle area
-                const group_screen_area = aabb3_project_to_2d(node.group_bounding_box_corners, spec.projection_matrix);
+                const group_screen_area = aabb3_project_to_2d(node.group_bounding_box_corners, projection_matrix);
                 const screen_space_error = node.group_error * group_screen_area;
 
-
-                if (screen_space_error > spec.error_threshold_normalized) {
+                if (screen_space_error > error_threshold) {
                     // error too large, needs to be split
                     record = this.node_split(record);
                     continue;
                 }
             }
-            record = record.link_next;
 
-            // check if record and its sibling can be merged
-            // if (approximate_triangle_area < spec.error_threshold) {
-            //     this.node_try_merge(record, spec);
-            // }
+            record = record.link_next;
         }
     }
 }

package/engine/graphics/micron/render/refinement/RefinementSpec.js

@@ -0,0 +1,98 @@
+import Vector2 from "../../../../../core/geom/Vector2.js";
+import { mat4 } from "gl-matrix";
+import { array_setFromProjectionMatrix } from "./array_setFromProjectionMatrix.js";
+
+export class RefinementSpec {
+    constructor() {
+
+        /**
+         * Viewport resolution
+         * @type {Vector2}
+         */
+        this.resolution = new Vector2();
+
+        /**
+         * Number of pixels in the viewport
+         * @type {number}
+         */
+        this.viewport_area = 0;
+
+        /**
+         * How much error to accept when deciding to subdivide a cluster
+         * Measured in pixels
+         * Higher value will result in better performance but more visible artifacts
+         * @type {number}
+         */
+        this.error_threshold = 1;
+
+        /**
+         * Error threshold as a fraction of the screen area instead of pixels, derived internally from pixel value
+         * @type {number}
+         */
+        this.error_threshold_normalized = 1;
+
+        /**
+         * Continuous memory region for faster access
+         * @type {ArrayBuffer}
+         */
+        const array_buffer = new ArrayBuffer(160);
+
+        /**
+         * Object-space camera frustum
+         * Frustum planes in compact form
+         * @type {Float32Array}
+         */
+        this.frustum_f32 = new Float32Array(array_buffer, 0, 24);
+
+
+        /**
+         * Contains transformation from camera space to object space
+         * @type {Float32Array|number[]|mat4}
+         */
+        this.projection_matrix = new Float32Array(array_buffer, 24 * 4, 16);
+
+        /**
+         * Model world transform
+         * @type {Float32Array|number[]|mat4}
+         */
+        // this.transform = new Float32Array(16);
+
+        /**
+         * Object-space camera position
+         * @type {Float32Array}
+         */
+        this.view_position = new Float32Array(3);
+    }
+
+    get frustum() {
+        throw new Error('deprecated, use .frustum_f32 instead');
+    }
+
+    setResolution(x, y) {
+        this.resolution.set(x, y);
+
+        this.viewport_area = x * y;
+
+        this.error_threshold_normalized = this.error_threshold / this.viewport_area;
+    }
+
+    /**
+     *
+     * @param {number[]|mat4|Float32Array|ArrayLike<number>} transform world-space object transform
+     * @param {number[]|mat4|Float32Array|ArrayLike<number>} matrix_world_inverse camera's world inverse matrix
+     * @param {number[]|mat4|Float32Array|ArrayLike<number>} matrix_projection camera's projection matrix
+     */
+    build(transform, matrix_world_inverse, matrix_projection) {
+        // const _transform = this.transform;
+        // _transform.set(transform);
+
+        // build projection matrix
+        const projection_matrix = this.projection_matrix;
+
+        mat4.multiply(projection_matrix, matrix_world_inverse, transform);
+        mat4.multiply(projection_matrix, matrix_projection, projection_matrix);
+
+        // compute view frustum in model-space
+        array_setFromProjectionMatrix(this.frustum_f32, projection_matrix);
+    }
+}

package/engine/graphics/micron/render/refinement/array_normalize_plane.js

@@ -0,0 +1,25 @@
+import { v3_length } from "../../../../../core/geom/Vector3.js";
+
+/**
+ * Normalize a plane in-place
+ * @param {number[]} source
+ * @param {number} source_offset
+ */
+function array_normalize_plane(source, source_offset) {
+    const _x = source[source_offset];
+    const _y = source[source_offset + 1];
+    const _z = source[source_offset + 2];
+
+    const length = v3_length(_x, _y, _z);
+
+    const inverseNormalLength = 1.0 / length;
+
+    /*
+    By re-using values already in the registers instead of using *= we save a few extra READ ops
+     */
+    source[source_offset] = _x * inverseNormalLength;
+    source[source_offset + 1] = _y * inverseNormalLength;
+    source[source_offset + 2] = _z * inverseNormalLength;
+
+    source[source_offset + 3] *= inverseNormalLength;
+}

package/engine/graphics/micron/render/refinement/array_setFromProjectionMatrix.js

@@ -0,0 +1,60 @@
+import { v3_length } from "../../../../../core/geom/Vector3.js";
+
+/**
+ *
+ * @param {number[]} destination
+ * @param {number} destination_offset
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @param {number} w
+ */
+function array_set_plane_normalized(destination, destination_offset, x, y, z, w) {
+    const length = v3_length(x, y, z);
+
+    const inverseNormalLength = 1.0 / length;
+
+    destination[destination_offset] = x * inverseNormalLength;
+    destination[destination_offset + 1] = y * inverseNormalLength;
+    destination[destination_offset + 2] = z * inverseNormalLength;
+    destination[destination_offset + 3] = w * inverseNormalLength;
+}
+
+/**
+ *
+ * @param {number[]|Float32Array} frustum_planes
+ * @param {number[]} me
+ */
+export function array_setFromProjectionMatrix(frustum_planes, me) {
+
+    const me0 = me[0];
+    const me3 = me[3];
+
+    const me4 = me[4];
+    const me7 = me[7];
+
+    const me8 = me[8];
+    const me11 = me[11];
+
+    const me12 = me[12];
+    const me15 = me[15];
+
+    array_set_plane_normalized(frustum_planes, 0, me3 - me0, me7 - me4, me11 - me8, me15 - me12);
+    array_set_plane_normalized(frustum_planes, 4, me3 + me0, me7 + me4, me11 + me8, me15 + me12);
+
+    const me1 = me[1];
+    const me5 = me[5];
+    const me9 = me[9];
+    const me13 = me[13];
+
+    array_set_plane_normalized(frustum_planes, 8, me3 + me1, me7 + me5, me11 + me9, me15 + me13);
+    array_set_plane_normalized(frustum_planes, 12, me3 - me1, me7 - me5, me11 - me9, me15 - me13);
+
+    const me2 = me[2];
+    const me6 = me[6];
+    const me10 = me[10];
+    const me14 = me[14];
+
+    array_set_plane_normalized(frustum_planes, 16, me3 - me2, me7 - me6, me11 - me10, me15 - me14);
+    array_set_plane_normalized(frustum_planes, 20, me3 + me2, me7 + me6, me11 + me10, me15 + me14);
+}

package/engine/graphics/micron/render/v1/MaterialVertexSpec.js

@@ -12,6 +12,27 @@ export class MaterialVertexSpec {
         this.material = null;
     }
 
+    /**
+     *
+     * @param {MaterialVertexSpec} other
+     */
+    copy(other) {
+        this.spec = other.spec;
+        this.material = other.material;
+    }
+
+    /**
+     *
+     * @return {MaterialVertexSpec}
+     */
+    clone() {
+        const r = new MaterialVertexSpec();
+
+        r.copy(this);
+
+        return r;
+    }
+
     /**
      * @param {MicronVertexDataSpec} spec
      * @param {Material} material

package/engine/graphics/micron/render/v1/VGThreeRenderer.js

@@ -7,6 +7,12 @@ import { HashMap } from "../../../../../core/collection/HashMap.js";
 import Signal from "../../../../../core/events/signal/Signal.js";
 import { array_copy } from "../../../../../core/collection/array/copyArray.js";
 
+/**
+ *
+ * @type {MaterialVertexSpec}
+ */
+const scratch_mvc = new MaterialVertexSpec();
+
 export class VGThreeRenderer {
     constructor() {
         this.geometry = new VirtualGeometry();
@@ -32,13 +38,6 @@ export class VGThreeRenderer {
          */
         this.__contexts_array = [];
 
-        /**
-         *
-         * @type {Scene|null}
-         * @private
-         */
-        this.__scene = null;
-
         /**
          *
          * @type {Object3D[]}
@@ -75,14 +74,18 @@ export class VGThreeRenderer {
      * @private
      */
     __obtain_material(spec, m) {
-        const key = MaterialVertexSpec.from(spec, m);
+        scratch_mvc.material = m;
+        scratch_mvc.spec = spec;
 
-        const existing = this.material_contexts.get(key);
+        const existing = this.material_contexts.get(scratch_mvc);
 
         if (existing !== undefined) {
             return existing;
         }
 
+        // create a separate instance to be stored alongside the context
+        const key = scratch_mvc.clone();
+
         const ctx = new MaterialContext(spec, m);
 
         ctx.init(this.__gl_context);

package/engine/graphics/render/buffer/buffers/ColorAndDepthFrameBuffer.js

@@ -1,9 +1,10 @@
 import { FrameBuffer } from "../FrameBuffer.js";
 import {
+    DepthFormat,
     DepthTexture,
     FloatType,
     NearestFilter,
-    RGBAFormat,
+    RGBFormat,
     sRGBEncoding,
     Vector2,
     WebGLMultisampleRenderTarget
@@ -39,9 +40,9 @@ export class ColorAndDepthFrameBuffer extends FrameBuffer {
 
         renderer.getSize(size);
 
-        const target = new WebGLMultisampleRenderTarget(size.x, size.y);
+        const target = new WebGLMultisampleRenderTarget(size.x, size.y,{ignoreDepth: false});
 
-        target.texture.format = RGBAFormat; // note, three.js required RGBA render texture, even though RGB would do here
+        target.texture.format = RGBFormat; // note, three.js required RGBA render texture, even though RGB would do here
         target.texture.minFilter = NearestFilter;
         target.texture.magFilter = NearestFilter;
         target.texture.generateMipmaps = false;
@@ -51,6 +52,7 @@ export class ColorAndDepthFrameBuffer extends FrameBuffer {
         target.depthBuffer = true;
 
         target.depthTexture = new DepthTexture();
+        target.depthTexture.format = DepthFormat;
         target.depthTexture.type = FloatType;
         target.depthTexture.generateMipmaps = false;
         target.depthTexture.internalFormat = 'DEPTH_COMPONENT32F';

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

@@ -233,7 +233,7 @@ function prepare_scene_0() {
 
     controls.minDistance = 2;
 
-    for (let i = 0; i < 5000; i++) {
+    for (let i = 0; i < 500; i++) {
         const radius = randomFloatBetween(random, 4, 4);
         const intensity = randomFloatBetween(random, 2, 2);
         addPointLight([

package/engine/graphics/render/visibility/hiz/prototypeHiZ.js

@@ -65,7 +65,7 @@ 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 { RefinementSpec } from "../../../micron/render/RefinementSpec.js";
+import { RefinementSpec } from "../../../micron/render/refinement/RefinementSpec.js";
 import { Matrix4 } from "three";
 import { inverseLerp } from "../../../../../core/math/inverseLerp.js";
 import { clamp } from "../../../../../core/math/clamp.js";

package/engine/graphics/shadows/ShadowMapRenderer.js

@@ -64,7 +64,6 @@ export class ShadowMapRenderer {
         this.__renderer = renderer;
 
         this.__ensure_map(shadow, renderer);
-        shadow_camera.updateProjectionMatrix();
 
         // draw scene from perspective of shadow camera into the render texture
 
@@ -92,7 +91,7 @@ export class ShadowMapRenderer {
 
         renderer.clear(true, true, false);
 
-        shadow.updateMatrices(light);
+        shadow.updateMatrices(light, 0);
 
         this.onBeforeRender.send3(renderer, shadow_camera, scene);
 
@@ -123,6 +122,16 @@ export class ShadowMapRenderer {
     __do_vsm_pass(shadow) {
         const _renderer = this.__renderer;
 
+        if (shadowMaterialVertical.defines.VSM_SAMPLES !== shadow.blurSamples) {
+
+            shadowMaterialVertical.defines.VSM_SAMPLES = shadow.blurSamples;
+            shadowMaterialHorizontal.defines.VSM_SAMPLES = shadow.blurSamples;
+
+            shadowMaterialVertical.needsUpdate = true;
+            shadowMaterialHorizontal.needsUpdate = true;
+
+        }
+
         // vertical pass
 
         const vertical = shadowMaterialVertical.uniforms;
@@ -181,6 +190,7 @@ export class ShadowMapRenderer {
             shadow.map = new WebGLRenderTarget(_shadowMapSize.x, _shadowMapSize.y, pars);
             shadow.map.texture.name = '.shadowMap';
 
+            shadow.camera.updateProjectionMatrix();
         }
     }
 }

package/engine/graphics/texture/cubemap/load_environment_map.js

@@ -2,6 +2,7 @@ import { EXRLoader } from "three/examples/jsm/loaders/EXRLoader.js";
 import { CubeTextureLoader, LinearFilter, PMREMGenerator, sRGBEncoding, TextureLoader, UnsignedByteType } from "three";
 import { noop } from "../../../../core/function/Functions.js";
 import { computeFileExtension } from "../../../../core/FilePath.js";
+import { HDRCubeTextureLoader } from "three/examples/jsm/loaders/HDRCubeTextureLoader.js";
 
 /**
  *
@@ -11,6 +12,28 @@ import { computeFileExtension } from "../../../../core/FilePath.js";
 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 => {
+                texture.magFilter = LinearFilter;
+                texture.encoding = sRGBEncoding;
+                resolve(texture);
+            },
+            noop,
+            reject
+        );
+    });
+}
+
+/**
+ *
+ * @param {string[]|string} paths
+ * @return {Promise<THREE.CubeTexture>}
+ */
+function load_hdr_cube_texture(paths) {
+    // piece-wise cubemap, a collection of images for each face
+    const cubeTextureLoader = new HDRCubeTextureLoader();
     return new Promise((resolve, reject) => {
         cubeTextureLoader.load(
             paths,
@@ -78,10 +101,13 @@ export async function load_environment_map({ path, renderer, original = false, f
     let texture;
 
     if (Array.isArray(path)) {
-        texture = await load_cube_texture(path);
+        const ext = computeFileExtension(path[0]);
 
-        texture.magFilter = LinearFilter;
-        texture.encoding = sRGBEncoding;
+        if (ext === 'hdr') {
+            texture = await load_hdr_cube_texture(path);
+        } else {
+            texture = await load_cube_texture(path);
+        }
 
         type = 'c';