@woosh/meep-engine 2.43.21 → 2.43.23

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

@@ -0,0 +1,188 @@
+import { NULL_POINTER } from "../BinaryTopology.js";
+import { create_edge } from "./create_edge.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;
+
+    // create faces
+    const face_allocation_offset = out.faces.allocate_continuous(face_count);
+
+    // reserve some memory to avoid extra allocations
+    out.loops.ensure_capacity(face_count * 3);
+    out.edges.ensure_capacity(face_count * 1.6);
+
+    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_2(vertex_a, vertex_b, out);
+        const edge_bc = get_or_create_edge_2(vertex_b, vertex_c, out);
+        const edge_ca = get_or_create_edge_2(vertex_c, vertex_a, 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);
+
+    }
+}
+
+/**
+ *
+ * @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 existing_loop = mesh.edge_read_loop(edge_id);
+
+    if (existing_loop === NULL_POINTER) {
+        // no loops connected yet
+        mesh.edge_write_loop(edge_id, loop_id);
+
+
+    } else {
+        // insert loop between existing loop and the next one
+        const next = mesh.loop_read_radial_next(existing_loop);
+
+        mesh.loop_write_radial_next(existing_loop, loop_id);
+        mesh.loop_write_radial_prev(next, loop_id);
+
+        mesh.loop_write_radial_next(loop_id, next);
+        mesh.loop_write_radial_prev(loop_id, existing_loop);
+    }
+
+}
+
+
+/**
+ * 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);
+
+    if (first_edge !== NULL_POINTER) {
+
+        // iterate over all edges around the vertex
+        let edge = first_edge;
+
+        do {
+            const edge_v1 = mesh.edge_read_vertex1(edge);
+            const edge_v2 = mesh.edge_read_vertex2(edge);
+
+            if (edge_v1 === v1 || edge_v2 === v1) {
+                // found edge that connects between v0 and v1
+                return edge;
+            }
+
+            if (edge_v1 === v0) {
+                edge = mesh.edge_read_v1_disk_next(edge);
+            } else if (edge_v2 === v0) {
+                edge = mesh.edge_read_v2_disk_next(edge);
+            } else {
+                // invalid edge connection
+                throw new Error('Invalid edge, not connected to first vertex');
+            }
+
+        } while (edge !== first_edge);
+
+    }
+
+    // if match is found - return the match, else create a new edge and assign
+
+    return create_edge(mesh, v0, v1);
+}

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

@@ -0,0 +1,84 @@
+import { bt_index_geometry_to_topology } from "./bt_index_geometry_to_topology.js";
+import { BinaryTopology } from "../BinaryTopology.js";
+import { bt_mesh_edge_has_vertex } from "../query/bt_mesh_edge_has_vertex.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);
+
+    // validate loops
+    for (let loop_id = 0; loop_id < 3; loop_id++) {
+        const face = mesh.loop_read_face(loop_id);
+        expect(face).toEqual(0);
+
+        const loop_next = mesh.loop_read_next(loop_id);
+        expect(loop_next).not.toEqual(loop_id);
+        expect(mesh.loop_read_prev(loop_next)).toEqual(loop_id);
+
+        const loop_prev = mesh.loop_read_prev(loop_id);
+        expect(loop_prev).not.toEqual(loop_id);
+        expect(mesh.loop_read_next(loop_prev)).toEqual(loop_id);
+
+        expect(loop_prev).not.toEqual(loop_next);
+
+        // should loop around
+        expect(mesh.loop_read_next(loop_next)).toEqual(loop_prev);
+        expect(mesh.loop_read_prev(loop_prev)).toEqual(loop_next);
+    }
+
+
+    // validate edges
+    for (let edge_id = 0; edge_id < 3; edge_id++) {
+        const v1 = mesh.edge_read_vertex1(edge_id);
+        const v2 = mesh.edge_read_vertex2(edge_id);
+
+        // different vertices
+        expect(v1).not.toEqual(v2);
+
+        // validate disk links
+        const disk_v1_next = mesh.edge_read_v1_disk_next(edge_id);
+
+        expect(disk_v1_next).not.toEqual(edge_id);
+
+        expect(bt_mesh_edge_has_vertex(mesh, disk_v1_next, v1)).toBe(true);
+
+        const disk_v1_prev = mesh.edge_read_v1_disk_prev(edge_id);
+
+        expect(disk_v1_prev).not.toEqual(edge_id);
+
+        expect(bt_mesh_edge_has_vertex(mesh, disk_v1_prev, v1)).toBe(true);
+
+        const disk_v2_next = mesh.edge_read_v2_disk_next(edge_id);
+
+        expect(disk_v2_next).not.toEqual(edge_id);
+
+        expect(bt_mesh_edge_has_vertex(mesh, disk_v2_next, v2)).toBe(true);
+
+        const disk_v2_prev = mesh.edge_read_v2_disk_prev(edge_id);
+
+        expect(disk_v2_prev).not.toEqual(edge_id);
+
+        expect(bt_mesh_edge_has_vertex(mesh, disk_v2_prev, v2)).toBe(true);
+
+    }
+
+});

package/core/geom/3d/topology/struct/binary/io/bt_mesh_calc_edges.js

@@ -0,0 +1,51 @@
+import { OrderedEdge } from "./OrderedEdge.js";
+import { HashMap } from "../../../../../../collection/HashMap.d.ts";
+
+/**
+ * @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);
+}
+
+/**
+ * @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;
+        }
+    }
+
+}

package/core/geom/3d/topology/struct/binary/io/create_edge.js

@@ -0,0 +1,106 @@
+import { NULL_POINTER } from "../BinaryTopology.js";
+
+/**
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} edge_from
+ * @param {number} edge_to
+ * @param {number} vertex
+ */
+function edge_link_disk_forward(mesh, edge_from, edge_to, vertex) {
+    const from_v1 = mesh.edge_read_vertex1(edge_from);
+
+    let displaced_edge;
+
+    if (from_v1 === vertex) {
+        displaced_edge = mesh.edge_read_v1_disk_next(edge_from);
+
+        mesh.edge_write_v1_disk_next(edge_from, edge_to);
+
+    } else {
+        displaced_edge = mesh.edge_read_v2_disk_next(edge_from);
+
+        mesh.edge_write_v2_disk_next(edge_from, edge_to);
+    }
+
+    return displaced_edge;
+}
+
+function edge_link_disk_back(mesh, edge_from, edge_to, vertex) {
+    const from_v1 = mesh.edge_read_vertex1(edge_from);
+
+    let displaced_edge;
+
+    if (from_v1 === vertex) {
+        displaced_edge = mesh.edge_read_v1_disk_prev(edge_from);
+
+        mesh.edge_write_v1_disk_prev(edge_from, edge_to);
+
+    } else {
+        displaced_edge = mesh.edge_read_v2_disk_prev(edge_from);
+
+        mesh.edge_write_v2_disk_prev(edge_from, edge_to);
+    }
+
+    return displaced_edge;
+}
+
+/**
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} edge_source anchor edge, new edge is inserted after this one
+ * @param {number} edge_new edge that is being introduced
+ * @param {number} vertex
+ */
+function edge_link_disk(mesh, edge_source, edge_new, vertex) {
+    const forward_link = edge_link_disk_forward(mesh, edge_source, edge_new, vertex);
+    edge_link_disk_forward(mesh, edge_new, forward_link, vertex);
+
+    edge_link_disk_back(mesh, forward_link, edge_new, vertex);
+    edge_link_disk_back(mesh, edge_new, edge_source, vertex);
+}
+
+/**
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} v0
+ * @param {number} v1
+ * @return {number}
+ */
+export function create_edge(mesh, v0, v1) {
+    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);
+
+    // process disk links
+    const first_v0_edge = mesh.vertex_read_edge(v0);
+
+    if (first_v0_edge !== NULL_POINTER) {
+        edge_link_disk(mesh, first_v0_edge, edge_id, v0);
+    } else {
+        // no edges attached yet, attach this one as the first
+        mesh.vertex_write_edge(v0, edge_id);
+        // link to self
+        mesh.edge_write_v1_disk_next(edge_id, edge_id);
+        mesh.edge_write_v1_disk_prev(edge_id, edge_id);
+    }
+
+    const first_v1_edge = mesh.vertex_read_edge(v1);
+
+    if (first_v1_edge !== NULL_POINTER) {
+
+        edge_link_disk(mesh, first_v1_edge, edge_id, v1);
+
+    } else {
+        // no edges attached yet, attach this one as the first
+        mesh.vertex_write_edge(v1, edge_id);
+        // link to self
+        mesh.edge_write_v2_disk_next(edge_id, edge_id);
+        mesh.edge_write_v2_disk_prev(edge_id, edge_id);
+    }
+    return edge_id;
+}

