@woosh/meep-engine 2.34.40 → 2.34.44

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

@@ -1,10 +1,10 @@
-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 "./refinement/RefinementSpec.js";
 import { ActivePatchList } from "./refinement/ActivePatchList.js";
 import { ActivePatchFlags } from "./refinement/ActivePatchFlags.js";
+import { mat4 } from "gl-matrix";
 
 /**
  * @readonly
@@ -14,27 +14,27 @@ const refinement_spec = new RefinementSpec();
 
 export class VirtualGeometryBuilder {
     constructor() {
-        this.view_projection_matrix = new Matrix4();
+
+
+        const common_buffer = new ArrayBuffer(192);
+
 
         /**
-         *
+         * Camera's world inverse matrix
          * @type {Float32Array|number[]|mat4}
          */
-        this.matrix_projection = new Float32Array(16);
-
-        this.matrix_projection_inverse = new Matrix4();
-
+        this.matrix_world_inverse = new Float32Array(common_buffer, 0, 16);
         /**
-         *
+         * Camera's projection matrix
          * @type {Float32Array|number[]|mat4}
          */
-        this.matrix_world_inverse = new Float32Array(16);
+        this.matrix_projection = new Float32Array(common_buffer, 64, 16);
 
         /**
          *
-         * @type {Frustum}
+         * @type {Float32Array|number[]|mat4}
          */
-        this.view_frustum = new Frustum();
+        this.view_projection_matrix = new Float32Array(common_buffer, 128, 16);
 
         /**
          * @private
@@ -74,20 +74,6 @@ export class VirtualGeometryBuilder {
          * @type {number}
          */
         this.error_bias = 2;
-
-        /**
-         *
-         * @type {number}
-         * @private
-         */
-        this.__info_enforced_node_splits = 0;
-
-        /**
-         *
-         * @type {boolean}
-         * @private
-         */
-        this.__flags__enforce_dependency_splits = true;
     }
 
     dropCache() {
@@ -111,27 +97,15 @@ export class VirtualGeometryBuilder {
         camera.updateMatrix();
         camera.updateMatrixWorld(true);
 
-        this.view_projection_matrix.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
-
         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);
+        mat4.multiply(this.view_projection_matrix, this.matrix_projection, this.matrix_world_inverse);
 
         //
         refinement_spec.focal_length = camera.fov / 180;
     }
 
