Proportional editing weights and edge creases

/**
 * Proportional editing: how much each vertex follows a move of the selected ones (1 for them, falling to 0 at `radius`):
 * by straight distance, or along edges when `connected`. → Float32Array per vertex slot (0 = stays).
 */
export function falloffWeights(m, sel, radius, { mode = 'smooth', connected = false } = {}) {
  const W = new Float32Array(m.nv), D = new Float64Array(m.nv).fill(Infinity);
  const f = (t) => { const x = 1 - t; switch (mode) { case 'sphere': return Math.sqrt(Math.max(0, 1 - t * t)); case 'root': return Math.sqrt(x); case 'linear': return x; case 'sharp': return x * x; case 'constant': return 1; default: return x * x * (3 - 2 * x); } };
  const S = [...new Set(sel)];
  for (const v of S) { D[v] = 0; W[v] = 1; }
  if (!(radius > 0)) return W;
  if (connected) {
    // shortest distance along edges (a plain heap of [distance, vertex])
    const heap = S.map((v) => [0, v]);
    const pop = () => { let bi = 0; for (let i = 1; i < heap.length; i++) if (heap[i][0] < heap[bi][0]) bi = i; return heap.splice(bi, 1)[0]; };
    while (heap.length) {
      const [d, v] = pop();
      if (d > D[v] || d > radius) continue;
      for (const h of m.outgoing(v)) {
        const w = m.head(h), nd = d + len(sub(P3(m, w), P3(m, v)));
        if (nd < D[w] && nd <= radius) { D[w] = nd; heap.push([nd, w]); }
      }
    }
  } else {
    // straight distance to the nearest selected vertex (a grid of the selected ones)
    const cell = radius, grid = new Map(), key = (x, y, z) => x + ',' + y + ',' + z;
    for (const v of S) { const c = P3(m, v).map((x) => Math.floor(x / cell)); const k = key(...c); if (!grid.has(k)) grid.set(k, []); grid.get(k).push(v); }
    for (let v = 0; v < m.nv; v++) {
      if (m.vertDead(v) || D[v] === 0) continue;
      const p = P3(m, v), c = p.map((x) => Math.floor(x / cell));
      for (let dx = -1; dx <= 1; dx++) for (let dy = -1; dy <= 1; dy++) for (let dz = -1; dz <= 1; dz++) for (const s of grid.get(key(c[0] + dx, c[1] + dy, c[2] + dz)) || []) { const d = len(sub(P3(m, s), p)); if (d < D[v]) D[v] = d; }
    }
  }
  for (let v = 0; v < m.nv; v++) if (D[v] > 0 && D[v] <= radius) W[v] = f(D[v] / radius);
  return W;
}

/** Crease edges for subdivision (0.7 MD.4): the 'crease' edge layer (0 smooth … 1 sharp for four levels) on each edge. */
export function setCrease(m, edges, value) {
  const v = Math.max(0, Math.min(1, +value || 0));
  if (!m.hasAttr('crease')) { if (!v) return 0; m.addAttr('crease', 'edge', 1); }
  for (const h of edges) m.setAttr('crease', h, [v]);
  return edges.length;
}

/** The crease shared by edges, or null when they differ (or there are none). */
export function creaseOfEdges(m, edges) {
  const a = m.attrArray('crease');
  let v = null;
  for (const h of edges) { const x = a ? a[h] : 0; if (v === null) v = x; else if (Math.abs(x - v) > 1e-6) return null; }
  return v;
}

const T = this.matrixFor(ev), W = this.weights, inv = this.inv;
this.h.model.meshPreview(this.tool.defId, (me) => {
  for (const [v, p] of this.base) {
    const q = T(p), w = W ? W[v] : 1, r = w === 1 ? q : add(p, mul(sub(q, p), w)), l = apply(inv, r);
    me.setPos(v, l[0], l[1], l[2]);
  }

fromPointer: (op, px) => ({ crease: Math.max(0, Math.min(1, Math.round(px / 2) / 100)) }), lengthParam: 'crease',
format: (p) => p.crease.toFixed(2),
run: (me, p) => O.setCrease(me, p.edges, p.crease),
wheel: (p, dir) => ({ crease: Math.max(0, Math.min(1, Math.round((p.crease + dir * 0.1) * 10) / 10)) }),