@woosh/meep-engine 2.33.4 → 2.33.9

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

@@ -4,21 +4,6 @@ import { aabb3_project_to_2d } from "../../../../../core/geom/3d/aabb/aabb3_comp
 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() {
         /**
@@ -38,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;
     }
 
     /**
@@ -45,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;
@@ -61,6 +60,7 @@ export class ActivePatchList {
     /**
      *
      * @param {ActivePatchRecord} record
+     * @returns {ActivePatchRecord}
      */
     node_split(record) {
 
@@ -73,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;
     }
 
     /**
@@ -180,8 +185,12 @@ 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
 
-        for (let record = this.records; record !== null; record = record.link_next) {
+        for (; record !== null;) {
 
             const node = record.patch;
 
@@ -192,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, frustum_planes);
+            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);
             }
@@ -235,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
-                    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
+};

package/engine/graphics/render/forward_plus/{TextureBackedMemoryRegion.js → data/TextureBackedMemoryRegion.js}

@@ -1,36 +1,14 @@
-import {
-    ByteType,
-    DataTexture,
-    FloatType,
-    HalfFloatType,
-    IntType,
-    NearestFilter,
-    RedFormat,
-    RedIntegerFormat,
-    RGBAIntegerFormat,
-    RGBIntegerFormat,
-    RGIntegerFormat,
-    ShortType,
-    UnsignedByteType,
-    UnsignedIntType,
-    UnsignedShortType
-} from "three";
-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 { channelCountToThreeTextureFormat } from "../../texture/channelCountToThreeTextureFormat.js";
-import { DataTypeByteSizes } from "../../../../core/collection/table/RowFirstTableSpec.js";
-
-/**
- *
- * @enum {number}
- */
-export const NumericType = {
-    Uint: 0,
-    Int: 1,
-    Float: 2
-};
+import { DataTexture, NearestFilter, RedFormat, UnsignedByteType } from "three";
+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 { 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
@@ -42,163 +20,6 @@ const SHRINK_FACTOR = 0.5;
 const GROW_FACTOR = 1.05;
 
 
-/**
- *
- * @param {NumericType} type
- * @param {number} precision
- * @returns {DataType}
- */
-export function computeDataType(type, precision) {
-    if (type === NumericType.Uint) {
-        if (precision <= 8) {
-            return DataType.Uint8;
-        } else if (precision <= 16) {
-            return DataType.Uint16;
-        } else if (precision <= 32) {
-            return DataType.Uint32;
-        }
-    } else if (type === NumericType.Int) {
-        if (precision <= 8) {
-            return DataType.Int8;
-        } else if (precision <= 16) {
-            return DataType.Int16;
-        } else if (precision <= 32) {
-            return DataType.Int32;
-        }
-    } else if (type === NumericType.Float) {
-        if (precision <= 32) {
-            return DataType.Float32;
-        } else if (precision <= 64) {
-            return DataType.Float64;
-        }
-    }
-
-    throw new Error(`Unsupported numeric type(=${type}) and precision(=${precision}) combination`);
-}
-
-/**
- *
- * @param {DataType} dt
- * @returns {number}
- */
-export function computeThreeTextureTypeFromDataType(dt) {
-    switch (dt) {
-        case DataType.Uint8:
-            return UnsignedByteType;
-        case DataType.Uint16:
-            return UnsignedShortType;
-        case DataType.Uint32:
-            return UnsignedIntType;
-        case DataType.Int8:
-            return ByteType;
-        case DataType.Int16:
-            return ShortType;
-        case DataType.Int32:
-            return IntType;
-        case DataType.Float16:
-            return HalfFloatType;
-        case DataType.Float32:
-            return FloatType;
-        case DataType.Float64:
-            return FloatType;
-        default:
-            throw new Error(`Unsupported data type '${dt}'`);
-    }
-}
-
-
-/**
- *
- * @param {DataType} dt
- * @param {number} channel_count
- * @returns {string|THREE.PixelFormatGPU}
- */
-export function computeThreeTextureInternalFormatFromDataType(dt, channel_count) {
-    let suffix = '';
-    switch (dt) {
-        case DataType.Uint8:
-            suffix = '8UI';
-            break;
-        case DataType.Uint16:
-            suffix = '16UI';
-            break;
-        case DataType.Uint32:
-            suffix = '32UI';
-            break;
-        case DataType.Int8:
-            suffix = '8I';
-            break;
-        case DataType.Int16:
-            suffix = '16I';
-            break;
-        case DataType.Int32:
-            suffix = '32I';
-            break;
-        case DataType.Float16:
-            suffix = '16F';
-            break;
-        case DataType.Float32:
-            suffix = '32F';
-            break;
-        case DataType.Float64:
-            suffix = '64F';
-            break;
-        default:
-            throw new Error(`Unsupported data type '${dt}'`);
-    }
-
-    let prefix = '';
-
-    switch (channel_count) {
-        case 1:
-            prefix = 'R';
-            break;
-        case 2:
-            prefix = 'RG';
-            break;
-        case 3:
-            prefix = 'RGB';
-            break;
-        case 4:
-            prefix = 'RGBA';
-            break;
-        default:
-            throw new Error(`Unsupported channel count '${channel_count}'`);
-    }
-
-    return prefix + suffix;
-}
-
-function channelCountToThreIntegerTextureType(channel_count) {
-    switch (channel_count) {
-        case 1:
-            return RedIntegerFormat;
-        case 2:
-            return RGIntegerFormat;
-        case 3:
-            return RGBIntegerFormat;
-        case 4:
-            return RGBAIntegerFormat;
-        default:
-            throw new Error(`Unsupported channel count '${channel_count}'`);
-    }
-}
-
-/**
- *
- * @param {NumericType} type
- * @param {number} channel_count
- */
-function computeThreeTextureFormat(type, channel_count) {
-    if (type === NumericType.Uint || type === NumericType.Int) {
-        return channelCountToThreIntegerTextureType(channel_count);
-    } else if (type === NumericType.Float) {
-        return channelCountToThreeTextureFormat(channel_count);
-    } else {
-        throw new Error(`Unsupported numeric type '${type}'`);
-    }
-}
-
 export class TextureBackedMemoryRegion {
 
     constructor() {