@woosh/meep-engine 2.37.18 → 2.38.0

package/core/geom/3d/topology/tm_face_normal.js

@@ -0,0 +1,14 @@
+import { compute_triangle_normal } from "./struct/TopoTriangle.js";
+
+/**
+ *
+ * @param {number[]} result
+ * @param {TopoTriangle} face
+ */
+export function tm_face_normal(result, face) {
+    const v0 = face.vertices[0];
+    const v1 = face.vertices[1];
+    const v2 = face.vertices[2];
+
+    compute_triangle_normal(result, v0, v1, v2);
+}

package/core/geom/3d/topology/tm_kill_only_edge.js

@@ -0,0 +1,35 @@
+import { assert } from "../../../assert.js";
+
+/**
+ *
+ * @param {TopoMesh} mesh
+ * @param {TopoEdge} edge
+ */
+export function tm_kill_only_edge(mesh, edge) {
+    assert.equal(edge.isTopoEdge, true, "e.isTopoEdge !== true");
+
+    // validate that the edge does not have any live back links
+    // const vertices = this.vertices;
+    // const vertex_count = vertices.length;
+    // for (let i = 0; i < vertex_count; i++) {
+    //     const v = vertices[i];
+    //
+    //     if (v.containsEdge(e)) {
+    //         // live link to edge
+    //         debugger;
+    //     }
+    // }
+    //
+    // const faces = this.faces;
+    // const face_count = faces.length;
+    // for (let i = 0; i < face_count; i++) {
+    //     const face = faces[i];
+    //
+    //     if (face.containsEdge(e)) {
+    //         // live link to face
+    //         debugger;
+    //     }
+    // }
+
+    mesh.__edges.delete(edge);
+}

package/core/geom/3d/topology/tm_kill_only_face.js

@@ -0,0 +1,12 @@
+import { assert } from "../../../assert.js";
+
+/**
+ *
+ * @param {TopoMesh} mesh
+ * @param {TopoTriangle} face
+ */
+export function tm_kill_only_face(mesh, face) {
+    assert.equal(face.isTopoFace, true, "f.isTopoFace !== true");
+
+    mesh.__faces.delete(face);
+}

package/core/geom/3d/topology/tm_kill_only_vert.js

@@ -0,0 +1,14 @@
+import { assert } from "../../../assert.js";
+import { array_remove_first } from "../../../collection/array/array_remove_first.js";
+
+/**
+ *
+ * @param {TopoMesh} mesh
+ * @param {TopoVertex} vertex
+ */
+export function tm_kill_only_vert(mesh, vertex) {
+    assert.equal(vertex.isTopoVertex, true, "v.isTopoVertex !== true");
+    assert.arrayHas(mesh.vertices, vertex, 'element not found');
+
+    array_remove_first(mesh.vertices, vertex);
+}

package/core/geom/3d/topology/tm_vert_kill.js

@@ -0,0 +1,19 @@
+import { tm_edge_kill } from "./tm_edge_kill.js";
+import { tm_kill_only_vert } from "./tm_kill_only_vert.js";
+
+/**
+ * Remove vertex and all edges that use it
+ * @param {TopoMesh} mesh
+ * @param {TopoVertex} vertex
+ */
+export function tm_vert_kill(mesh, vertex) {
+    const edges = vertex.edges;
+
+    const edge_count = edges.length;
+
+    for (let i = edge_count - 1; i >= 0; i--) {
+        tm_edge_kill(mesh, edges[i]);
+    }
+
+    tm_kill_only_vert(mesh, vertex);
+}

package/core/geom/3d/topology/tm_vert_splice.js

