@woosh/meep-engine 2.34.44 → 2.34.48

package/engine/graphics/ecs/mesh-v2/sample/prototypeShadedGeometry.js

@@ -4,6 +4,15 @@ import EntityBuilder from "../../../../ecs/EntityBuilder.js";
 import { Transform } from "../../../../ecs/transform/Transform.js";
 import { ShadedGeometry } from "../ShadedGeometry.js";
 import { BoxBufferGeometry, MeshBasicMaterial } from "three";
+import { randomFloatBetween } from "../../../../../core/math/random/randomFloatBetween.js";
+import { seededRandom } from "../../../../../core/math/random/seededRandom.js";
+import ViewportPosition from "../../../../ecs/gui/position/ViewportPosition.js";
+import GUIElement from "../../../../ecs/gui/GUIElement.js";
+import ButtonView from "../../../../../view/elements/button/ButtonView.js";
+import { downloadAsFile } from "../../../../../core/binary/ByteArrayTools.js";
+import { convert_bvh_to_dot_format_string } from "../../../../../core/bvh2/visual/convert_bvh_to_dot_format_string.js";
+import ViewportPositionSystem from "../../../../ecs/gui/position/ViewportPositionSystem.js";
+import GUIElementSystem from "../../../../ecs/gui/GUIElementSystem.js";
 
 const eh = new EngineHarness();
 
@@ -26,22 +35,68 @@ async function main(engine) {
         color: 0xFFFFFF
     });
 
-    material.visible = false;
+    // material.visible = false;
 
     window.material = material;
 
-    const g = ShadedGeometry.from(new BoxBufferGeometry(), material);
+    const geometry = new BoxBufferGeometry();
 
