IFC export of parts, assemblies and library items

/** A STEP real with at most `digits` decimals (coordinates, directions): always with a decimal point. */
export function R(v, digits = 6) {
  if (!Number.isFinite(v)) return '0.';
  let s = (Math.abs(v) < 0.5 * 10 ** -digits ? 0 : v).toFixed(digits).replace(/(\.\d*?)0+$/, '$1');
  if (!s.includes('.')) s += '.';
  return s === '-0.' ? '0.' : s;
}

/** A STEP real to 12 significant digits (quantities, values), exponent as E-9. */
export function Rq(v) {
  if (!Number.isFinite(v)) return '0.';
  let s = String(Number(v.toPrecision(12)));
  if (s.includes('e')) { const [m, e] = s.split('e'); return (m.includes('.') ? m : m + '.') + 'E' + e.replace('+', ''); }
  return s.includes('.') ? s : s + '.';
}

/** The quantities of a built part: IfcElementQuantity sets (volume, area; mass, box). */
function quantities(F, key, stats, material) {
  const { w } = F, out = [];
  if (!stats) return out;
  const q = (type, name, v) => (Number.isFinite(v) ? w.add('IFCQUANTITY' + type + '(' + S(name) + ',$,$,' + Rq(v) + ',$)') : null);
  const std = [q('VOLUME', 'NetVolume', stats.volume * 1e-9), q('AREA', 'NetSurfaceArea', stats.area * 1e-6)].filter(Boolean);
  if (std.length) out.push(w.add('IFCELEMENTQUANTITY(' + S(F.seed('qto|' + key)) + ",$,'Qto_BuildingElementProxyQuantities',$,$,(" + std.join(',') + '))'));
  const lo = toZ(stats.bbox.min), hi = toZ(stats.bbox.max), size = [0, 1, 2].map((k) => Math.abs(hi[k] - lo[k]));
  const own = [
    material ? q('WEIGHT', 'NetWeight', stats.volume * material.density * 1e-6) : null,   // mm³ × g/cm³ = 1e-3 g → kg ×1e-6
    q('LENGTH', 'OverallLength', size[0]), q('LENGTH', 'OverallWidth', size[1]), q('LENGTH', 'OverallDepth', size[2]),
  ].filter(Boolean);
  if (own.length) out.push(w.add('IFCELEMENTQUANTITY(' + S(F.seed('qpc|' + key)) + ",$,'PartCraft_Quantities',$,$,(" + own.join(',') + '))'));
  F.counts.psets += out.length;
  return out;
}

/** Volume, area and box of a mesh (any axes) for the quantities. */
function meshStats(mesh) {
  const P = mesh.positions, I = mesh.indices;
  let vol = 0, area = 0;
  const min = [Infinity, Infinity, Infinity], max = [-Infinity, -Infinity, -Infinity];
  for (let i = 0; i < P.length; i += 3) for (let k = 0; k < 3; k++) { min[k] = Math.min(min[k], P[i + k]); max[k] = Math.max(max[k], P[i + k]); }
  for (let t = 0; t < I.length; t += 3) {
    const a = I[t] * 3, b = I[t + 1] * 3, c = I[t + 2] * 3;
    const ux = P[b] - P[a], uy = P[b + 1] - P[a + 1], uz = P[b + 2] - P[a + 2], vx = P[c] - P[a], vy = P[c + 1] - P[a + 1], vz = P[c + 2] - P[a + 2];
    const nx = uy * vz - uz * vy, ny = uz * vx - ux * vz, nz = ux * vy - uy * vx;
    area += Math.hypot(nx, ny, nz) / 2;
    vol += (P[a] * (P[b + 1] * P[c + 2] - P[b + 2] * P[c + 1]) - P[a + 1] * (P[b] * P[c + 2] - P[b + 2] * P[c]) + P[a + 2] * (P[b] * P[c + 1] - P[b + 1] * P[c])) / 6;
  }
  return { volume: Math.abs(vol), area, bbox: { min, max } };
}

/** 4×4 column-major rigid matrix (Y up) → IFC axis placement (Z up): location, Axis (local z), RefDirection (local x). */
function placementOf(F, M) {
  const col = (j) => [M[j * 4], M[j * 4 + 1], M[j * 4 + 2]];
  const C = (v) => toZ(v);
  // the matrix in IFC axes: C · M · C⁻¹; its columns are C of M's columns taken in IFC order (x, −z, y)
  const ex = C(col(0)), ey = C(col(2)).map((v) => -v), ez = C(col(1));   // images of IFC's x, y, z
  void ey;
  const o = C(col(3));
  return F.w.add('IFCAXIS2PLACEMENT3D(' + F.w.pt(o) + ',' + F.w.dir(ez) + ',' + F.w.dir(ex) + ')');
}