@@ -0,0 +1,64 @@
+import { assert } from "../../../assert.js";
+import { tm_vert_kill } from "./tm_vert_kill.js";
+
+/**
+ * Splice vertex
+ * Merges two vertices into one, source into destination, removing source.
+ * NOTE: source vertex is deleted in the process
+ *
+ * @param {TopoMesh} mesh
+ * @param {TopoVertex} destination
+ * @param {TopoVertex} source
+ * @returns {boolean}
+ */
+export function tm_vert_splice(mesh, destination, source) {
+    if (destination === source) {
+        // already spliced
+        return false;
+    }
+
+    assert.defined(source, 'victim');
+    assert.notNull(source, 'victim');
+    assert.equal(source.isTopoVertex, true, "victim.isTopoVertex !== true");
+    assert.notEqual(destination, source, "cannot replace self");
+
+    const faces = source.faces;
+    const face_count = faces.length;
+
+    let i = 0;
+
+    for (; i < face_count; i++) {
+        // take over the victim's faces
+        const face = faces.pop();
+
+
+        // face.computeNormal(); // DEBUG
+        face.replaceVertex(source, destination);
+
+        destination.addUniqueFace(face);
+
+        // face.computeNormal(); // DEBUG
+    }
+
+    const edges = source.edges;
+    const edge_count = edges.length;
+
+    // const destination_edges = destination.edges;
+
+    for (i = 0; i < edge_count; i++) {
+        // take over the victim's edges
+        const edge = edges.pop();
+
+        edge.replaceVertex(source, destination);
+        //
+        // for (let j = 0; j < destination_edges.length; j++) {
+        //     destination_edges[j]
+        // }
+
+        destination.addUniqueEdge(edge);
+    }
+
+    tm_vert_kill(mesh, source);
+
+    return true;
+}

package/core/geom/3d/topology/tm_vertex_compute_normal.js

@@ -0,0 +1,42 @@
+import { compute_triangle_normal } from "./struct/TopoTriangle.js";
+//
+
+
+const scratch_v3_0 = new Float32Array(3);
+
+/**
+ *
+ * @param {number[]} result
+ * @param {number} result_offset
+ * @param {TopoVertex} vertex
+ */
+export function tm_vertex_compute_normal(result, result_offset, vertex) {
+    const faces = vertex.faces;
+    const face_length = faces.length;
+
+
+    let _x = 0;
+    let _y = 0;
+    let _z = 0;
+
+    for (let i = 0; i < face_length; i++) {
+        const face = faces[i];
+
+        compute_triangle_normal(scratch_v3_0, face.vertices[0], face.vertices[1], face.vertices[2]);
+
+        _x += scratch_v3_0[0];
+        _y += scratch_v3_0[1];
+        _z += scratch_v3_0[2];
+    }
+
+    // re-normalize
+    const len_inv = Math.hypot(_x,_y,_z);
+
+    _x *= len_inv;
+    _y *= len_inv;
+    _z *= len_inv;
+
+    result[result_offset] = _x;
+    result[result_offset+1] = _y;
+    result[result_offset+2] = _z;
+}

package/core/geom/3d/topology/topoMeshToBufferGeometry.js

