Function decimate

js/decimation.js:106–264

(geometry, targetTriangles, onProgress, harvestFlat = true, harvestTol = DEFAULT_HARVEST_TOL)

function _shouldYield() {
  const now = performance.now();
  if (now - _lastYieldTime < 100) return false;
  _lastYieldTime = now;
  return true;
}
function _yieldFrame() {
  return new Promise(r => setTimeout(r, 0));
}

// ── Public API ───────────────────────────────────────────────────────────────

export async function decimate(geometry, targetTriangles, onProgress, harvestFlat = true, harvestTol = DEFAULT_HARVEST_TOL, lockedFaces = null) {
  const { positions, faces, vertCount, faceCount } = buildIndexed(geometry);

  // Already at/under the target: nothing to decimate. But if harvesting is on we
  // still run — there may be flat faces collapsible for free even below the limit.
  if (faceCount <= targetTriangles && !harvestFlat) return buildOutput(positions, faces, faceCount);

  // Preserve-untextured (beta): a vertex touching any locked (untextured) face
  // may neither move nor be removed, so edges with a locked endpoint are never
  // pushed onto the heap. This also pins the textured/untextured boundary ring,
  // so no T-junctions can open against the locked region. lockedFaces uses the
  // same face order as the non-indexed input geometry.
  let lockedVert = null;
  let lockedFaceCount = 0;
  if (lockedFaces) {
    lockedVert = new Uint8Array(vertCount);
    for (let f = 0; f < faceCount; f++) {
      if (!lockedFaces[f]) continue;
      lockedFaceCount++;
      lockedVert[faces[f * 3]]     = 1;
      lockedVert[faces[f * 3 + 1]] = 1;
      lockedVert[faces[f * 3 + 2]] = 1;
    }
  }
  // When the locked faces alone meet or exceed the triangle target, the target
  // is unreachable without touching untextured geometry. Chasing it anyway
  // would grind the textured region down to its guard limit, so instead drop
  // straight to error-bounded harvesting (or bail entirely when harvesting is
  // off) and flag the overrun so the caller can warn the user.
  const lockedOverBudget = lockedVert !== null && faceCount > targetTriangles
    && lockedFaceCount >= targetTriangles;
  if (lockedOverBudget && !harvestFlat) {
    if (onProgress) onProgress(1);
    const out = buildOutput(positions, faces, faceCount);
    out.userData.lockedOverBudget = true;
    return out;
  }

  // Per-vertex error quadrics (10 doubles = upper triangle of symmetric 4×4)
  const quadrics = new Float64Array(vertCount * 10);
  initQuadrics(quadrics, positions, faces, faceCount);
  addCreaseQuadrics(quadrics, positions, faces, faceCount);

  // Doubly-linked vertex-face incidence (typed arrays — faster than Set<number>)
  const { vfHead, slotFace, slotVert, slotNext, slotPrev, faceSlot } =
    buildLinkedAdj(faces, faceCount, vertCount);

  const active  = new Uint8Array(vertCount).fill(1);