package/core/geom/3d/topology/struct/binary/io/get_or_create_edge_map.js

@@ -0,0 +1,26 @@
+import { OrderedEdge } from "./OrderedEdge.js";
+import { create_edge } from "./create_edge.js";
+
+/**
+ *
+ * @param {number} v0
+ * @param {number} v1
+ * @param {HashMap<OrderedEdge,number>} map
+ * @param {BinaryTopology} mesh
+ */
+function get_or_create_edge_map(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 = create_edge(mesh, v0, v1);
+
+    map.set(scratch_ordered_edge, edge_id);
+
+    return edge_id;
+}

package/core/geom/3d/topology/struct/binary/query/bt_mesh_edge_has_vertex.js

@@ -0,0 +1,16 @@
+/**
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} edge_id
+ * @param {number} vertex_id
+ * @returns {boolean}
+ */
+export function bt_mesh_edge_has_vertex(mesh, edge_id, vertex_id) {
+    const v1 = mesh.edge_read_vertex1(edge_id);
+
+    if (v1 === vertex_id) {
+        return true;
+    }
+
+    return mesh.edge_read_vertex2(edge_id) === vertex_id;
+}

package/core/geom/3d/topology/struct/binary/query/bt_mesh_edge_has_vertex.spec.js

@@ -0,0 +1,15 @@
+import { BinaryTopology } from "../BinaryTopology.js";
+import { bt_mesh_edge_has_vertex } from "./bt_mesh_edge_has_vertex.js";
+
+test('main', () => {
+    const mesh = new BinaryTopology();
+
+    const edge = mesh.edges.allocate();
+
+    mesh.edge_write_vertex1(edge, 7);
+    mesh.edge_write_vertex2(edge, 3);
+
+    expect(bt_mesh_edge_has_vertex(mesh, edge, 7)).toBe(true);
+    expect(bt_mesh_edge_has_vertex(mesh, edge, 3)).toBe(true);
+    expect(bt_mesh_edge_has_vertex(mesh, edge, 1)).toBe(false);
+});