-    /**
-     *
-     * @param {THREE.Matrix4} matrix
-     */
-    setProjectionMatrix(matrix) {
-        this.view_projection_matrix.copy(matrix);
-    }
-
     /**
      *
      * @param {THREE.Object3D|ThreeMicronMesh} object
@@ -156,7 +130,7 @@ export class VirtualGeometryBuilder {
                 this.buildForMesh(
                     object.instance_id,
                     micron_geometry,
-                    object.matrixWorld,
+                    object.matrixWorld.elements,
                     acl
                 );
             }
@@ -176,7 +150,7 @@ export class VirtualGeometryBuilder {
      *
      * @param {number} instance_id
      * @param {MicronGeometry} geometry
-     * @param {THREE.Matrix4} transform
+     * @param {number[]} transform world transform matrix of the instance
      * @param {ActivePatchList} apl
      */
     buildForMesh(
@@ -186,7 +160,7 @@ export class VirtualGeometryBuilder {
         apl
     ) {
 
-        refinement_spec.build(transform.elements, this.matrix_world_inverse, this.matrix_projection);
+        refinement_spec.build(transform, this.view_projection_matrix);
 
         const output = this.output;
 

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

@@ -141,6 +141,10 @@ export class ThreeInstancedAdapter {
         const geo = this.__buffer_geometry;
 
         const patch_transform_attribute = geo.getAttribute(ATTRIBUTE_NAME_TRANSFORM);
+        /**
+         *
+         * @type {Float32Array}
+         */
         const patch_transform_array = patch_transform_attribute.array;
 
         patch_transform_attribute.needsUpdate = true;
@@ -157,7 +161,7 @@ export class ThreeInstancedAdapter {
 
             const i16 = i * 16;
 
-            occurrence.transform.toArray(patch_transform_array, i16);
+            patch_transform_array.set(occurrence.transform, i16);
 
             const patch_slot_id = patch_data.ensure(occurrence.patch);
 

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

@@ -2,7 +2,7 @@ import { ActivePatchRecord } from "./ActivePatchRecord.js";
 import { ActivePatchFlags } from "./ActivePatchFlags.js";
 import { aabb3_project_to_2d } from "../../../../../core/geom/3d/aabb/aabb3_compute_projected_area.js";
 import { BitSet } from "../../../../../core/binary/BitSet.js";
-import { aabb3_intersects_frustum } from "../../../../../core/bvh2/aabb3/aabb3_intersects_frustum.js";
+import { aabb3_intersects_frustum_array } from "../../../../../core/bvh2/aabb3/aabb3_intersects_frustum_array.js";
 
 export class ActivePatchList {
     constructor() {
@@ -201,7 +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 in_view_frustum = aabb3_intersects_frustum(node.bounding_box, frustum_planes);
+            const in_view_frustum = aabb3_intersects_frustum_array(node.bounding_box, frustum_planes);
 
             if (!in_view_frustum) {
                 // outside of view frustum, cull

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

@@ -1,6 +1,6 @@
 import Vector2 from "../../../../../core/geom/Vector2.js";
 import { mat4 } from "gl-matrix";
-import { array_setFromProjectionMatrix } from "../../../../../core/geom/3d/frustum/array_setFromProjectionMatrix.js";
+import { frustum_from_projection_matrix_array } from "../../../../../core/geom/3d/frustum/frustum_from_projection_matrix_array.js";
 
 export class RefinementSpec {
     constructor() {
@@ -37,25 +37,20 @@ export class RefinementSpec {
          */
         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);
+        this.projection_matrix = new Float32Array(array_buffer, 0, 16);
 
         /**
-         * Model world transform
-         * @type {Float32Array|number[]|mat4}
+         * Object-space camera frustum
+         * Frustum planes in compact form
+         * @type {Float32Array}
          */
-        // this.transform = new Float32Array(16);
+        this.frustum_f32 = new Float32Array(array_buffer, 64, 24);
+
 
         /**
          * Object-space camera position
@@ -68,6 +63,11 @@ export class RefinementSpec {
         throw new Error('deprecated, use .frustum_f32 instead');
     }
 
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     */
     setResolution(x, y) {
         this.resolution.set(x, y);
 
@@ -79,20 +79,16 @@ export class RefinementSpec {
     /**
      *
      * @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
+     * @param {number[]|mat4|Float32Array|ArrayLike<number>} view_projection_matrix camera's view projection matrix (projection* world_inverse)
      */
-    build(transform, matrix_world_inverse, matrix_projection) {
-        // const _transform = this.transform;
-        // _transform.set(transform);
+    build(transform, view_projection_matrix) {
 
         // 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);
+        mat4.multiply(projection_matrix, view_projection_matrix, transform);
 
         // compute view frustum in model-space
-        array_setFromProjectionMatrix(this.frustum_f32, projection_matrix);
+        frustum_from_projection_matrix_array(this.frustum_f32, projection_matrix);
     }
 }

package/engine/graphics/render/buffer/simple-fx/DepthLimitedBlur.js

@@ -1,9 +1,19 @@
-import { NoBlending, RGBAFormat, ShaderMaterial, UniformsUtils, Vector2, WebGLMultisampleRenderTarget } from "three";
+import {
+    Color,
+    NoBlending,
+    RGBAFormat,
+    ShaderMaterial,
+    UniformsUtils,
+    Vector2,
+    WebGLMultisampleRenderTarget
+} from "three";
 import { BlurShaderUtils, DepthLimitedBlurShader } from "three/examples/jsm/shaders/DepthLimitedBlurShader.js";
 import { renderScreenSpace } from "../../utils/renderScreenSpace.js";
 
+const scratch_color = new Color();
+
 export class DepthLimitedBlur {
-    constructor({ format = RGBAFormat, radius = 8 }) {
+    constructor({ format = RGBAFormat, radius = 8, clear_color = 0, clear_alpha = 1 }) {
 
         /**
          *
@@ -43,6 +53,9 @@ export class DepthLimitedBlur {
 
         this.__blur_radius = radius;
         this.__blur_std_dev = 4;
+
+        this.__clear_color = new Color(clear_color);
+        this.__clear_alpha = clear_alpha;
     }
 
     configureMaterials() {
@@ -113,21 +126,31 @@ export class DepthLimitedBlur {
         mx.uniforms.size.value.set(this.__rt_output.width, this.__rt_output.height);
         my.uniforms.size.value.set(this.__rt_output.width, this.__rt_output.height);
 
-
+        // remember renderer state
         const __old_state_rt = renderer.getRenderTarget();
-
+        const __old_clear_color = scratch_color;
+        renderer.getClearColor(__old_clear_color);
+        const __old_clear_alpha = renderer.getClearAlpha();
+        const __old_auto_clear = renderer.autoClear;
+
+        //
+        renderer.autoClear = false;
+        renderer.setClearColor(this.__clear_color);
         renderer.setRenderTarget(this.__intermediate);
         renderer.clearColor();
 
         renderScreenSpace(renderer, mx);
 
         renderer.setRenderTarget(this.__rt_output);
+
         renderer.clearColor();
 
         renderScreenSpace(renderer, my);
 
         // restore state
         renderer.setRenderTarget(__old_state_rt);
+        renderer.setClearColor(__old_clear_color, __old_clear_alpha);
+        renderer.autoClear = __old_auto_clear;
     }
 
     /**

package/engine/graphics/render/buffer/simple-fx/ao/AmbientOcclusionPostProcessEffect.js

@@ -6,6 +6,7 @@ import {
     RedFormat,
     ShaderMaterial,
     UniformsUtils,
+    UnsignedByteType,
     WebGLMultisampleRenderTarget
 } from "three";
 import { SAOShader } from "./SAOShader.js";
@@ -91,6 +92,8 @@ export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
             magFilter: LinearFilter,
 
             format: RedFormat,
+            type: UnsignedByteType,
+            internalFormat: 'R8',
             depthBuffer: false,
             stencilBuffer: false,
             generateMipmaps: false,
@@ -108,7 +111,7 @@ export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
          * @type {DepthLimitedBlur}
          * @private
          */
-        this.__blur = new DepthLimitedBlur({ format: RedFormat });
+        this.__blur = new DepthLimitedBlur({ format: RedFormat, clear_color: 0xFFFFFF });
     }
 
     /**
@@ -304,7 +307,9 @@ export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
         // bind compositing layer
         this.__composit_layer = graphics.layerComposer.createLayer(
             {
-                format: RedFormat
+                format: RedFormat,
+                type: UnsignedByteType,
+                internalFormat: 'R8'
             },
             BlendingType.Multiply
         );