Function computeWorldPeriod

js/smartResolution.js:67–105

* World-space "period" of the texture along U and V — i.e. how many world * millimetres correspond to one full UV repeat. Mirrors the math in * mapping.js (computeUV → applyTransform). * * Returns { periodU_mm, periodV_mm }. Undefined directions (rare) fall back * to the longest planar period

(settings, bounds)

 * not pick a degenerate axis.
 */
function computeWorldPeriod(settings, bounds) {
  // settings.scaleU/scaleV ARE the world period in mm (absolute tile size) —
  // identical across all mapping modes by construction. Only the aspect
  // correction from mapping.js (effective scale = scale / aspect) remains.
  const aspectU = settings.textureAspectU ?? 1;
  const aspectV = settings.textureAspectV ?? 1;
  return {
    periodU_mm: (settings.scaleU || 1e-6) / aspectU,
    periodV_mm: (settings.scaleV || 1e-6) / aspectV,
  };
}

// ── Subdivision triangle-count simulator ─────────────────────────────────────
//
// Walks the actual subdivide-pass logic shape-by-shape, using law-of-cosines
// medians for the 1→2 and 1→3 child-edge lengths.  Aggressively memoised on
// quantised (sorted-descending) edge tuples so duplicate CAD-tessellation
// triangles cost O(1).
//
// Per-triangle simulation matches global subdivide() because edge marking is
// purely a function of edge length (L > T?) — same decision regardless of
// which triangle the marked edge belongs to.  Empirically within ~5 % of the
// real subdivide() output across 3DBenchy, Barry Bear, Grip70mm, cone,
// cubeWithSmallFillets, laserPlate, and puerta texturized — vs the legacy
// closed-form K · area / edge² which underestimates by 3–7×.

function simTri(a, b, c, T, memo, depth) {
  // Sort descending: a ≥ b ≥ c.
  if (a < b) { const t = a; a = b; b = t; }
  if (b < c) { const t = b; b = c; c = t; }
  if (a < b) { const t = a; a = b; b = t; }

  // Quantise relative to T for cache.  256 bins per multiple of T → sub-percent
  // shape-resolution, ample for triangle-count accounting.
  const ka = Math.round((a / T) * 256);
  const kb = Math.round((b / T) * 256);
  const kc = Math.round((c / T) * 256);
  const key = ka * 0x40000000 + kb * 0x10000 + kc;
  const cached = memo.get(key);
  if (cached !== undefined) return cached;

  // Match subdivide()'s 12-pass outer cap so deep slivers behave identically.