@woosh/meep-engine 2.33.3 → 2.33.8

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);
 
         /**
          *
@@ -48,10 +62,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 +90,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();
+        this.__acl.clear();
     }
 
     /**
@@ -102,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);
@@ -137,15 +149,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);
 
@@ -182,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;
 
@@ -256,9 +260,7 @@ export class VirtualGeometryBuilder {
 
         const resolution = this.resolution;
 
-        refinement_spec.resolution.copy(resolution);
-
-        refinement_spec.viewport_area = resolution.x * resolution.y;
+        refinement_spec.setResolution(resolution.x, resolution.y);
 
         // clear output
         this.output.clear();

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

@@ -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";
 
 /**
  *

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

@@ -1,25 +1,9 @@
 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 { approximateTriangleArea } from "../approximateTriangleArea.js";
 import { BitSet } from "../../../../../core/binary/BitSet.js";
 import { aabb3_intersects_frustum } from "../../../../../core/bvh2/aabb3/aabb3_intersects_frustum.js";
 
-/**
- *
- * @param {number[]|Float32Array} bounding_box_corners
- * @param {RefinementSpec} spec
- * @returns {number}
- */
-function compute_projected_area(bounding_box_corners, spec) {
-    // Cull by screen area
-    const normalized_screen_area = aabb3_project_to_2d(bounding_box_corners, spec.projection_matrix);
-
-    const patch_screen_area = normalized_screen_area * spec.viewport_area;
-
-    return patch_screen_area;
-}
-
 export class ActivePatchList {
     constructor() {
         /**
@@ -39,6 +23,19 @@ export class ActivePatchList {
          * @type {BitSet}
          */
         this.unfolded = new BitSet();
+
+        // prevent re-allocation related thrashing
+        this.unfolded.preventShrink();
+    }
+
+    clear() {
+        const unfolded = this.unfolded;
+
+        unfolded.reset();
+
+        ActivePatchRecord.pool_release_all(this.records);
+
+        this.records = null;
     }
 
     /**
@@ -46,14 +43,15 @@ export class ActivePatchList {
      * @param {MicronGeometry} geometry
      */
     initializeFromGeometry(geometry) {
-        const record = ActivePatchRecord.fromPatch(geometry.root);
+        this.clear();
+
+        const record = ActivePatchRecord.pool_get();
 
+        record.patch = geometry.root;
         record.link_next = null;
         record.link_previous = null;
 
         const unfolded = this.unfolded;
-
-        unfolded.reset();
         unfolded.set(record.patch.id, true);
 
         this.records = record;
@@ -62,6 +60,7 @@ export class ActivePatchList {
     /**
      *
      * @param {ActivePatchRecord} record
+     * @returns {ActivePatchRecord}
      */
     node_split(record) {
 
@@ -74,19 +73,24 @@ export class ActivePatchList {
 
             const child_id = child.id;
 
-            if (unfolded.get(child_id)) {
+            if (unfolded.getAndSet(child_id)) {
                 // already unfolded, skip
                 continue;
             }
 
-            const child_record = ActivePatchRecord.fromPatch(child);
+            const child_record = ActivePatchRecord.pool_get();
+            child_record.patch = child;
 
             this.record_insert_after(record, child_record);
-
-            unfolded.set(child_id, true);
         }
 
         this.record_remove(record);
+
+        const next = record.link_next;
+
+        ActivePatchRecord.pool_release(record);
+
+        return next;
     }
 
     /**
@@ -150,36 +154,6 @@ export class ActivePatchList {
         this.record_remove(b);
     }
 
-    /**
-     *
-     * @param {ActivePatchRecord} record
-     * @param {RefinementSpec} spec
-     */
-    node_try_merge(record, spec) {
-        const next = record.link_next;
-        if (next === null) {
-            // no next record
-            return;
-        }
-
-        return;
-
-        const parent = record.patch.parent;
-
-        if (parent !== next.patch.parent) {
-            // not a sibling
-            return;
-        }
-
-        const patch_screen_area = compute_projected_area(parent.bounding_box, spec);
-
-        const approximate_triangle_area = patch_screen_area * approximateTriangleArea(parent);
-
-        if (approximate_triangle_area <= spec.error_threshold) {
-            this.node_merge(record, next);
-        }
-
-    }
 
     /**
      * Populate with LOD-X of a given geometry
@@ -210,7 +184,13 @@ export class ActivePatchList {
      */
     refine(spec) {
 
-        for (let record = this.records; record !== null; record = record.link_next) {
+        const frustum_planes = spec.frustum_f32;
+        const projection_matrix = spec.projection_matrix;
+        const error_threshold = spec.error_threshold_normalized;
+
+        let record = this.records
+
+        for (; record !== null;) {
 
             const node = record.patch;
 
@@ -221,32 +201,17 @@ 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, spec.frustum_f32);
+            const in_view_frustum = aabb3_intersects_frustum(node.bounding_box, frustum_planes);
 
             if (!in_view_frustum) {
                 // outside of view frustum, cull
                 if (prev_is_visible) {
                     record.clearFlag(ActivePatchFlags.Visible);
                 }
+                record = record.link_next;
                 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);
             }
@@ -264,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 = compute_projected_area(node.group_bounding_box_corners, spec);
+                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) {
+                if (screen_space_error > error_threshold) {
                     // error too large, needs to be split
-                    this.node_split(record);
+                    record = this.node_split(record);
                     continue;
                 }
             }
 
-
-            // 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/ActivePatchRecord.js

@@ -60,8 +60,6 @@ export class ActivePatchRecord {
         patch_pool_size--;
 
         // reset record
-        r.link_next = null;
-
         r.flags = 0;
 
         return r;
@@ -91,6 +89,10 @@ export class ActivePatchRecord {
      * @param {ActivePatchRecord} r
      */
     static pool_release_all(r) {
+        if (r === null) {
+            return;
+        }
+
         let p = r;
 
         for (; patch_pool_size < patch_limit;) {

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/buffer/buffers/prototypeNormalFrameBuffer.js

@@ -50,8 +50,6 @@ import { enableEditor } from "../../../../../editor/enableEditor.js";
 import EntityBuilder from "../../../../ecs/EntityBuilder.js";
 import { Transform } from "../../../../ecs/transform/Transform.js";
 import Mesh from "../../../ecs/mesh/Mesh.js";
-import ViewportPosition from "../../../../ecs/gui/position/ViewportPosition.js";
-import GUIElement from "../../../../ecs/gui/GUIElement.js";
 import { CopyShader } from "three/examples/jsm/shaders/CopyShader.js";
 import {
     DoubleSide,
@@ -64,11 +62,11 @@ import {
     UniformsUtils,
     WebGLRenderTarget
 } from "three";
-import { buildCubeURLs } from "../../../GraphicsEngine.js";
 import { AmbientOcclusionPostProcessEffect } from "../simple-fx/ao/AmbientOcclusionPostProcessEffect.js";
 import { PathDisplaySystem } from "../../../ecs/path/PathDisplaySystem.js";
 import { MicronRenderPlugin } from "../../../micron/plugin/MicronRenderPlugin.js";
 import { StandardFrameBuffers } from "../../../StandardFrameBuffers.js";
+import { buildCubeURLs } from "../../../texture/cubemap/buildCubeURLs.js";
 
 const engineHarness = new EngineHarness();
 
@@ -386,13 +384,13 @@ function main(engine) {
     //     .build(ecd);
 
     // const canvasView = makeCameraClippingDebug(engine);
-
-    new EntityBuilder()
-        .add(ViewportPosition.fromJSON({
-            offset: new Vector2(10, 10)
-        }))
-        .add(GUIElement.fromView(canvasView))
-        .build(ecd);
+    //
+    // new EntityBuilder()
+    //     .add(ViewportPosition.fromJSON({
+    //         offset: new Vector2(10, 10)
+    //     }))
+    //     .add(GUIElement.fromView(canvasView))
+    //     .build(ecd);
 
 
 }

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

@@ -11,15 +11,13 @@ import { compute_light_data_hash_0 } from "./cluster/compute_light_data_hash_0.j
 import { read_plane_pair } from "./cluster/read_plane_pair.js";
 import { read_frustum_planes_to_array } from "./cluster/read_frustum_planes_to_array.js";
 import { compute_cluster_planes_from_points } from "./cluster/compute_cluster_planes_from_points.js";
-import {
-    computeDataType,
-    computeThreeTextureInternalFormatFromDataType,
-    computeThreeTextureTypeFromDataType,
-    NumericType,
-    TextureBackedMemoryRegion
-} from "./TextureBackedMemoryRegion.js";
+import { TextureBackedMemoryRegion } from "./data/TextureBackedMemoryRegion.js";
 import { assert } from "../../../../core/assert.js";
 import { DataType2TypedArrayConstructorMapping } from "../../../../core/collection/table/DataType2TypedArrayConstructorMapping.js";
+import { NumericType } from "./data/NumericType.js";
+import { computeDataType } from "./data/computeDataType.js";
+import { computeThreeTextureTypeFromDataType } from "./data/computeThreeTextureTypeFromDataType.js";
+import { computeThreeTextureInternalFormatFromDataType } from "./data/computeThreeTextureInternalFormatFromDataType.js";
 
 const LOOKUP_CACHE_SIZE = 16384; // must be power of two
 /**

package/engine/graphics/render/forward_plus/data/NumericType.js

@@ -0,0 +1,9 @@
+/**
+ *
+ * @enum {number}
+ */
+export const NumericType = {
+    Uint: 0,
+    Int: 1,
+    Float: 2
+};