+    const random = seededRandom(0);
+
+    for (let i = 0; i < 100000; i++) {
+
+        new EntityBuilder()
+            .add(Transform.fromJSON({
+                position: {
+                    x: randomFloatBetween(random, -50, 50),
+                    y: randomFloatBetween(random, 0, 10),
+                    z: randomFloatBetween(random, -50, 50)
+                },
+                scale: 0.01
+            }))
+            .add(ShadedGeometry.from(geometry, material))
+            .build(ecd);
+    }
+
+    debug_button(engine, () => {
+        const dot = convert_bvh_to_dot_format_string(engine.graphics.layers.getLayerByName('shaded-geometry').bvh);
+        downloadAsFile(dot, 'bvh.dot', 'text');
+
+    }, 'save dot file');
+
+}
+
+
+const entityManager = engine.entityManager;
+
+/**
+ *
+ * @param {Engine} engine
+ * @param {function} action
+ * @param {string} [name]
+ * @param {EntityComponentDataset} ecd
+ */
+function debug_button(engine, action, name = "Button", ecd = entityManager.dataset) {
+    if (entityManager.getSystem(ViewportPositionSystem) === null) {
+        entityManager.addSystem(new ViewportPositionSystem(engine.graphics.viewport.size));
+    }
+
+    if (entityManager.getSystem(GUIElementSystem) === null) {
+        entityManager.addSystem(new GUIElementSystem(engine.gui.view, engine));
+    }
 
     new EntityBuilder()
-        .add(Transform.fromJSON({
-            position: {
-                x: 10,
-                y: 1,
-                z: 10
+        .add(ViewportPosition.fromJSON({}))
+        .add(GUIElement.fromView(new ButtonView({
+            action,
+            name,
+            css: {
+                background: 'rgba(255,255,255,0.8)',
+                border: '1px solid black',
+                borderRadius: '4px',
+                padding: '2px',
             }
-        }))
-        .add(g)
+        })))
         .build(ecd);
 }
 

package/engine/graphics/micron/build/buildMicronGeometryFromBufferGeometry.js

@@ -15,6 +15,7 @@ import { compute_buffer_geometry_byte_size } from "../../geometry/buffered/compu
 import { deinterleaveBufferGeometry } from "../../geometry/buffered/deinterleaveBufferGeometry.js";
 import { AABB3 } from "../../../../core/bvh2/aabb3/AABB3.js";
 import { aabb3_from_v3_array } from "../../../../core/bvh2/aabb3/aabb3_from_v3_array.js";
+import { update_topo_face_normals } from "../../../../core/geom/3d/topology/update_topo_face_normals.js";
 
 /**
  * Returns current time in milliseconds
@@ -142,6 +143,9 @@ export async function buildMicronGeometryFromBufferGeometry(input) {
 
     expandConnectivityByLocality(topoMesh, geometry_aabb);
 
+    // ensure faces have normals for mesh simplification
+    update_topo_face_normals(Array.from(topoMesh.getFaces()), topoMesh.getFaces().size);
+
     /**
      * Used to generate neighbourhood assignment
      * @type {Map<number, PatchRepresentation>}

package/engine/graphics/micron/build/hierarchy/merge_patches.js

@@ -399,7 +399,6 @@ async function many_to_many_merge(
         collapse_edges(
             num_desired_faces_to_remove,
             open_set,
-            [],
             merged_mesh,
             edge_to_collapse_map,
             vertex_quadratics,
@@ -462,6 +461,7 @@ async function many_to_many_merge(
     // );
 
     const group_per_pixel_error = group_inverse_polycount;
+    // const group_per_pixel_error = Math.sqrt(largest_squared_error);
 
     // split topology into desired number of pieces
     const pieces = recursive_split_mesh_partition(merged_mesh, actual_up_count, MICRON_PATCH_SIZE_MAX);

package/engine/graphics/micron/convert_three_object_to_micron.js

@@ -76,6 +76,8 @@ export async function convert_three_object_to_micron(object, micron_cache = defa
 
         await micron_cache.set(g, micron_geometry);
 
+        // console.log(micron_geometry);
+
         return micron_geometry;
     }
 

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

@@ -226,11 +226,9 @@ export class MicronGeometry {
                     }
 
                     // push to stack
-                    stack[stack_cursor] = child;
+                    stack[stack_cursor++] = child;
 
                     included_set.set(child.id, true);
-
-                    stack_cursor++;
                 }
             }
         }

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

@@ -48,7 +48,6 @@ import { CanvasView } from "../../../view/elements/CanvasView.js";
 import { Sampler2D } from "../texture/sampler/Sampler2D.js";
 import { downsampleSampler2D } from "../texture/sampler/downsampleSampler2D.js";
 import { ShadowMapRenderer } from "../shadows/ShadowMapRenderer.js";
-import { MouseEvents } from "../../input/devices/events/MouseEvents.js";
 import { mat4 } from "gl-matrix";
 
 const background = new TextureLoader().load('data/textures/utility/checkers_white_grey_256x256.png');
@@ -262,8 +261,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();
 
@@ -460,14 +459,15 @@ 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();
     // sample_gltf_broken_isiflow();
     // gltf_grid('data/models/moicon/Kople/EVCharger1.gltf');
     // gltf_grid('data/models/RTS_Buildings_Humans/18/Building_R_18_out/Building_R_18.gltf');
-    // gltf_sample('data/models/moicon/08-clickable-assets/model.gltf');
-    // gltf_sample('data/models/moicon/05-ground-floor/model.gltf');
+    // gltf_sample('moicon/08-clickable-assets/model.gltf');
+    // gltf_sample('moicon/05-ground-floor/model.gltf');
     // gltf_sample('data/models/moicon/isiflow_Oct_15_21/0/model.gltf');
     // gltf_sample('moicon/29_Dec_2021_Nammo/1/model.gltf');
     // gltf_sample('moicon/29_Dec_2021_Nammo/1-onematerial/model.gltf');
@@ -479,6 +479,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', 3, 3);
 
     document.addEventListener("mousemove", onDocumentMouseMove);
 
@@ -546,6 +548,7 @@ function onWindowResize() {
  * @param {number} scale
  */
 function createScene(geometry, m1, scale) {
+
     geometry.computeVertexNormals();
 
 
@@ -798,7 +801,7 @@ function render() {
     // console.log(`patches:${active_patches.length}, polycount:${polycount}`);
 }
 
-window.document.body.addEventListener(MouseEvents.Move, ({ clientX, clientY }) => {
+const raycast_handler = ({ clientX, clientY }) => {
     const direction = new Vector3();
 
     const viewport_size = new Vector2();
@@ -858,5 +861,7 @@ window.document.body.addEventListener(MouseEvents.Move, ({ clientX, clientY }) =
     if (hits.length > 0) {
         console.log(`HITS: ${hits.map(JSON.stringify).join(',')}`);
     }
-});
+};
+
+// window.document.body.addEventListener(MouseEvents.Move, raycast_handler);
 

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

@@ -1,10 +1,9 @@
 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";
 
 /**
  * @readonly
@@ -125,7 +124,6 @@ export class VirtualGeometryBuilder {
                 // get acl
                 const acl = this.__acl;
 
-                acl.initializeFromGeometry(micron_geometry);
 
                 this.buildForMesh(
                     object.instance_id,
@@ -159,7 +157,6 @@ export class VirtualGeometryBuilder {
         transform,
         apl
     ) {
-
         refinement_spec.build(transform, this.view_projection_matrix);
 
         const output = this.output;
@@ -168,48 +165,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 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;
 
+        const added_patch_count = get_geometry_patch_cut(
+            output_patches,
+            output.patch_count,
+            refinement_spec,
+            geometry,
+            instance_id,
+            transform
+        );
 
-        // TODO sort patches based on camera distance to better utilize z-culling in hardware
+        output.patch_count += added_patch_count;
     }
 
     clearScene() {
@@ -239,7 +207,6 @@ export class VirtualGeometryBuilder {
         // clear output
         this.output.clear();
 
-        this.__info_enforced_node_splits = 0;
 
         const n = this.input_scene_length;
         const input_objects = this.input_scene;

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

@@ -194,8 +194,6 @@ export class ActivePatchList {
 
             const node = record.patch;
 
-            // check if record needs to be split
-            const prev_is_visible = record.getFlag(ActivePatchFlags.Visible);
 
             /*
              check if node is in view frustum
@@ -205,16 +203,11 @@ export class ActivePatchList {
 
             if (!in_view_frustum) {
                 // outside of view frustum, cull
-                if (prev_is_visible) {
-                    record.clearFlag(ActivePatchFlags.Visible);
-                }
                 record = record.link_next;
                 continue;
             }
 
-            if (!prev_is_visible) {
-                record.setFlag(ActivePatchFlags.Visible);
-            }
+            record.setFlag(ActivePatchFlags.Visible);
 
             /*
              scale error to projection space:
@@ -224,6 +217,7 @@ export class ActivePatchList {
              */
 
 
+            // check if record needs to be split
             if (node.lod > 0) {
 
                 // not the lowest level of LOD, see if subdivision might be necessary