@@ -6,6 +6,8 @@ import { BufferAttribute, BufferGeometry } from "three";
  * @returns {THREE.BufferGeometry}
  */
 export function topoMeshToBufferGeometry(mesh) {
+    const vertices_lookup = new Map();
+
     // build vertices array
     const vertex_count = mesh.vertices.length;
     const position_array = new Float32Array(vertex_count * 3);
@@ -17,11 +19,23 @@ export function topoMeshToBufferGeometry(mesh) {
         position_array[i_3] = vertex.x;
         position_array[i_3 + 1] = vertex.y;
         position_array[i_3 + 2] = vertex.z;
+
+        vertices_lookup.set(vertex, i);
     }
     // build face array
     const mesh_faces = mesh.getFaces();
     const face_count = mesh_faces.size;
-    const face_array = new Uint16Array(face_count * 3);
+
+    let IndexArrayType;
+    if (vertex_count <= 255) {
+        IndexArrayType = Uint8Array;
+    } else if (vertex_count <= 65535) {
+        IndexArrayType = Uint16Array;
+    } else {
+        IndexArrayType = Uint32Array;
+    }
+
+    const face_array = new IndexArrayType(face_count * 3);
 
     let i_3 = 0;
     for (let face of mesh_faces) {
@@ -30,9 +44,9 @@ export function topoMeshToBufferGeometry(mesh) {
         const vB = face.vertices[1];
         const vC = face.vertices[2];
 
-        const vAi = mesh.vertices.indexOf(vA);
-        const vBi = mesh.vertices.indexOf(vB);
-        const vCi = mesh.vertices.indexOf(vC);
+        const vAi = vertices_lookup.get(vA);
+        const vBi = vertices_lookup.get(vB);
+        const vCi = vertices_lookup.get(vC);
 
         face_array[i_3] = vAi;
         face_array[i_3 + 1] = vBi;

package/core/geom/3d/topology/weld_duplicate_vertices.js

@@ -0,0 +1,63 @@
+import { computeTopoMeshVertexDuplicates } from "./computeTopoMeshVertexDuplicates.js";
+import { EPSILON } from "../../../math/MathUtils.js";
+import { tm_vert_splice } from "./tm_vert_splice.js";
+import { debugValidateMesh } from "./debugValidateMesh.js";
+
+/**
+ *
+ * @param {TopoMesh} mesh
+ * @param {AABB3} bounds
+ * @param {number} tolerance
+ * @returns {number} removed vertices
+ */
+export function weld_duplicate_vertices(mesh, bounds, tolerance = EPSILON) {
+
+    debugValidateMesh(mesh);
+
+    const duplicates = computeTopoMeshVertexDuplicates(mesh, bounds, tolerance);
+
+    const removed_vertices = new Set();
+
+    let removal_count = 0;
+
+    for (let entry of duplicates) {
+
+        /**
+         *
+         * @type {TopoVertex}
+         */
+        const source = entry[0];
+
+        if (removed_vertices.has(source.index)) {
+            continue;
+        }
+
+        /**
+         *
+         * @type {TopoVertex[]}
+         */
+        const vertex_duplicates = entry[1];
+
+        const duplicate_count = vertex_duplicates.length;
+        for (let i = 0; i < duplicate_count; i++) {
+            const v = vertex_duplicates[i];
+
+            const duplicate_vertex_index = v.index;
+
+            if (removed_vertices.has(duplicate_vertex_index)) {
+                continue;
+            }
+
+            removed_vertices.add(duplicate_vertex_index);
+
+            tm_vert_splice(mesh, source, v);
+
+            removal_count++;
+        }
+    }
+
+    debugValidateMesh(mesh);
+
+    return removal_count;
+
+}

package/core/geom/Quaternion.d.ts

@@ -1,5 +1,6 @@
 import Signal from "../events/signal/Signal";
 import {Matrix4, Quaternion as ThreeQuaternion} from "three";
+import Vector3 from "./Vector3";
 
 export default class Quaternion {
     public x: number
@@ -7,7 +8,7 @@ export default class Quaternion {
     public z: number
     public w: number
 
-    public get onChanged(): Signal;
+    readonly onChanged: Signal<number, number, number, number, number, number, number, number>;
 
     set(x: number, y: number, z: number, w: number): void
 
@@ -15,6 +16,10 @@ export default class Quaternion {
     copy(other: ThreeQuaternion): void
     copy(other: { x: number, y: number, z: number, w: number }): void
 
+    equals(other: { x: number, y: number, z: number, w: number }): boolean
+
+    normalize(): void
+
     __setThreeEuler(threeEuler: any): void
 
     __setFromEuler(x: number, y: number, z: number, order?: string): void
@@ -24,4 +29,19 @@ export default class Quaternion {
     setFromRotationMatrix(m: Matrix4): void
 
     decodeFromUint32(uint: number): void
+
+
+    toEulerAnglesXYZ(v3: { set(x: number, y: number, z: number): any }): void
+
+    fromEulerAnglesXYZ(x: number, y: number, z: number): void
+
+    fromAxisAngle(axis: Vector3 | { x: number, y: number, z: number }, angle: number): void
+
+    computeTwistAngle(axis: Vector3): number
+
+    multiplyQuaternions(a: Quaternion, b: Quaternion): void
+
+    toJSON(): any
+
+    fromJSON(j: any): void
 }