Shape keys: offsets, editing and blending

/** Start editing key `id`: every vertex there now is marked with the key's number (a vertex added later reads 0). */
export function beginEdit(mesh, id) {
  if (mesh.hasAttr(BASIS) || !mesh.hasAttr(PREFIX + id)) return false;
  mesh.addAttr(BASIS, 'vertex', 3);
  mesh.addAttr(EDITING, 'vertex', 1);
  const P = mesh.P, off = mesh.attrArray(PREFIX + id), b = [0, 0, 0], k = [+id.slice(1)];
  for (let v = 0; v < mesh.nv; v++) {
    if (mesh.vertDead(v)) continue;
    b[0] = P[v * 3]; b[1] = P[v * 3 + 1]; b[2] = P[v * 3 + 2];
    mesh.setAttr(BASIS, v, b);
    mesh.setAttr(EDITING, v, k);
    mesh.setPos(v, b[0] + off[v * 3], b[1] + off[v * 3 + 1], b[2] + off[v * 3 + 2]);
  }
  return true;
}

/** End an edit: the key = the points now − the basis; the points go back to the basis (vertices added meanwhile keep their point, offset 0). */
export function finishEdit(mesh) {
  const id = editing(mesh);
  if (!id) { if (mesh.hasAttr(BASIS)) { mesh.removeAttr(BASIS); mesh.removeAttr(EDITING); } return null; }
  const B = mesh.attrArray(BASIS), E = mesh.attrArray(EDITING), P = mesh.P, d = [0, 0, 0];
  const name = PREFIX + id;
  for (let v = 0; v < mesh.nv; v++) {
    if (mesh.vertDead(v)) continue;
    if (!(E[v] > 0)) { d[0] = d[1] = d[2] = 0; mesh.setAttr(name, v, d); continue; }   // made during the edit: no basis of its own
    const bx = B[v * 3], by = B[v * 3 + 1], bz = B[v * 3 + 2];
    d[0] = P[v * 3] - bx; d[1] = P[v * 3 + 1] - by; d[2] = P[v * 3 + 2] - bz;
    mesh.setAttr(name, v, d);
    mesh.setPos(v, bx, by, bz);
  }
  mesh.removeAttr(BASIS); mesh.removeAttr(EDITING);
  return id;
}

export function setFromPositions(mesh, id, positions) {
  if (!mesh.hasAttr(PREFIX + id) && !addShape(mesh, id)) return false;
  if (!positions || positions.length < mesh.nv * 3) return false;
  const P = mesh.P, d = [0, 0, 0];
  for (let v = 0; v < mesh.nv; v++) {
    if (mesh.vertDead(v)) continue;
    d[0] = positions[v * 3] - P[v * 3]; d[1] = positions[v * 3 + 1] - P[v * 3 + 1]; d[2] = positions[v * 3 + 2] - P[v * 3 + 2];
    mesh.setAttr(PREFIX + id, v, d);
  }
  return true;
}

/** Every vertex's point with the keys at `weights` (keys at 0 cost nothing). `out` is reused when it is big enough. */
export function blendShapes(mesh, weights, out) {
  const n = mesh.nv * 3, P = mesh.P;
  const o = out && out.length >= n ? out : new Float32Array(n);
  o.set(P.subarray(0, n));
  if (!weights) return o;
  for (const [id, w] of weights) {
    if (!w) continue;
    const off = mesh.attrArray(PREFIX + id);
    if (!off) continue;
    for (let i = 0; i < n; i++) o[i] += w * off[i];
  }
  return o;
}

function deform(def, base) {
  if (base !== def.mesh || !deforms(def)) return null;   // a curve object's made mesh has no shape keys or skin
  const s = state.get(def.id);
  let c = cache.get(def.id);
  const key = base.uid + ':' + base.v + ':' + base.live + ':' + base.nv;
  if (!c || c.key !== key) { c = { key, mesh: base.clone(), stamp: -1 }; cache.set(def.id, c); }
  if (c.stamp !== s.stamp) {
    const D = c.mesh, P = D.P;
    blendShapes(base, s.weights, P);   // straight into the copy's points
    if (s.show) {
      // painting weights (AN.2): at rest, each face coloured by the bone's weight there (blue none … red all), on this copy
      // only; topo goes up so the view builds its colours again
      const W = base.attrArray('weight.' + s.show), cs = [];
      for (let f = 0; f < base.nf; f++) {
        if (base.faceDead(f)) continue;
        base.faceVerts(f, cs);
        let w = 0;
        for (const v of cs) w += W ? W[v] : 0;
        D.setFaceMat(f, D.paintIndex(RAMP[Math.round((w / (cs.length || 1)) * (RAMP.length - 1))]));
      }
      D.topo++;
    } else if (s.skin) s.skin.apply(base, P);
    D.live++;
    c.stamp = s.stamp;
  }
  return c.mesh;
}