@woosh/meep-engine 2.43.22 → 2.43.24

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

@@ -1,329 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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);
-});