package/core/geom/3d/topology/struct/binary/query/bt_mesh_edge_other_vertex.js

@@ -0,0 +1,21 @@
+/**
+ * Returns other vertex ID
+ * Assumes that given vertex belongs to this edge
+ * Assumes that given edge exists
+ * @param {BinaryTopology} mesh
+ * @param {number} edge_id edge ID
+ * @param {number} vertex_id
+ * @returns {number}
+ */
+export function bt_mesh_edge_other_vertex(mesh, edge_id, vertex_id) {
+
+    const v1 = mesh.edge_read_vertex1(edge_id);
+    const v2 = mesh.edge_read_vertex2(edge_id);
+
+    if (v1 === vertex_id) {
+        return v2;
+    } else {
+        return v1;
+    }
+
+}

package/core/geom/3d/topology/struct/binary/query/bt_mesh_edge_other_vertex.spec.js

@@ -0,0 +1,16 @@
+import { BinaryTopology } from "../BinaryTopology.js";
+import { bt_mesh_edge_other_vertex } from "./bt_mesh_edge_other_vertex.js";
+
+test('main', () => {
+
+    const mesh = new BinaryTopology();
+
+    const edge = mesh.edges.allocate();
+
+    mesh.edge_write_vertex1(edge, 7);
+    mesh.edge_write_vertex2(edge, 3);
+
+    expect(bt_mesh_edge_other_vertex(mesh, edge, 7)).toBe(3);
+    expect(bt_mesh_edge_other_vertex(mesh, edge, 3)).toBe(7);
+
+});

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 "./binary/io/bt_index_geometry_to_topology.js";
+import { BinaryTopology } from "./binary/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 topoMesh = new TopoMesh();
+
+    const positions_array = lucy_geom.getAttribute('position').array;
+    const index_array = lucy_geom.getIndex().array;
+
+
+    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');
+
+    //
+    // console.time('topo build - obj');
+    // topoMesh.build(positions_array, index_array);
+    // console.timeEnd('topo build - obj');
+
+    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/core/path/PATH_SEPARATOR.js

