3D site export (GLB, OBJ, USD) and the 3D pointer readout

export function pickSite(scene, cam, sx, sy, { tol = 8 } = {}) {
  if (!scene) return null;
  const { o, d } = cam.ray(sx, sy);
  const toProject = (p) => ({ x: p[0] + scene.origin.x, y: p[1] + scene.origin.y, z: p[2] / scene.exag + scene.origin.z });
  // pipes and structures are mostly buried: they are found through the ground, so they are tested first and win
  let best = null;
  // 0.7.1 71.19: a road or hardscape (onGround) lies on the ground: it is tested before the ground and wins a tie with it, but
  // is not found through a hill in front of it the way buried pipes are
  const rank = (m) => (m.owners ? (m.onGround ? 1 : 2) : 0);
  const meshes = [...scene.meshes].sort((a, b) => rank(b) - rank(a));
  for (const m of meshes) {
    if (best && rank(best.m) === 2 && rank(m) < 2) break;
    const P = m.positions, I = m.indices;
    if (best && rank(best.m) === 1 && m.key === 'eg' && scene.meshes.some((q) => q.key === 'fg')) continue;   // the see-through ground over it
    const tie = best && rank(best.m) === 1 && !m.owners ? 1 - 1e-6 : 1;
    for (let t = 0; t < I.length; t += 3) {
      const a = [P[3 * I[t]], P[3 * I[t] + 1], P[3 * I[t] + 2]], b = [P[3 * I[t + 1]], P[3 * I[t + 1] + 1], P[3 * I[t + 1] + 2]], c = [P[3 * I[t + 2]], P[3 * I[t + 2] + 1], P[3 * I[t + 2] + 2]];
      const hit = rayTri(o, d, a, b, c);
      if (hit !== null && (!best || hit < best.t * tie)) best = { t: hit, m, tri: t / 3 };
    }
  }

function showTip(hit, p) {
  if (!hit) { tip.hidden = true; return; }
  const u = project().state.units === 'm' ? 'm' : 'ft';
  tip.replaceChildren(el('strong', {}, hit.name), el('span', {}, t('v3d.tip.at', { e: fixed(hit.at.x, 2), n: fixed(hit.at.y, 2), z: fixed(hit.at.z, 2), u })));
  tip.hidden = false;
  const w = host.clientWidth;
  tip.style.left = Math.min(Math.max(8, p.x + 14), Math.max(8, w - 260)) / 16 + 'rem';
  tip.style.top = (p.y + bar.offsetHeight + 14) / 16 + 'rem';
}

/** Positions → meters, Y up, exaggeration undone. Normals turned the same way (and re-normalized). */
function convert(scene, P, N) {
  const k = METERS_PER[scene.units] || 1, e = scene.exag || 1;
  const out = new Float32Array(P.length);
  for (let i = 0; i < P.length; i += 3) { out[i] = P[i] * k; out[i + 1] = (P[i + 2] / e) * k; out[i + 2] = -P[i + 1] * k; }
  let nOut = null;
  if (N) {
    nOut = new Float32Array(N.length);
    for (let i = 0; i < N.length; i += 3) {
      const x = N[i], y = N[i + 1], z = N[i + 2] * e, l = Math.hypot(x, y, z) || 1;
      nOut[i] = x / l; nOut[i + 1] = z / l; nOut[i + 2] = -y / l;
    }
  }
  return { P: out, N: nOut };
}

const acc = (arr, type, componentType, target, minmax) => {
  const n = type === 'VEC3' ? 3 : 1;
  const a = { bufferView: view(arr, target), componentType, count: arr.length / n, type };
  if (minmax) {
    const min = [Infinity, Infinity, Infinity], max = [-Infinity, -Infinity, -Infinity];
    for (let i = 0; i < arr.length; i += 3) for (let k = 0; k < 3; k++) { if (arr[i + k] < min[k]) min[k] = arr[i + k]; if (arr[i + k] > max[k]) max[k] = arr[i + k]; }
    a.min = min.map(Math.fround); a.max = max.map(Math.fround);
  }
  accessors.push(a);
  return accessors.length - 1;
};

export function exportOBJ(scene, { name = 'Site' } = {}) {
  const o = scene.origin;
  const f = (v) => { const s = v.toFixed(4); return s === '-0.0000' ? '0.0000' : s; };
  const lines = [
    '# CivilCraft site — ' + String(name).replace(/[\r\n]+/g, ' '),
    // i18n-ignore: OBJ header comments (file content)
    '# Meters, Y up, true scale, relative to the origin below (Z-up project coordinates, ' + (scene.units === 'm' ? 'meters' : 'US survey feet') + ')',
    `# origin easting ${o.x} northing ${o.y} elevation ${o.z}`,
  ];
  let base = 1, nBase = 1;
  for (const m of scene.meshes) {
    if (!m.indices.length) continue;
    const { P, N } = convert(scene, m.positions, m.normals);
    lines.push('o ' + m.name.replace(/\s+/g, '_'));
    for (let i = 0; i < P.length; i += 3) lines.push(`v ${f(P[i])} ${f(P[i + 1])} ${f(P[i + 2])}`);
    for (let i = 0; i < N.length; i += 3) lines.push(`vn ${N[i].toFixed(5)} ${N[i + 1].toFixed(5)} ${N[i + 2].toFixed(5)}`);   // i18n-ignore: OBJ records
    const I = m.indices;
    for (let t = 0; t < I.length; t += 3) { const a = I[t] + base, b = I[t + 1] + base, c = I[t + 2] + base, na = I[t] + nBase, nb = I[t + 1] + nBase, nc = I[t + 2] + nBase; lines.push(`f ${a}//${na} ${b}//${nb} ${c}//${nc}`); }
    base += P.length / 3; nBase += N.length / 3;
  }
  for (const l of scene.lines) {
    if (!l.positions.length) continue;
    const { P } = convert(scene, l.positions, null);
    lines.push('o ' + l.name.replace(/\s+/g, '_'));
    for (let i = 0; i < P.length; i += 3) lines.push(`v ${f(P[i])} ${f(P[i + 1])} ${f(P[i + 2])}`);
    for (let i = 0; i < P.length / 3; i += 2) lines.push(`l ${base + i} ${base + i + 1}`);
    base += P.length / 3;
  }
  if (scene.points?.positions.length) {
    const { P } = convert(scene, scene.points.positions, null);
    lines.push('o ' + t('scene.layer.node').replace(/\s+/g, '_'));
    for (let i = 0; i < P.length; i += 3) lines.push(`v ${f(P[i])} ${f(P[i + 1])} ${f(P[i + 2])}`);
    for (let i = 0; i < P.length / 3; i++) lines.push(`p ${base + i}`);
    base += P.length / 3;
  }
  return lines.join('\n') + '\n';
}

const site = b.group(b.root, 'Site_' + (name || 'site'), { kind: 'assembly', displayName: name || 'Site', matrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, o.x * k, o.y * k, o.z * k, 1] });
b.attr(site, 'ifc:class', 'token', 'IfcSite', { custom: true, uniform: true });
const code = crs && (crs.code || crs.name || crs.id);
if (code) b.attr(site, 'ifc:crs:name', 'string', String(code), { custom: true, uniform: true });
b.attr(site, 'cadcraft:units', 'token', scene.units === 'ft' ? 'usft' : 'm', { custom: true, uniform: true });
const conv = (P) => {
  const out = new Float32Array(P.length);
  for (let i = 0; i < P.length; i += 3) { out[i] = P[i] * k; out[i + 1] = P[i + 1] * k; out[i + 2] = (P[i + 2] / e) * k; }
  return out;
};