Decal placement and size

/** What lies under screen point ev: the face, its placement path, the point and normal in its definition's coordinates, its paint,
 *  and where on its material's tile it is (tile units: a mesh's UVs, else metres along the face ÷ the tile) | null. */
export function surfaceAt(h, ev) {
  const hit = h.scene().hit(h.cam.ray(ev.x, ev.y));
  if (!hit) return null;
  const path = hit.f.path, ctx = h.model.context(path);
  if (!ctx) return null;
  const def = ctx.def, inv = invert(ctx.m), pL = apply(inv, hit.p);
  const [a, b, c] = hit.f.tris[0].map((q) => apply(inv, q)), nL = norm(cross(sub(b, a), sub(c, a)));
  // the placement's paint: the innermost placement that has one (as the renderers walk them)
  let paint = null, d = h.model.root;
  for (const iid of path) { const inst = d.insts.get(iid); if (!inst) break; if (inst.color) paint = inst.color; d = h.model.def(inst.def); }
  let face = null, uv = null;
  if (def.mesh) {
    // the shown mesh's triangle holding the point: its corners' UVs, weighted
    const M = def.shown || def.mesh, T = M.triangulate(), P = M.P, hV = M.hV, uvA = M.attrArray('uv');
    let best = null;
    for (let i = 0; i < T.n; i++) {
      const q = [0, 1, 2].map((k) => { const v = hV[T.tri[i * 3 + k]] * 3; return [P[v], P[v + 1], P[v + 2]]; });
      const w = bary(pL, q[0], q[1], q[2]);
      if (!w || w.dist > (best ? best.dist : 1e-3) || Math.min(w.a, w.b, w.c) < -1e-4) continue;
      best = { i, ...w };
    }
    if (best) {
      face = M.facePaint(T.face[best.i]);
      if (uvA) { const hs = [0, 1, 2].map((k) => T.tri[best.i * 3 + k]); uv = [0, 1].map((j) => best.a * uvA[hs[0] * 2 + j] + best.b * uvA[hs[1] * 2 + j] + best.c * uvA[hs[2] * 2 + j]); }
    }
  } else {
    face = def.faces.get(hit.f.id)?.color || null;
  }
  const p = face || paint, mid = isMaterialPaint(p) ? p.slice(4) : null;
  const m = mid && materials.has(mid) ? libMat(mid) : null;
  let tuv = null;
  if (m) {
    if (def.mesh) tuv = uv;
    else { const w = planarUV(pL, nL); tuv = [w[0] / m.size[0], w[1] / m.size[1]]; }
  }
  return { hit, path, def, pL, nL, paint: p, material: m ? mid : null, tuv };
}

function bary(p, a, b, c) {
  const ab = sub(b, a), ac = sub(c, a), n = cross(ab, ac), nn = n[0] * n[0] + n[1] * n[1] + n[2] * n[2];
  if (!(nn > 1e-20)) return null;
  const ap = sub(p, a), dist = Math.abs(ap[0] * n[0] + ap[1] * n[1] + ap[2] * n[2]) / Math.sqrt(nn);
  const cb = cross(ap, ac), cc = cross(ab, ap);
  const bw = (cb[0] * n[0] + cb[1] * n[1] + cb[2] * n[2]) / nn, cw = (cc[0] * n[0] + cc[1] * n[1] + cc[2] * n[2]) / nn;
  return { a: 1 - bw - cw, b: bw, c: cw, dist };
}

const size = [st.decal.width, Math.round(st.decal.width * aspect * 1000) / 1000];

function resizeDecal(id, w) {
  const d = materials.decal(id);
  if (!d || !(w > 0)) return;
  const h = Math.round((w * d.size[1]) / d.size[0] * 1000) / 1000;
  materials.updateDecal(id, { size: [w, h], depth: Math.max(0.01, Math.min(w, h) / 2) });
  syncDecalTile(id);
}

/** Turn a decal a quarter turn about its normal; resize it (its material's tile follows). */
function turnDecal(id) {
  const d = materials.decal(id);
  if (!d) return;
  materials.updateDecal(id, { u: cross(d.n, d.u), size: [d.size[1], d.size[0]] });
  syncDecalTile(id);
}