Function computeSmartResolution

js/smartResolution.js:289–389

({ geometry, bounds, settings, texture })

  // Pre-compute per-triangle edges once — reused across all simulator calls.
  const triEdges = computeTriEdges(geometry);

  // Solve for the largest (coarsest) edge that keeps simulated tri count ≤
  // budget.  Start from the closed-form equilateral-cover estimate, then
  // do up to 3 ratio corrections (sim count scales ~1/edge² so each step
  // multiplies edge by sqrt(predicted/budget) until it converges).
  let budgetEdge = Math.sqrt((TRIS_PER_AREA_GEOM * surfaceArea) / Math.max(triBudget, 1));
  for (let step = 0; step < 3; step++) {
    const simCount = simulateFromEdges(triEdges, budgetEdge);
    if (simCount <= triBudget) break;
    const correction = Math.sqrt(simCount / triBudget);
    if (correction < 1.005) break;          // converged
    budgetEdge = budgetEdge * correction;
  }
  // Guarantee the budget actually holds.  On near-uniform meshes (cube-like
  // CAD tessellations) the simulated count is a step function of the edge —
  // 12 × 4^k for the default cube — so the sqrt-ratio corrections above can
  // stall between split thresholds and finish a few percent over budget.
  // Walk coarser in 5% steps until the simulation fits; sim count is
  // monotonically non-increasing in edge length, so this always terminates.
  for (let step = 0; step < 24; step++) {
    if (simulateFromEdges(triEdges, budgetEdge) <= triBudget) break;
    budgetEdge *= 1.05;
  }

  // 5. Final edge: take the larger (coarser) of detail vs budget so neither
  // constraint is violated.
  let edge = Math.max(detailEdge, budgetEdge);
  const budgetClamped = budgetEdge > detailEdge;

  // Sanity clamp: never below 0.05 mm, never coarser than diag/50 (or the
  // 5 mm slider absolute) — matches the legacy default's spirit.
  const diag = Math.sqrt(bounds.size.x ** 2 + bounds.size.y ** 2 + bounds.size.z ** 2);
  const lo = 0.05;
  const hi = Math.min(5.0, diag / 50);
  const preClamp = edge;
  edge = Math.min(Math.max(edge, lo), Math.max(hi, lo));
  const edgeClamped = edge !== preClamp;

  // Round UP to 2 decimals so the slider value never violates the budget
  // floor (rounding down by even 0.005 mm can push estimated triangles past
  // the budget cap).
  edge = Math.max(lo, Math.ceil(edge * 100) / 100);

  // Estimated triangle count at the chosen edge length, via per-triangle
  // simulation of the actual subdivision pattern.
  const estTriangles = simulateFromEdges(triEdges, edge);

  // Recommended Max Triangles for "minimum quality loss" decimation.
  const recommendedMaxTri = computeRecommendedMaxTri({
    pixelsPerEdge, pixMm, surfaceArea,
    amplitude: settings.amplitude,
  });

  return {
    edge,
    diagnostics: {
      pixelsPerEdge,