DWG and DXF drawings in 3D

export function mul3(a, b) {
  const r = new Array(12);
  for (let i = 0; i < 3; i++) {
    const o = i * 4;
    r[o] = a[o] * b[0] + a[o + 1] * b[4] + a[o + 2] * b[8];
    r[o + 1] = a[o] * b[1] + a[o + 1] * b[5] + a[o + 2] * b[9];
    r[o + 2] = a[o] * b[2] + a[o + 1] * b[6] + a[o + 2] * b[10];
    r[o + 3] = a[o] * b[3] + a[o + 1] * b[7] + a[o + 2] * b[11] + a[o + 3];
  }
  return r;
}

export const apply3 = (m, x, y, z) => [m[0] * x + m[1] * y + m[2] * z + m[3], m[4] * x + m[5] * y + m[6] * z + m[7], m[8] * x + m[9] * y + m[10] * z + m[11]];

/** The extrusion direction (DXF 210), or Z when it is missing or zero. */
export function normal(ext) {
  const x = ext?.x || 0, y = ext?.y || 0, z = ext?.z || 0, l = Math.hypot(x, y, z);
  return l < 1e-12 ? [0, 0, 1] : [x / l, y / l, z / l];
}

/** Object coordinate system → world: AutoCAD's arbitrary-axis algorithm (columns Ax, Ay, N). */
export function ocsMatrix(ext) {
  const N = normal(ext);
  if (N[0] === 0 && N[1] === 0 && N[2] === 1) return I3;
  const cross = (a, b) => [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
  const unit = (v) => { const l = Math.hypot(v[0], v[1], v[2]) || 1; return [v[0] / l, v[1] / l, v[2] / l]; };
  const Ax = unit(Math.abs(N[0]) < 1 / 64 && Math.abs(N[1]) < 1 / 64 ? cross([0, 1, 0], N) : cross([0, 0, 1], N));
  const Ay = unit(cross(N, Ax));
  return [Ax[0], Ay[0], N[0], 0, Ax[1], Ay[1], N[1], 0, Ax[2], Ay[2], N[2], 0];
}

const thick = (t, ext) => {
  if (!t) return null;
  const N = normal(ext);
  const v = dir3(m, N[0] * t, N[1] * t, N[2] * t);
  return Math.hypot(v[0], v[1], v[2]) > 0 ? v : null;
};

const local = mul3(mul3(T3(ip.x, ip.y, ip.z), Rz(e.rotation)),
  mul3(T3(k * e.colSpacing, r * e.rowSpacing, 0), mul3(S3(s.x, s.y, s.z), T3(-base.x, -base.y, -base.z))));
const sub = { m: mul3(om, local), layer, color, layerColor: lay.color, depth: ctx.depth + 1, owner: ctx.owner,

const N = normal(e.extrusion), mj = e.majorAxis, c0 = e.center;
const mn = [(N[1] * mj.z - N[2] * mj.y) * e.ratio, (N[2] * mj.x - N[0] * mj.z) * e.ratio, (N[0] * mj.y - N[1] * mj.x) * e.ratio];
let sweep = e.endParam - e.startParam;
while (sweep <= 0) sweep += TAU;
const n = Math.max(8, Math.min(128, Math.ceil(sweep / TAU * 72))), pts = [];
for (let i = 0; i <= n; i++) {
  const t = e.startParam + sweep * (i / n), co = Math.cos(t), si = Math.sin(t);
  pts.push(apply3(m, c0.x + co * mj.x + si * mn[0], c0.y + co * mj.y + si * mn[1], c0.z + co * mj.z + si * mn[2]));
}

const side = (k) => {   // half the width at point k, along the normal of the path there
  const w = ((a.sw || 0) + ((b === a ? 0 : (a.ew || 0)) - (a.sw || 0)) * (total ? at2[k] / total : 0)) / 2;
  const p = P2[Math.max(0, k - 1)], q = P2[Math.min(P2.length - 1, k + 1)];
  const dx = q[0] - p[0], dy = q[1] - p[1], l = Math.hypot(dx, dy) || 1;
  return [-dy / l * w, dx / l * w];
};

/** A spline through its fit points, else its B-spline from the control points (de Boor), in 3D. */
export function spline3(e) {
  const P = (q) => [q.x, q.y, q.z || 0];
  const fit = e.fit || e.fitPoints || [], cp = e.control || e.controlPoints || [], k = e.knots || [], p = e.degree || 3;
  if (fit.length > 1) return fit.map(P);
  if (cp.length < 2) return [];
  if (k.length !== cp.length + p + 1) return cp.map(P);
  const w = e.weights && e.weights.length === cp.length ? e.weights : null;
  const lo = k[p], hi = k[k.length - p - 1], n = Math.max(16, cp.length * 8), pts = [];
  for (let s = 0; s <= n; s++) {
    const u = s === n ? hi - 1e-9 * (hi - lo) : lo + (hi - lo) * (s / n);
    let span = p;
    while (span < cp.length - 1 && u >= k[span + 1]) span++;
    const d = [];
    for (let j = 0; j <= p; j++) { const q = cp[span - p + j], wt = w ? w[span - p + j] : 1; d.push([q.x * wt, q.y * wt, (q.z || 0) * wt, wt]); }
    for (let r = 1; r <= p; r++) {
      for (let j = p; j >= r; j--) {
        const i = span - p + j, den = k[i + p - r + 1] - k[i], a = den === 0 ? 0 : (u - k[i]) / den;
        d[j] = d[j].map((v, c) => (1 - a) * d[j - 1][c] + a * v);
      }
    }
    pts.push([d[p][0] / d[p][3], d[p][1] / d[p][3], d[p][2] / d[p][3]]);
  }
  return pts;
}

const grow = (p) => {
  for (let k = 0; k < 3; k++) { if (!Number.isFinite(p[k])) return false; }
  for (let k = 0; k < 3; k++) { if (p[k] < bmin[k]) bmin[k] = p[k]; if (p[k] > bmax[k]) bmax[k] = p[k]; }
  return true;
};

const lo = this.box.min[i], hi = this.box.max[i];
const at = lo + Math.max(0, Math.min(hi - lo, (Number(s.offset) || 0) * this.scale));
const sign = (s.flip ? -1 : 1) * keep;   // keep: −1 = keep the low side (x ≤ at), +1 = the high side
const n = new THREE.Vector3().setComponent(i, sign);
const plane = new THREE.Plane(n, -sign * at);   // kept: n·p + c ≥ 0
this.section = { axis: k, offset: (at - lo) / this.scale, flip: !!s.flip, plane };

/** [0, size] along the axis, in drawing units. */
sectionRange(axis) {
  if (!this.box) return [0, 0];
  const { i } = SECTION[axis] || SECTION.top;
  return [0, (this.box.max[i] - this.box.min[i]) / this.scale];
}