@woosh/meep-engine 2.33.4 → 2.33.5

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;
     }
 
     /**
@@ -181,7 +186,9 @@ export class ActivePatchList {
 
         const frustum_planes = spec.frustum_f32;
 
-        for (let record = this.records; record !== null; record = record.link_next) {
+        let record = this.records
+
+        for (; record !== null;) {
 
             const node = record.patch;
 
@@ -200,6 +207,7 @@ export class ActivePatchList {
                 if (prev_is_visible) {
                     record.clearFlag(ActivePatchFlags.Visible);
                 }
+                record = record.link_next;
                 continue;
             }
 
@@ -241,11 +249,11 @@ export class ActivePatchList {
 
                 if (screen_space_error > spec.error_threshold_normalized) {
                     // error too large, needs to be split
-                    this.node_split(record);
+                    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) {

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/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 { 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";
 
 /**
  * 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() {

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

@@ -0,0 +1,16 @@
+import { RedIntegerFormat, RGBAIntegerFormat, RGBIntegerFormat, RGIntegerFormat } from "three";
+
+export 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}'`);
+    }
+}

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

@@ -0,0 +1,36 @@
+import { NumericType } from "./NumericType.js";
+import { DataType } from "../../../../../core/collection/table/DataType.js";
+
+/**
+ *
+ * @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`);
+}

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

@@ -0,0 +1,18 @@
+import { NumericType } from "./NumericType.js";
+import { channelCountToThreIntegerTextureType } from "./channelCountToThreIntegerTextureType.js";
+import { channelCountToThreeTextureFormat } from "../../../texture/channelCountToThreeTextureFormat.js";
+
+/**
+ *
+ * @param {NumericType} type
+ * @param {number} channel_count
+ */
+export 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}'`);
+    }
+}

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

@@ -0,0 +1,63 @@
+import { DataType } from "../../../../../core/collection/table/DataType.js";
+
+/**
+ *
+ * @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;
+}

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

@@ -0,0 +1,41 @@
+import { DataType } from "../../../../../core/collection/table/DataType.js";
+import {
+    ByteType,
+    FloatType,
+    HalfFloatType,
+    IntType,
+    ShortType,
+    UnsignedByteType,
+    UnsignedIntType,
+    UnsignedShortType
+} from "three";
+
+/**
+ *
+ * @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}'`);
+    }
+}

package/engine/graphics/render/forward_plus/plugin/ptototypeFPPlugin.js

@@ -45,7 +45,6 @@ import { SerializationMetadataSystem } from "../../../../ecs/systems/Serializati
 import { InverseKinematicsSystem } from "../../../../ecs/animation/InverseKinematicsSystem.js";
 import { PathDisplaySystem } from "../../../ecs/path/PathDisplaySystem.js";
 import { Line, LineBasicMaterial, MeshStandardMaterial, TorusKnotBufferGeometry } from "three";
-import { buildCubeURLs } from "../../../GraphicsEngine.js";
 import RenderSystem from "../../../../ecs/systems/RenderSystem.js";
 import { makeEngineOptionsModel } from "../../../../../../model/game/options/makeEngineOptionsModel.js";
 import { enableEditor } from "../../../../../editor/enableEditor.js";
@@ -77,6 +76,7 @@ import { GameAssetType } from "../../../../asset/GameAssetType.js";
 import { GLTFAssetLoader } from "../../../../asset/loaders/GLTFAssetLoader.js";
 import { ImageRGBADataLoader } from "../../../../asset/loaders/image/ImageRGBADataLoader.js";
 import { MicronRenderPlugin } from "../../../micron/plugin/MicronRenderPlugin.js";
+import { buildCubeURLs } from "../../../texture/cubemap/buildCubeURLs.js";
 
 const engineHarness = new EngineHarness();