@woosh/meep-engine 2.33.5 → 2.33.10

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/culling/{PathCullingSystem.js → PatchCullingSystem.js}

@@ -49,7 +49,7 @@ function buildExecutor() {
 
 const MAX_PATCH_COUNT = 60000;
 
-export class PathCullingSystem {
+export class PatchCullingSystem {
     constructor() {
         /**
          *

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

@@ -3,11 +3,11 @@ 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 { 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";
+import { DataTypeByteSizes } from "../../../../../core/collection/table/DataTypeByteSizes.js";
 
 /**
  *

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 "../../../../../core/geom/3d/frustum/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/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/micron/render/v1/getTransformedPositionsCached.js

@@ -1,5 +1,5 @@
 import { PatchCacheKey } from "../PatchCacheKey.js";
-import { apply_mat4_transform_to_v3_array } from "./apply_mat4_transform_to_v3_array.js";
+import { apply_mat4_transform_to_v3_array } from "../../../../../core/geom/3d/apply_mat4_transform_to_v3_array.js";
 import { Cache } from "../../../../../core/cache/Cache.js";
 import { invokeObjectHash } from "../../../../../core/model/object/invokeObjectHash.js";
 import { invokeObjectEquals } from "../../../../../core/model/object/invokeObjectEquals.js";

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/data/TextureBackedMemoryRegion.js

@@ -3,12 +3,12 @@ import { DataType } from "../../../../../core/collection/table/DataType.js";
 import { assert } from "../../../../../core/assert.js";
 import { DataType2TypedArrayConstructorMapping } from "../../../../../core/collection/table/DataType2TypedArrayConstructorMapping.js";
 import { max2 } from "../../../../../core/math/max2.js";
-import { DataTypeByteSizes } from "../../../../../core/collection/table/RowFirstTableSpec.js";
 import { NumericType } from "./NumericType.js";
 import { computeDataType } from "./computeDataType.js";
 import { computeThreeTextureTypeFromDataType } from "./computeThreeTextureTypeFromDataType.js";
 import { computeThreeTextureInternalFormatFromDataType } from "./computeThreeTextureInternalFormatFromDataType.js";
 import { computeThreeTextureFormat } from "./computeThreeTextureFormat.js";
+import { DataTypeByteSizes } from "../../../../../core/collection/table/DataTypeByteSizes.js";
 
 /**
  * How wide a data texture is

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,13 +65,12 @@ 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 { Matrix4 } from "three";
 import { inverseLerp } from "../../../../../core/math/inverseLerp.js";
 import { clamp } from "../../../../../core/math/clamp.js";
 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";
 
 const engineHarness = new EngineHarness();
 
@@ -219,8 +218,14 @@ function prepare_query_test(hiz, graphics, ecd) {
 
     function prepare_query() {
 
-        const spec = new RefinementSpec();
-        spec.build(new Matrix4(), graphics.camera.matrixWorldInverse, graphics.camera.projectionMatrix);
+        const camera = graphics.camera;
+
+        const projection = mat4.create();
+        const world_inverse = camera.matrixWorldInverse.elements;
+        const camera_projection = camera.projectionMatrix.elements;
+
+        mat4.copy(projection, world_inverse);
+        mat4.multiply(projection, camera_projection, projection);
 
         for (let i = 0; i < query.getSize(); i++) {
             const entity = entities[i];
@@ -237,7 +242,7 @@ function prepare_query_test(hiz, graphics, ecd) {
 
             mesh.bvh.writeToArray(aabb, 0);
 
-            query.setElement(i, aabb, spec.projection_matrix);
+            query.setElement(i, aabb, projection);
         }
 
     }
@@ -412,7 +417,7 @@ function main(engine) {
         metrics.get('hiz_build').record(t1 - t0);
 
 
-        preview.texture = hiz.mips[0].texture;
+        preview.texture = hiz.mips[1].texture;
 
         preview.render();
 

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