@@ -0,0 +1 @@
+export const PATH_SEPARATOR = '/';

package/core/path/computeFileExtension.js

@@ -0,0 +1,24 @@
+import { computePathBase } from "./computePathBase.js";
+
+/**
+ *
+ * @param {string} path
+ * @returns {String|null}
+ */
+export function computeFileExtension(path) {
+    if (typeof path !== "string") {
+        throw new Error('path is not a string');
+    }
+
+    //get base
+    const pathBase = computePathBase(path);
+
+    const lastDotIndex = pathBase.lastIndexOf('.');
+
+    if (lastDotIndex !== -1) {
+        return pathBase.substring(lastDotIndex + 1);
+    } else {
+        //no extension
+        return null;
+    }
+}

package/core/path/computeFileExtension.spec.js

@@ -0,0 +1,13 @@
+import { computeFileExtension } from "./computeFileExtension.js";
+
+test('extract extension of cat.txt', () => {
+    expect(computeFileExtension('cat.txt')).toEqual('txt');
+});
+
+test('extract extension of ../hmm/cat.txt', () => {
+    expect(computeFileExtension('../hmm/cat.txt')).toEqual('txt');
+});
+
+test('extract extension of empty string', () => {
+    expect(computeFileExtension('')).toBeNull();
+});

package/core/path/computePathBase.js

@@ -0,0 +1,21 @@
+import { PATH_SEPARATOR } from "./PATH_SEPARATOR.js";
+
+/**
+ * Strips all directories from the path.
+ * @example 'a/b/c' -> 'c'
+ * @param {string} path
+ * @returns {string}
+ */
+export function computePathBase(path) {
+    if (typeof path !== "string") {
+        throw new Error('path is not a string');
+    }
+
+    const lastSlashIndex = path.lastIndexOf(PATH_SEPARATOR);
+
+    if (lastSlashIndex !== -1) {
+        return path.substring(lastSlashIndex + 1);
+    } else {
+        return path;
+    }
+}

package/core/path/computePathBase.spec.js

@@ -0,0 +1,13 @@
+import { computePathBase } from "./computePathBase.js";
+
+test('extract base path of empty string', () => {
+    expect(computePathBase('')).toBe('');
+});
+
+test('extract base path of hello', () => {
+    expect(computePathBase('hello')).toBe('hello');
+});
+
+test('extract base path of hello/there/world', () => {
+    expect(computePathBase('hello/there/world')).toBe('world');
+});

package/core/path/computePathDirectory.js

@@ -0,0 +1,25 @@
+import { PATH_SEPARATOR } from "./PATH_SEPARATOR.js";
+
+/**
+ * Returns the directory name of a path, similar to the Unix dirname command.
+ * @param {string} path
+ * @return {string}
+ */
+export function computePathDirectory(path) {
+    if (typeof path !== "string") {
+        throw new Error('path is not a string');
+    }
+
+    let lastSlashIndex = path.lastIndexOf(PATH_SEPARATOR);
+
+    //rewind in case of trailing slashes
+    while (lastSlashIndex > 0 && path.charAt(lastSlashIndex - 1) === PATH_SEPARATOR) {
+        lastSlashIndex--;
+    }
+
+    if (lastSlashIndex !== -1) {
+        return path.substring(0, lastSlashIndex);
+    } else {
+        return path;
+    }
+}