@woosh/meep-engine 2.34.45 → 2.34.49

package/engine/graphics/micron/format/MicronGeometryPatch.js

@@ -1,6 +1,6 @@
-import { squirrel3 } from "../../../../core/math/hash/squirrel3.js";
 import { ConicRay } from "../../../../core/geom/ConicRay.js";
 import { vec4 } from "gl-matrix";
+import { assert } from "../../../../core/assert.js";
 
 /**
  * Patches are organized into a tree hierarchy
@@ -13,18 +13,11 @@ export class MicronGeometryPatch {
          */
         this.id = 0;
 
-        /**
-         * Continuous memory region for various pieces of data to get better memory access patterns
-         * All pieces of data end up in a continuous piece of memory, resulting in better cache coherence
-         * @type {ArrayBuffer}
-         */
-        const array_buffer = new ArrayBuffer((6 + 6 + 24) * 4);
-
         /**
          * Bounds are used to determine screen error and whether a patch should be subdivided or not for rendering
          * @type {number[]}
          */
-        this.bounding_box = new Float32Array(array_buffer, 0, 6);
+        this.bounding_box = null;
 
         /**
          *
@@ -36,13 +29,21 @@ export class MicronGeometryPatch {
          *
          * @type {number[]|Float32Array}
          */
-        this.group_bounding_box = new Float32Array(array_buffer, 6 * 4, 6);
+        this.group_bounding_box = null;
 
         /**
          *
          * @type {number[]|Float32Array}
          */
-        this.group_bounding_box_corners = new Float32Array(array_buffer, 12 * 4, 24);
+        this.group_bounding_box_corners = null;
+
+        /**
+         * Continuous memory region for various pieces of data to get better memory access patterns
+         * All pieces of data end up in a continuous piece of memory, resulting in better cache coherence
+         * @type {ArrayBuffer}
+         */
+        const array_buffer = new ArrayBuffer(144);
+        this.allocate_metadata(array_buffer, 0);
 
         /**
          *
@@ -114,21 +115,25 @@ export class MicronGeometryPatch {
     }
 
     /**
-     * @deprecated
+     *
+     * @param {ArrayBuffer} buffer
+     * @param {number} offset
+     * @returns {number}
      */
