@woosh/meep-engine 2.43.20 → 2.43.22

package/core/geom/3d/topology/struct/bt_index_geometry_to_topology.js

@@ -0,0 +1,329 @@
+import { HashMap } from "../../../../collection/HashMap.js";
+import { split_by_2 } from "../../morton/mortonEncode_magicbits.js";
+import { NULL_POINTER } from "./BinaryTopology.js";
+
+
+/**
+ * Populates supplied topology with data from supplied indexed geometry
+ * @see https://github.com/blender/blender/blob/9cb061f4f0119e647173e7d354e1457e97632333/source/blender/blenkernel/intern/mesh_calc_edges.cc
+ * @see https://github.com/blender/blender/blob/9cb061f4f0119e647173e7d354e1457e97632333/source/blender/io/stl/importer/stl_import_mesh.cc#L63
+ * @param {BinaryTopology} out
+ * @param {number[]} indices
+ * @param {number[]} vertex_positions
+ * @param {number[]} [vertex_normals]
+ */
+export function bt_index_geometry_to_topology(
+    out,
+    indices,
+    vertex_positions,
+    vertex_normals
+) {
+
+    // remove any existing data
+    out.clear();
+
+    /*
+    NOTES:
+        - we use {@link BinaryElementPool#allocate_continuous} to avoid having to allocate additional mapping structure
+     */
+
+    // ingest all vertices
+    const vertex_count = vertex_positions.length / 3;
+
+    const vertex_allocation_offset = out.vertices.allocate_continuous(vertex_count);
+
+    for (let i = 0; i < vertex_count; i++) {
+        const i3 = i * 3;
+
+        const vertex_id = i + vertex_allocation_offset;
+
+        out.vertex_write_coordinate(vertex_id, vertex_positions, i3);
+
+        if (vertex_normals !== undefined) {
+            out.vertex_write_normal(vertex_id, vertex_normals, i3);
+        }
+
+        // initialize edge to NULL
+        out.vertex_write_edge(vertex_id, NULL_POINTER);
+    }
+
+    const face_count = indices.length / 3;
+
+    // reserve some memory to avoid extra allocations
+    out.loops.ensure_capacity(face_count * 3);
+    out.edges.ensure_capacity(face_count * 1.6);
+
+    // create faces
+    const face_allocation_offset = out.faces.allocate_continuous(face_count);
+
+    /**
+     *
+     * @type {HashMap<OrderedEdge, number>}
+     */
+    const edge_hash_map = new HashMap({
+        capacity: Math.ceil(1 + 2.1 * face_count)
+    });
+
+    for (let i = 0; i < face_count; i++) {
+        const i3 = i * 3;
+
+        const a = indices[i3];
+        const b = indices[i3 + 1];
+        const c = indices[i3 + 2];
+
+        const vertex_a = a + vertex_allocation_offset;
+        const vertex_b = b + vertex_allocation_offset;
+        const vertex_c = c + vertex_allocation_offset;
+
+        const face_id = i + face_allocation_offset;
+
+        // create edges
+        const edge_ab = get_or_create_edge(vertex_a, vertex_b, edge_hash_map, out);
+        const edge_bc = get_or_create_edge(vertex_b, vertex_c, edge_hash_map, out);
+        const edge_ca = get_or_create_edge(vertex_c, vertex_a, edge_hash_map, out);
+
+        // allocate loops
+        const loop_a = out.loop_create();
+        const loop_b = out.loop_create();
+        const loop_c = out.loop_create();
+
+        // write loops
+        out.loop_write_vertex(loop_a, vertex_a);
+        out.loop_write_vertex(loop_b, vertex_b);
+        out.loop_write_vertex(loop_c, vertex_c);
+
+        // link loops to edges
+        link_loop_to_edge(loop_a, edge_ab, out);
+        link_loop_to_edge(loop_b, edge_bc, out);
+        link_loop_to_edge(loop_c, edge_ca, out);
+
+        out.loop_write_face(loop_a, face_id);
+        out.loop_write_face(loop_b, face_id);
+        out.loop_write_face(loop_c, face_id);
+
+        /*
+        NOTE: Vertices (#BMLoop.v & #BMLoop.next.v) always contain vertices from (#BMEdge.v1 & #BMEdge.v2).
+         */
+        // link up loops around the face
+        out.loop_write_next(loop_a, loop_b);
+        out.loop_write_prev(loop_a, loop_c);
+
+        out.loop_write_next(loop_b, loop_c);
+        out.loop_write_prev(loop_b, loop_a);
+
+        out.loop_write_next(loop_c, loop_a);
+        out.loop_write_prev(loop_c, loop_b);
+
+        // update face
+        out.face_write_loop(face_id, loop_a);
+
+    }
+}
+
+/**
+ * follow the pointer list to the end along radial list
+ * @param {number} start_loop
+ * @param {BinaryTopology} mesh
+ * @returns {number}
+ */
+function loop_radial_get_last(start_loop, mesh) {
+    let prev_loop = start_loop;
+    let next_loop;
+
+    while ((next_loop = mesh.loop_read_radial_next(prev_loop)) !== NULL_POINTER) {
+        prev_loop = next_loop;
+    }
+
+    return prev_loop;
+}
+
+/**
+ *
+ * @param {number} loop_id
+ * @param {number} edge_id
+ * @param {BinaryTopology} mesh
+ */
+function link_loop_to_edge(loop_id, edge_id, mesh) {
+    mesh.loop_write_edge(loop_id, edge_id);
+
+    /**
+     * First loop attached to the edge
+     * @type {number}
+     */
+    const edge_loop_start = mesh.edge_read_loop(edge_id);
+
+    if (edge_loop_start === NULL_POINTER) {
+        // no loops connected yet
+        mesh.edge_write_loop(edge_id, loop_id);
+    } else {
+        // connect loop to the end of the list
+        const last_loop_in_list = loop_radial_get_last(edge_loop_start, mesh);
+
+        mesh.loop_write_radial_next(last_loop_in_list, loop_id);
+        mesh.loop_write_radial_prev(loop_id, last_loop_in_list);
+    }
+
+}
+
+/**
+ * @see https://github.com/blender/blender/blob/9cb061f4f0119e647173e7d354e1457e97632333/source/blender/blenkernel/intern/mesh_calc_edges.cc#L209
+ * @param {BinaryTopology} mesh
+ */
+function bt_mesh_calc_edges(mesh) {
+    /**
+     *
+     * @type {HashMap<OrderedEdge, unknown>}
+     */
+    const map = new HashMap();
+
+    add_polygon_edges_to_map(mesh, map);
+}
+
+class OrderedEdge {
+    /**
+     *
+     * @param {number} v1
+     * @param {number} v2
+     */
+    constructor(v1, v2) {
+        if (v1 < v2) {
+            this.v_low = v1;
+            this.v_high = v2;
+        } else {
+            this.v_low = v2;
+            this.v_high = v1;
+        }
+    }
+
+    /**
+     *
+     * @param {number} v1
+     * @param {number} v2
+     */
+    set(v1, v2) {
+        if (v1 < v2) {
+            this.v_low = v1;
+            this.v_high = v2;
+        } else {
+            this.v_low = v2;
+            this.v_high = v1;
+        }
+    }
+
+    /**
+     *
+     * @param {OrderedEdge} other
+     */
+    copy(other) {
+        this.v_low = other.v_low;
+        this.v_high = other.v_high;
+    }
+
+    clone() {
+        return new OrderedEdge(this.v_low, this.v_high);
+    }
+
+    /**
+     *
+     * @return {number}
+     */
+    hash() {
+        return split_by_2(this.v_low) | (split_by_2(this.v_high) << 1);
+    }
+
+    /**
+     *
+     * @param {OrderedEdge} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return this.v_low === other.v_low
+            && this.v_high === other.v_high
+            ;
+    }
+}
+
+/**
+ * @see https://github.com/blender/blender/blob/9cb061f4f0119e647173e7d354e1457e97632333/source/blender/blenkernel/intern/mesh_calc_edges.cc#L96
+ * @param {BinaryTopology} mesh
+ * @param {HashMap<OrderedEdge,*>} edge_map
+ */
+function add_polygon_edges_to_map(mesh, edge_map) {
+
+    const faces = mesh.faces;
+    const face_count = faces.size;
+
+    for (let i = 0; i < face_count; i++) {
+        if (!faces.is_allocated(i)) {
+            continue;
+        }
+
+        const first_loop = mesh.face_read_loop(i);
+        let prev_loop = first_loop + j;
+
+        for (let j = 0; j < 3; j++) {
+            const loop = first_loop + j;
+
+
+            const prev_v = mesh.loop_read_vertex(prev_loop);
+            const next_v = mesh.loop_read_vertex(loop);
+
+            const edge = new OrderedEdge(prev_v, next_v);
+
+            edge_map.getOrSet(edge, null);
+
+            prev_loop = loop;
+        }
+    }
+
+}
+
+/**
+ *
+ * @param {number} v0
+ * @param {number} v1
+ * @param {HashMap<OrderedEdge,number>} map
+ * @param {BinaryTopology} mesh
+ */
+function get_or_create_edge(v0, v1, map, mesh) {
+    const scratch_ordered_edge = new OrderedEdge(v0, v1);
+
+    const existing = map.get(scratch_ordered_edge);
+
+    if (existing !== undefined) {
+        return existing;
+    }
+
+    // doesn't exist - create
+    const edge_id = mesh.edges.allocate();
+
+    mesh.edge_write_vertex1(edge_id, v0);
+    mesh.edge_write_vertex2(edge_id, v1);
+
+    // initialize rest of the edge
+    mesh.edge_write_loop(edge_id, NULL_POINTER);
+
+    // TODO process disk_link pointers for the edge
+
+    map.set(scratch_ordered_edge, edge_id);
+
+    return edge_id;
+}
+
+
+/**
+ * Ensure an edge between two vertices
+ * NOTE: works without having to use a separate hash map, resulting in faster execution and smaller RAM requirement
+ * @param {number} v0
+ * @param {number} v1
+ * @param {BinaryTopology} mesh
+ */
+function get_or_create_edge_2(v0, v1, mesh) {
+    const first_edge = mesh.vertex_read_edge(v0);
+
+    // iterate over all edges around the vertex
+
+    // if match is found - return the match, else create a new edge and assign
+
+    // TODO implement
+}

package/core/geom/3d/topology/struct/bt_index_geometry_to_topology.spec.js

@@ -0,0 +1,26 @@
+import { bt_index_geometry_to_topology } from "./bt_index_geometry_to_topology.js";
+import { BinaryTopology } from "./BinaryTopology.js";
+
+test('Empty geometry work as expected', () => {
+    const mesh = new BinaryTopology();
+    bt_index_geometry_to_topology(mesh, [], []);
+
+    expect(mesh.faces.size).toBe(0);
+    expect(mesh.vertices.size).toBe(0);
+    expect(mesh.edges.size).toBe(0);
+    expect(mesh.loops.size).toBe(0);
+});
+
+test('Single triangle', () => {
+    const mesh = new BinaryTopology();
+    bt_index_geometry_to_topology(mesh, [0, 1, 2], [
+        1, 3, 7,
+        11, 13, 17,
+        23, 27, -1
+    ]);
+
+    expect(mesh.faces.size).toBe(1);
+    expect(mesh.loops.size).toBe(3);
+    expect(mesh.edges.size).toBe(3);
+    expect(mesh.vertices.size).toBe(3);
+});

package/core/geom/3d/topology/struct/prototypeBinaryTopology.js

@@ -0,0 +1,55 @@
+import { PLYLoader } from "three/examples/jsm/loaders/PLYLoader.js";
+import { noop } from "../../../../function/Functions.js";
+import { bt_index_geometry_to_topology } from "./bt_index_geometry_to_topology.js";
+import { BinaryTopology } from "./BinaryTopology.js";
+import {
+    compute_buffer_geometry_byte_size
+} from "../../../../../engine/graphics/geometry/buffered/compute_buffer_geometry_byte_size.js";
+import { prettyPrint } from "../../../../NumberFormat.js";
+import { TopoMesh } from "./TopoMesh.js";
+
+function promise_ply(url) {
+
+    return new Promise((resolve, reject) => {
+        new PLYLoader().load(url, resolve, noop, reject);
+    });
+}
+
+
+async function main() {
+
+    // const url = "data/models/stanford/Lucy100k.ply";
+    const url = "data/models/stanford/dragon_recon/dragon_vrip.ply";
+    const lucy_geom = await promise_ply(url);
+
+    const mesh = new BinaryTopology();
+
+    const positions_array = lucy_geom.getAttribute('position').array;
+    const index_array = lucy_geom.getIndex().array;
+
+
+    const topoMesh = new TopoMesh();
+
+    console.time('topo build - obj');
+    topoMesh.build(positions_array, index_array);
+    console.timeEnd('topo build - obj');
+
+    // console.time('topo build - bin');
+    console.profile('topo build - bin');
+    bt_index_geometry_to_topology(mesh, index_array, positions_array);
+    console.profileEnd('topo build - bin');
+    // console.timeEnd('topo build - bin');
+
+    mesh.trim();
+
+    console.log(mesh, lucy_geom);
+
+    console.log(`source mesh size: ${prettyPrint(compute_buffer_geometry_byte_size(lucy_geom))} bytes`);
+    console.log(`binary topology size: ${prettyPrint(mesh.byteSize)} bytes`);
+    console.log(`object topology size: ${prettyPrint(topoMesh.byteSize)} bytes`);
+
+    window.topo_obj = topoMesh;
+}
+
+main();
+

package/engine/graphics/ecs/mesh-v2/aggregate/SGMeshHighlightSystem.js

@@ -16,12 +16,21 @@ export class SGMeshHighlightSystem extends System {
      * @param {number} entity
      * @private
      */
-    __apply_highlight( event, entity) {
+    __apply_highlight(event, entity) {
         const ecd = this.entityManager.dataset;
 
         const sg_mesh = ecd.getComponent(entity, SGMesh);
+
+        if (sg_mesh === undefined) {
+            return;
+        }
+
         const highlight = ecd.getComponent(entity, Highlight);
 
+        if (highlight === undefined) {
+            return;
+        }
+
         const node = sg_mesh.__node;
 
         node.traverse(t => {
@@ -35,7 +44,7 @@ export class SGMeshHighlightSystem extends System {
      * @param {number} entity
      * @private
      */
-    __remove_highlight( event, entity) {
+    __remove_highlight(event, entity) {
 
         const ecd = this.entityManager.dataset;
 
@@ -56,7 +65,7 @@ export class SGMeshHighlightSystem extends System {
      */
     link(highlight, mesh, entity) {
         if (mesh.__node !== null) {
-            this.__apply_highlight(undefined,  entity);
+            this.__apply_highlight(undefined, entity);
         }
 
         const ecd = this.entityManager.dataset;

package/engine/graphics/micron/format/MicronGeometryPatch.d.ts

@@ -1,3 +1,3 @@
 export class MicronGeometryPatch {
-
+    allocate_metadata(buffer: ArrayBuffer, offset: number): number
 }

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

@@ -35,7 +35,7 @@ export class MicronGeometryPatch {
         this.group_bounding_box = null;
 
         /**
-         *
+         * TODO get rid of this, use bounding box instead for smaller memory footprint
          * @type {number[]|Float32Array}
          */
         this.group_bounding_box_corners = null;
@@ -124,6 +124,7 @@ export class MicronGeometryPatch {
      * @returns {number}
      */
     allocate_metadata(buffer, offset) {
+        assert.isNonNegativeInteger(offset, 'offset');
         assert.greaterThanOrEqual(buffer.byteLength, offset + 144, 'buffer underflow');
 
         this.bounding_box = new Float32Array(buffer, offset, 6);

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

@@ -56,14 +56,13 @@ function ensureProxy(object) {
     }
 }
 
-export class GLTFAssetTransformer extends AssetTransformer {
+class TransformContext {
     /**
      *
-     * @param {AbstractAsyncMap<THREE.BufferGeometry, MicronGeometry>} [cache]
+     * @param {AssetManager} assetManager
+     * @param {AbstractAsyncMap<THREE.BufferGeometry, MicronGeometry>} cache
      */
-    constructor(cache) {
-        super();
-
+    constructor(assetManager, cache) {
         /**
          *
          * @type {AbstractAsyncMap<THREE.BufferGeometry, MicronGeometry>|undefined}
@@ -71,20 +70,6 @@ export class GLTFAssetTransformer extends AssetTransformer {
          */
         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 {MicronGeometry[]}
@@ -92,31 +77,54 @@ export class GLTFAssetTransformer extends AssetTransformer {
          */
         this.__active_mesh_micron_cache = [];
 
-        /**
-         * @deprecated
-         * Whether override mesh will be created for the asset, this is generally outdated
-         * @type {boolean}
-         * @private
-         */
-        this.__settings_build_override_mesh = false;
+        this.__am = assetManager;
     }
 
     /**
      *
-     * @param {AssetManager|null} am
+     * @param {{userData:{}}} gltf
+     * @param {AssetDescription} ad
      */
-    set assetManager(am) {
-        this.__am = am;
-    }
+    async load_mesh_micron_data(gltf, ad) {
+        // clear active cache
+        this.__active_mesh_micron_cache = [];
 
+        const micron_metadata = gltf.userData.micron;
+
+        if (micron_metadata === undefined) {
+            return;
+        }
+
+        const uri = micron_metadata.geometry_data_uri;
+        if (uri === undefined) {
+            return;
+        }
+
+        const base = computePathDirectory(ad.path);
+
+        let micron_data;
+
+        const micron_path = `${base}/${uri}`;
+
+        try {
+            micron_data = await this.__am.promise(micron_path, ASSET_TYPE_ARRAY_BUFFER, { skip_queue: true });
+        } 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());
+
+        deserialize_geometry_collection(this.__active_mesh_micron_cache, buffer);
+    }
 
     /**
      * @param {THREE.Object3D} object
      * @param {{asset:AssetDescription}} ctx
      * @return {Promise<void>}
-     * @private
      */
-    async __visitObjectToLoadMicron(object, ctx) {
+    async visitObjectToLoadMicron(object, ctx) {
         if (!object.isMesh) {
             return;
         }
@@ -150,46 +158,59 @@ export class GLTFAssetTransformer extends AssetTransformer {
         }
     }
 
+}
 
+export class GLTFAssetTransformer extends AssetTransformer {
     /**
      *
-     * @param {{userData:{}}} gltf
-     * @param {AssetDescription} ad
-     * @private
+     * @param {AbstractAsyncMap<THREE.BufferGeometry, MicronGeometry>} [cache]
      */
-    async __load_mesh_micron_data(gltf, ad) {
-        // clear active cache
-        this.__active_mesh_micron_cache = [];
-
-        const micron_metadata = gltf.userData.micron;
-
-        if (micron_metadata === undefined) {
-            return;
-        }
-
-        const uri = micron_metadata.geometry_data_uri;
-        if (uri === undefined) {
-            return;
-        }
-
-        const base = computePathDirectory(ad.path);
+    constructor(cache) {
+        super();
 
-        let micron_data;
+        /**
+         *
+         * @type {AbstractAsyncMap<THREE.BufferGeometry, MicronGeometry>|undefined}
+         * @private
+         */
+        this.__cache = cache;
 
-        const micron_path = `${base}/${uri}`;
+        /**
+         *
+         * @type {AssetManager|null}
+         * @private
+         */
+        this.__am = null;
 
-        try {
-            micron_data = await this.__am.promise(micron_path, ASSET_TYPE_ARRAY_BUFFER, { skip_queue: true });
-        } catch (e) {
-            console.error(`Failed to load micron geometry '${micron_path}' referenced in GLTF (will skip): ${e}`);
-            return;
-        }
+        /**
+         * Minimum number of polygons required for micron to be used
+         * @type {number}
+         * @private
+         */
+        this.__threshold_polycount = DEFAULT_THRESHOLD_POLYCOUNT;
 
-        // deserialize micron data
-        const buffer = BinaryBuffer.fromArrayBuffer(micron_data.create());
+        /**
+         *
+         * @type {MicronGeometry[]}
+         * @private
+         */
+        this.__active_mesh_micron_cache = [];
 
-        deserialize_geometry_collection(this.__active_mesh_micron_cache, buffer);
+        /**
+         * @deprecated
+         * Whether override mesh will be created for the asset, this is generally outdated
+         * @type {boolean}
+         * @private
+         */
+        this.__settings_build_override_mesh = false;
+    }
 
+    /**
+     *
+     * @param {AssetManager|null} am
+     */
+    set assetManager(am) {
+        this.__am = am;
     }
 
 
@@ -212,10 +233,12 @@ export class GLTFAssetTransformer extends AssetTransformer {
          */
         const root = source.create();
 
-        await this.__load_mesh_micron_data(source.gltf, asset_description);
+        const context = new TransformContext(this.__am, this.__cache);
+
+        await context.load_mesh_micron_data(source.gltf, asset_description);
 
         // attempt to load existing micron geometries
-        await async_traverse_three_object(root, this.__visitObjectToLoadMicron, this, {
+        await async_traverse_three_object(root, context.visitObjectToLoadMicron, context, {
             asset: asset_description
         });
 
@@ -227,6 +250,8 @@ export class GLTFAssetTransformer extends AssetTransformer {
         }
 
         if (this.__settings_build_override_mesh) {
+            console.warn(`Deprecated OVERRIDE_MESH setting is ON, generating override mesh for asset: ${asset_description}`);
+
             const micron_root = await convert_three_object_to_micron(root.clone(), this.__cache);
             micron_root.boundingSphere = root.boundingSphere;
 

package/engine/graphics/sh3/path_tracer/PathTracedMesh.js

@@ -54,6 +54,10 @@ export class PathTracedMesh {
         this.__local_scale_inverse = Math.hypot(scale_x, scale_y, scale_z);
     }
 
+    get transform() {
+        return this.__transform;
+    }
+
     /**
      *
      * @param {number[]} out