Function findOverlappingTriangles

js/meshValidation.js:330–374

* Find duplicate triangles by exact vertex comparison. * Two triangles are duplicates if they share the same three vertex positions * (bit-identical floats), regardless of winding order. * Also collects the face indices of duplicates for highlighting. * * @param {THREE.BufferGeometry} geometry

(geometry, token)

 * Also collects the face indices of duplicates for highlighting.
 *
 * @param {THREE.BufferGeometry} geometry
 * @param {{ get:() => number }} token
 * @returns {Promise<{ count:number, faces:Set<number> }|number>}
 *          -1 if aborted
 */
async function findOverlappingTriangles(geometry, token) {
  const startToken = token.get();
  const pos = geometry.attributes.position.array;
  const triCount = pos.length / 9;

  // Use a DataView to read float32 bits as uint32 for exact hashing
  const dv = new DataView(pos.buffer, pos.byteOffset, pos.byteLength);

  // Build a sortable key per vertex from raw float bits (exact, no quantization)
  function vertKey(offset) {
    // Read the 3 float32 values as uint32 bit patterns
    const bx = dv.getUint32(offset, true);
    const by = dv.getUint32(offset + 4, true);
    const bz = dv.getUint32(offset + 8, true);
    return `${bx}_${by}_${bz}`;
  }

  const triHashMap = new Map();
  const overlapFaces = new Set();

  for (let t = 0; t < triCount; t++) {
    const byteBase = t * 9 * 4; // 9 floats × 4 bytes
    const verts = [
      vertKey(byteBase),
      vertKey(byteBase + 12),
      vertKey(byteBase + 24),
    ];
    verts.sort();
    const key = verts[0] + '|' + verts[1] + '|' + verts[2];
    const existing = triHashMap.get(key);
    if (existing !== undefined) {
      overlapFaces.add(existing);
      overlapFaces.add(t);
    } else {
      triHashMap.set(key, t);
    }

    if (t % 50000 === 0 && t > 0) {
      await yieldFrame();
      if (token.get() !== startToken) return -1;
    }
  }