-    get parent() {
-        throw new Error('Single parent is no longer supported, use .parents instead');
-    }
+    allocate_metadata(buffer, offset) {
+        assert.greaterThanOrEqual(buffer.byteLength, offset + 144, 'buffer underflow');
 
-    /**
-     * @deprecated
-     */
-    set parent(v) {
-        throw new Error('Single parent is no longer supported, use .parents instead');
+        this.bounding_box = new Float32Array(buffer, offset, 6);
+
+        this.group_bounding_box = new Float32Array(buffer, offset + 24, 6);
+
+        this.group_bounding_box_corners = new Float32Array(buffer, offset + 48, 24);
+
+        return 144;
     }
 
     hash() {
-        return squirrel3(this.id);
+        return this.id;
     }
 
     computeByteSize() {
@@ -136,8 +141,13 @@ export class MicronGeometryPatch {
 
         result += this.face_indices.buffer.byteLength;
 
-        for (let i = 0; i < this.vertex_attribute_arrays.length; i++) {
-            result += this.vertex_attribute_arrays[i].buffer.byteLength;
+        const attribute_arrays = this.vertex_attribute_arrays;
+        const attribute_count = attribute_arrays.length;
+
+        for (let i = 0; i < attribute_count; i++) {
+            const attribute_array = attribute_arrays[i];
+
+            result += attribute_array.buffer.byteLength;
         }
 
         return result;

package/engine/graphics/micron/format/serialization/MicronGeometryBinarySerializationAdapter.js

@@ -79,12 +79,18 @@ export class MicronGeometryBinarySerializationAdapter extends BinaryClassSeriali
 
         const patches = [];
 
+        // for the sake of speed, we will allocate all metadata in the same piece of memory to make traversal of patch hierarchy faster
+        const md_buffer = new ArrayBuffer(patch_count * 144);
+        let md_buffer_offset = 0;
+
         // build initial patches
         for (let i = 0; i < patch_count; i++) {
             const patch = new MicronGeometryPatch();
 
             patch.id = i;
 
+            md_buffer_offset += patch.allocate_metadata(md_buffer, md_buffer_offset);
+
             patches[i] = patch;
         }
 

package/engine/graphics/micron/plugin/GLTFAssetTransformer.js

@@ -0,0 +1,176 @@
+import { AssetTransformer } from "../../../asset/AssetTransformer.js";
+import { MicronGeometryBinarySerializationAdapter } from "../format/serialization/MicronGeometryBinarySerializationAdapter.js";
+import { MICRON_URI_FIELD } from "../MICRON_URI_FIELD.js";
+import { computePathDirectory } from "../../../../core/FilePath.js";
+import { BinaryBuffer } from "../../../../core/binary/BinaryBuffer.js";
+import { MicronGeometry } from "../format/MicronGeometry.js";
+import { MICRON_GEOMETRY_FIELD } from "../MICRON_GEOMETRY_FIELD.js";
+import { async_traverse_three_object } from "../../../asset/loaders/async_traverse_three_object.js";
+import { convert_three_object_to_micron } from "../convert_three_object_to_micron.js";
+import { compute_geometry_polycount } from "../../compute_geometry_polycount.js";
+import { traverseThreeObject } from "../../ecs/highlight/renderer/traverseThreeObject.js";
+import { max2 } from "../../../../core/math/max2.js";
+
+export const ASSET_TYPE_ARRAY_BUFFER = "arraybuffer";
+
+const DEFAULT_THRESHOLD_POLYCOUNT = 1024;
+
+/**
+ *
+ * @param {THREE.Object3D} object
+ * @return {number}
+ */
+function max_polycount(object) {
+    let r = 0;
+
+    traverseThreeObject(object, (m) => {
+        if (m.isMesh) {
+            const geo = m.geometry;
+            if (geo !== null) {
+                r = max2(r, compute_geometry_polycount(geo))
+            }
+        }
+    });
+
+    return r;
+}
+
+export class GLTFAssetTransformer extends AssetTransformer {
+    /**
+     *
+     * @param {AbstractAsyncMap<THREE.BufferGeometry, MicronGeometry>} cache
+     */
+    constructor(cache) {
+        super();
+
+        /**
+         *
+         * @type {AbstractAsyncMap<THREE.BufferGeometry, MicronGeometry>}
+         * @private
+         */
+        this.__cache = cache;
+
+        /**
+         *
+         * @type {AssetManager|null}
+         * @private
+         */
+        this.__am = null;
+
+        /**
+         * Minimum number of polygons required for micron to be used
+         * @type {number}
+         * @private
+         */
+        this.__threshold_polycount = DEFAULT_THRESHOLD_POLYCOUNT;
+
+        /**
+         *
+         * @type {MicronGeometryBinarySerializationAdapter}
+         * @private
+         */
+        this.__serde = new MicronGeometryBinarySerializationAdapter();
+    }
+
+    /**
+     *
+     * @param {AssetManager|null} am
+     */
+    set assetManager(am) {
+        this.__am = am;
+    }
+
+
+    /**
+     * @param {THREE.Object3D} object
+     * @param {{asset:AssetDescription}} ctx
+     * @return {Promise<void>}
+     * @private
+     */
+    async __visitObjectToLoadMicron(object, ctx) {
+        if (!object.isMesh) {
+            return;
+        }
+
+        /**
+         * @type {THREE.BufferGeometry}
+         */
+        const geometry = object.geometry;
+
+        const micron_uri = geometry.userData[MICRON_URI_FIELD];
+
+        if (typeof micron_uri !== "string") {
+            return;
+        }
+
+
+        /**
+         * @type {AssetDescription}
+         */
+        const ad = ctx.asset;
+
+        const base = computePathDirectory(ad.path);
+
+        let micron_data;
+
+        const micron_path = `${base}/${micron_uri}`;
+
+        try {
+            micron_data = await this.__am.promise(micron_path, ASSET_TYPE_ARRAY_BUFFER);
+        } catch (e) {
+            console.error(`Failed to load micron geometry '${micron_path}' referenced in GLTF (will skip): ${e}`);
+            return;
+        }
+
+        // deserialize micron data
+        const buffer = BinaryBuffer.fromArrayBuffer(micron_data.create());
+        const micron_geometry = new MicronGeometry();
+
+        this.__serde.deserialize(buffer, micron_geometry);
+
+        // set proxy for raycasting
+        micron_geometry.proxy = geometry;
+
+        geometry[MICRON_GEOMETRY_FIELD] = micron_geometry;
+    }
+
+
+    /**
+     *
+     * @param {Asset} source
+     * @param {AssetDescription} asset_description
+     * @return {Promise<Asset>}
+     */
+    async transform(source, asset_description) {
+        const animationClips = source.animations;
+
+        if (animationClips !== undefined && animationClips.length > 0) {
+            // animations might cause trouble
+            console.warn(`model '${asset_description.path}' contains animations, these animations might not works as intended with micron.`);
+        }
+
+        /**
+         * @type {THREE.Object3D}
+         */
+        const root = source.create();
+
+        const gltf_max_polycount = max_polycount(root);
+
+        if (gltf_max_polycount < this.__threshold_polycount) {
+            // no change, geometries are too small
+            return source;
+        }
+
+        // attempt to load existing micron geometries
+        await async_traverse_three_object(root, this.__visitObjectToLoadMicron, this, {
+            asset: asset_description
+        });
+
+        const micron_root = await convert_three_object_to_micron(root.clone(), this.__cache);
+        micron_root.boundingSphere = root.boundingSphere;
+
+        source.override_mesh = micron_root;
+
+        return source;
+    }
+}

package/engine/graphics/micron/plugin/MicronRenderPlugin.js

@@ -2,8 +2,6 @@ import { EnginePlugin } from "../../../plugin/EnginePlugin.js";
 import { VGThreeRenderer } from "../render/v1/VGThreeRenderer.js";
 import { RenderLayer } from "../../render/layers/RenderLayer.js";
 import { RenderPassType } from "../../render/RenderPassType.js";
-import { AssetTransformer } from "../../../asset/AssetTransformer.js";
-import { convert_three_object_to_micron } from "../convert_three_object_to_micron.js";
 import { Cache } from "../../../../core/cache/Cache.js";
 import { computeGeometryHash } from "../../../asset/loaders/geometry/geometry/computeGeometryHash.js";
 import { computeGeometryEquality } from "../../../asset/loaders/geometry/geometry/computeGeometryEquality.js";
@@ -12,13 +10,9 @@ import { AsyncRemoteHashMap } from "../../../../core/collection/map/AsyncRemoteH
 import { BufferGeometrySerializationAdapter } from "./serialization/BufferGeometrySerializationAdapter.js";
 import { MicronGeometryBinarySerializationAdapter } from "../format/serialization/MicronGeometryBinarySerializationAdapter.js";
 import { AsyncMapWrapper } from "../../../../core/collection/map/AsyncMapWrapper.js";
-import { async_traverse_three_object } from "../../../asset/loaders/async_traverse_three_object.js";
-import { computePathDirectory } from "../../../../core/FilePath.js";
-import { BinaryBuffer } from "../../../../core/binary/BinaryBuffer.js";
 import { MicronGeometry } from "../format/MicronGeometry.js";
 import { ArrayBufferLoader } from "../../../asset/loaders/ArrayBufferLoader.js";
-import { MICRON_URI_FIELD } from "../MICRON_URI_FIELD.js";
-import { MICRON_GEOMETRY_FIELD } from "../MICRON_GEOMETRY_FIELD.js";
+import { ASSET_TYPE_ARRAY_BUFFER, GLTFAssetTransformer } from "./GLTFAssetTransformer.js";
 
 /**
  *
@@ -26,134 +20,6 @@ import { MICRON_GEOMETRY_FIELD } from "../MICRON_GEOMETRY_FIELD.js";
  */
 const STORAGE_KEY = '@plugin/virtual-geometry-micron/geometry-cache';
 
-const ASSET_TYPE_ARRAY_BUFFER = "arraybuffer";
-
-class GLTFAssetTransformer extends AssetTransformer {
-    /**
-     *
-     * @param {AbstractAsyncMap<THREE.BufferGeometry, MicronGeometry>} cache
-     */
-    constructor(cache) {
-        super();
-
-        /**
-         *
-         * @type {AbstractAsyncMap<THREE.BufferGeometry, MicronGeometry>}
-         * @private
-         */
-        this.__cache = cache;
-
-        /**
-         *
-         * @type {AssetManager|null}
-         * @private
-         */
-        this.__am = null;
-
-        /**
-         *
-         * @type {MicronGeometryBinarySerializationAdapter}
-         * @private
-         */
-        this.__serde = new MicronGeometryBinarySerializationAdapter();
-    }
-
-    /**
-     *
-     * @param {AssetManager|null} am
-     */
-    set assetManager(am) {
-        this.__am = am;
-    }
-
-
-    /**
-     * @param {THREE.Object3D} object
-     * @param {{asset:AssetDescription}} ctx
-     * @return {Promise<void>}
-     * @private
-     */
-    async __visitObjectToLoadMicron(object, ctx) {
-        if (!object.isMesh) {
-            return;
-        }
-
-        /**
-         * @type {THREE.BufferGeometry}
-         */
-        const geometry = object.geometry;
-
-        const micron_uri = geometry.userData[MICRON_URI_FIELD];
-
-        if (typeof micron_uri !== "string") {
-            return;
-        }
-
-
-        /**
-         * @type {AssetDescription}
-         */
-        const ad = ctx.asset;
-
-        const base = computePathDirectory(ad.path);
-
-        let micron_data;
-
-        const micron_path = `${base}/${micron_uri}`;
-
-        try {
-            micron_data = await this.__am.promise(micron_path, ASSET_TYPE_ARRAY_BUFFER);
-        } catch (e) {
-            console.error(`Failed to load micron geometry '${micron_path}' referenced in GLTF (will skip): ${e}`);
-            return;
-        }
-
-        // deserialize micron data
-        const buffer = BinaryBuffer.fromArrayBuffer(micron_data.create());
-        const micron_geometry = new MicronGeometry();
-
-        this.__serde.deserialize(buffer, micron_geometry);
-
-        // set proxy for raycasting
-        micron_geometry.proxy = geometry;
-
-        geometry[MICRON_GEOMETRY_FIELD] = micron_geometry;
-    }
-
-
-    /**
-     *
-     * @param {Asset} source
-     * @param {AssetDescription} asset_description
-     * @return {Promise<Asset>}
-     */
-    async transform(source, asset_description) {
-        const animationClips = source.animations;
-
-        if (animationClips !== undefined && animationClips.length > 0) {
-            // animations might cause trouble
-            console.warn(`model '${asset_description.path}' contains animations, these animations might not works as intended with micron.`);
-        }
-
-        /**
-         * @type {THREE.Object3D}
-         */
-        const root = source.create();
-
-        // attempt to load existing micron geometries
-        await async_traverse_three_object(root, this.__visitObjectToLoadMicron, this, {
-            asset: asset_description
-        });
-
-        const micron_root = await convert_three_object_to_micron(root.clone(), this.__cache);
-        micron_root.boundingSphere = root.boundingSphere;
-
-        source.override_mesh = micron_root;
-
-        return source;
-    }
-}
-
 export class MicronRenderPlugin extends EnginePlugin {
     constructor() {
         super();

package/engine/graphics/micron/prototypeVirtualGeometry.js

@@ -1,10 +1,8 @@
 import {
     AmbientLight,
     BoxBufferGeometry,
-    CameraHelper,
     CubeTextureLoader,
     DirectionalLight,
-    DirectionalLightHelper,
     FrontSide,
     Matrix4,
     Mesh,
@@ -64,6 +62,10 @@ metrics.create({
     name: 'adapter_update', buffer_size: METRIC_BUFFER_SIZE
 });
 
+metrics.create({
+    name: 'debug_v0', buffer_size: METRIC_BUFFER_SIZE
+});
+
 let container, stats;
 
 let camera, scene, renderer;
@@ -261,8 +263,8 @@ function init() {
 
     // shadow_camera.onBeforeRender = do_vgrt_update;
 
-    scene.add(new CameraHelper(shadow_camera));
-    scene.add(new DirectionalLightHelper(directionalLight));
+    // scene.add(new CameraHelper(shadow_camera));
+    // scene.add(new DirectionalLightHelper(directionalLight));
 
     shadow_camera.updateProjectionMatrix();
 
@@ -459,7 +461,7 @@ function init() {
 
     // sample_gltf_sponza();
     // gltf_sample('data/models/RTS_Buildings_Humans/18/Building_R_18_out/Building_R_18.gltf');
-    sample_lucy();
+    // sample_lucy();
     // sample_dragon();
     // sample_gltf_hapro_2();
     // sample_gltf_hapro_1();
@@ -479,6 +481,8 @@ function init() {
     // gltf_sample('moicon/03_Jan_22_Demo/8-assets/model.gltf');
     // gltf_sample('moicon/03_Jan_22_Demo/worker_test/model.gltf');
     // gltf_sample('moicon/A4/A4/model.gltf');
+    gltf_sample('moicon/ztest_object_many_pieces/model.gltf');
+    // gltf_grid('moicon/ztest_object_many_pieces/model.gltf', 10, 10);
 
     document.addEventListener("mousemove", onDocumentMouseMove);
 

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

@@ -1,10 +1,10 @@
 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";
+import { get_geometry_patch_cut } from "./refinement/get_geometry_patch_cut.js";
+import { traverseThreeObject } from "../../ecs/highlight/renderer/traverseThreeObject.js";
 
 /**
  * @readonly
@@ -107,7 +107,7 @@ export class VirtualGeometryBuilder {
     }
 
     /**
-     *
+     * @private
      * @param {THREE.Object3D|ThreeMicronMesh} object
      */
     buildForObject(object) {
@@ -134,15 +134,6 @@ export class VirtualGeometryBuilder {
                 );
             }
         }
-
-        const children = object.children;
-        const children_count = children.length;
-
-        for (let i = 0; i < children_count; i++) {
-            const child = children[i];
-
-            this.buildForObject(child);
-        }
     }
 
     /**
@@ -158,8 +149,6 @@ export class VirtualGeometryBuilder {
         transform,
         apl
     ) {
-        apl.initializeFromGeometry(geometry);
-
         refinement_spec.build(transform, this.view_projection_matrix);
 
         const output = this.output;
@@ -168,48 +157,19 @@ export class VirtualGeometryBuilder {
         output.stats_source_triangle_count += geometry.source_triangle_count;
         output.stats_source_vertex_count += geometry.source_vertex_count;
 
-        // apl.build_from_lod(geometry, 0);
-        apl.refine(refinement_spec);
-
         // build up occurances
         const output_patches = output.patches;
-        let output_patch_cursor = output.patch_count;
-        let patch_instance;
-
-        const geometry_id = geometry.id;
 
-        for (
-            let record = apl.records;
-            record !== null;
-            record = record.link_next
-        ) {
-
-            if (!record.getFlag(ActivePatchFlags.Visible)) {
-                // patch is not visible, skip
-                continue;
-            }
+        const added_patch_count = get_geometry_patch_cut(
+            output_patches,
+            output.patch_count,
+            refinement_spec,
+            geometry,
+            instance_id,
+            transform
+        );
 
-            const patch = record.patch;
-            patch_instance = output_patches[output_patch_cursor];
-
-            if (patch_instance === undefined) {
-                // no instance available for reuse - create a new one
-                patch_instance = new MicronGeometryPatchOccurrence();
-                output_patches[output_patch_cursor] = patch_instance;
-            }
-
-            patch_instance.instance_id = instance_id;
-            patch_instance.geometry_id = geometry_id;
-            patch_instance.patch = patch;
-            patch_instance.transform = transform;
-
-            output_patch_cursor++;
-        }
-
-        output.patch_count = output_patch_cursor;
-
-
-        // TODO sort patches based on camera distance to better utilize z-culling in hardware
+        output.patch_count += added_patch_count;
     }
 
     clearScene() {
@@ -243,10 +203,11 @@ export class VirtualGeometryBuilder {
         const n = this.input_scene_length;
         const input_objects = this.input_scene;
 
+
         for (let i = 0; i < n; i++) {
             const object3D = input_objects[i];
 
-            this.buildForObject(object3D);
+            traverseThreeObject(object3D, this.buildForObject, this);
         }
 
 

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

@@ -50,17 +50,6 @@ export class RefinementSpec {
          * @type {Float32Array}
          */
         this.frustum_f32 = new Float32Array(array_buffer, 64, 24);
-
-
-        /**
-         * Object-space camera position
-         * @type {Float32Array}
-         */
-        this.view_position = new Float32Array(3);
-    }
-
-    get frustum() {
-        throw new Error('deprecated, use .frustum_f32 instead');
     }
 
     /**