Function buildOutput

js/decimation.js:664–703

(positions, faces, faceCount)

  // costs are ~0, prefer collapsing shorter edges first for better triangle
  // quality and fewer guard rejections.
  const dx = positions[v2*3] - positions[v1*3];
  const dy = positions[v2*3+1] - positions[v1*3+1];
  const dz = positions[v2*3+2] - positions[v1*3+2];
  heap.push(cost + (dx*dx + dy*dy + dz*dz) * 1e-8,
            v1, v2, version[v1], version[v2], px, py, pz);
}

// ── Indexed <-> Non-indexed conversion ──────────────────────────────────────

// Spatial-hash vertex deduplication via the shared integer-keyed point map
// (open addressing over typed arrays — no BigInt boxing, no Map overhead).
// Same 1e6 weld grid as before: QuantizedPointMap keys on Math.round(c*QUANT),
// which groups identically to the old offset-packed BigInt keys.
function buildIndexed(geometry) {
  const QUANT = QUANT_DEFAULT;
  const posAttr = geometry.attributes.position;
  const n = posAttr.count;

  const positions  = new Float64Array(n * 3); // over-allocated, trimmed later
  const indexRemap = new Int32Array(n);
  let   vertCount  = 0;

  const vertMap = new QuantizedPointMap(QUANT, Math.min(n, 1 << 22));

  for (let i = 0; i < n; i++) {
    const x = posAttr.getX(i), y = posAttr.getY(i), z = posAttr.getZ(i);
    const idx = vertMap.getOrSet(x, y, z, vertCount);
    if (vertMap.inserted) {
      vertCount++;
      positions[idx * 3]     = x;
      positions[idx * 3 + 1] = y;
      positions[idx * 3 + 2] = z;
    }
    indexRemap[i] = idx;
  }

  const faceCount = n / 3;
  const faces = new Int32Array(faceCount * 3);
  for (let i = 0; i < n; i++) faces[i] = indexRemap[i];

  return { positions: positions.subarray(0, vertCount * 3), faces, vertCount, faceCount };
}