FBX import: axes, units and transforms

/** The file's axes and unit → ModelCraft (Z up, metres): up → +Z, front → −Y, coord → +X. */
export function axisMatrix(s) {
  const e = (i, sign) => { const v = [0, 0, 0]; if (i >= 0 && i <= 2) v[i] = sign < 0 ? -1 : 1; return v; };
  // rows of the map: model X = coord axis, model Y = −front axis, model Z = up axis (each a unit vector in file space)
  const X = e(s.coord, s.coordSign); const Y = e(s.front, s.frontSign).map((v) => -v); const Z = e(s.up, s.upSign);
  const k = (s.unit > 0 && Number.isFinite(s.unit) ? s.unit : 1) * 0.01;
  // column-major: column j = the model coordinates of file axis j
  const m = ident();
  for (let j = 0; j < 3; j++) { m[j * 4] = X[j] * k; m[j * 4 + 1] = Y[j] * k; m[j * 4 + 2] = Z[j] * k; }
  if (Math.abs(det(m)) < 1e-12) return S([k, k, k]);   // contradictory axes: just the unit
  return m;
}

const A = axisMatrix(scene.settings);
const AI = invert(A);
const conj = (m) => mmul(A, mmul(m, AI));

/** Euler angles (degrees) in a RotationOrder: "XYZ" turns about X first, then Y, then Z. */
function euler(v, order = 0) {
  const [x, y, z] = [Rx(v[0]), Ry(v[1]), Rz(v[2])];
  const seq = [[z, y, x], [y, z, x], [x, z, y], [z, x, y], [y, x, z], [x, y, z]][order] || [z, y, x];
  return mmul(seq[0], mmul(seq[1], seq[2]));
}

function localMatrix(p) {
  const order = num(p, 'RotationOrder', 0);
  const rp = vec3(p, 'RotationPivot', [0, 0, 0]);
  const sp = vec3(p, 'ScalingPivot', [0, 0, 0]);
  const parts = [
    T(vec3(p, 'Lcl Translation', [0, 0, 0])), T(vec3(p, 'RotationOffset', [0, 0, 0])), T(rp),
    euler(vec3(p, 'PreRotation', [0, 0, 0]), 0), euler(vec3(p, 'Lcl Rotation', [0, 0, 0]), order),
    invert(euler(vec3(p, 'PostRotation', [0, 0, 0]), 0)), T(rp.map((x) => -x)),
    T(vec3(p, 'ScalingOffset', [0, 0, 0])), T(sp), S(vec3(p, 'Lcl Scaling', [1, 1, 1])), T(sp.map((x) => -x)),
  ];
  return parts.reduce((m, q) => mmul(m, q), ident());
}

const pts = new Float64Array(nv * 3);
for (let i = 0; i < nv; i++) { const q = apply(A, [V[i * 3], V[i * 3 + 1], V[i * 3 + 2]]); pts[i * 3] = q[0]; pts[i * 3 + 1] = q[1]; pts[i * 3 + 2] = q[2]; }
const flip = det(A) < 0;

function addLight(model, attr, M, report, skip) {
  const p = attr.props;
  const type = num(p, 'LightType', 0);
  if (type === 1) { skip(t('fbx.note.directional')); return; }
  if (type > 2) { skip(t('fbx.note.area_light')); return; }
  if (!model.addLight) return;
  const c = vec3(p, 'Color', [1, 1, 1]);
  const hex = '#' + c.map((x) => Math.round(Math.min(1, Math.max(0, x)) * 255).toString(16).padStart(2, '0')).join('');
  const dir = norm(applyDir(M, [0, -1, 0]));   // FBX spot lights shine along their own −Y
  model.addLight({ kind: type === 2 ? 'spot' : 'point', p: apply(M, [0, 0, 0]), dir: len(dir) ? dir : [0, 0, -1], color: hex,
    lumens: num(p, 'Intensity', 100) * 8, angle: num(p, 'OuterAngle', num(p, 'Cone angle', 45)), name: attr.name || '' });
  report.lights++;
}

function addCamera(model, attr, M, report) {
  if (!Array.isArray(model.scenes)) return;
  const p = attr.props;
  const eye = apply(M, [0, 0, 0]);
  const fwd = norm(applyDir(M, [1, 0, 0]));   // FBX cameras look along their own +X
  if (!len(fwd)) return;
  const target = [eye[0] + fwd[0] * 10, eye[1] + fwd[1] * 10, eye[2] + fwd[2] * 10];
  const ortho = num(p, 'CameraProjectionType', 0) === 1;
  const s = cleanScene({ name: attr.name || 'Camera', cam: ortho ? { eye, target, persp: false, height: num(p, 'OrthoZoom', 1) * 10 } : { eye, target, persp: true, fov: num(p, 'FieldOfViewY', num(p, 'FieldOfView', 40)) } });   // i18n-ignore: a fallback name
  if (s) { model.scenes.push(s); report.cameras++; }
}