three-slicer-viewer 0.3.2 → 0.3.3

package/dist/parse_3mf.worker.js

@@ -1,9 +1,71 @@
-import { p as f } from "./parse_3mf-BZISF3eW.js";
-self.onmessage = async (a) => {
-  const { id: s, buffer: r, baseName: t } = a.data || {};
+import { r as u, p } from "./parse_3mf-CpbA-6Iq.js";
+function b(r) {
+  if (!r) return [];
+  const t = [r.tris.buffer, ...r.modifiers.map((s) => s.tris.buffer)];
+  return r.baked && t.push(r.baked.localPos.buffer, r.baked.normals.buffer), t;
+}
+const g = 8;
+let i = null, h = 0;
+const c = /* @__PURE__ */ new Map();
+function w() {
+  if (i) return i;
+  i = [];
+  const r = Math.min(g, Math.max(1, (self.navigator?.hardwareConcurrency || 2) - 1));
   try {
-    const { objects: e, project: o } = await f(r, t);
-    self.postMessage({ id: s, objects: e, project: o }, e.map((c) => c.tris.buffer));
+    for (let t = 0; t < r; t++) {
+      const s = new Worker(self.location.href, { type: "module" }), n = { worker: s, failed: !1 };
+      s.onmessage = (o) => {
+        const { id: e, result: f, error: a } = o.data || {}, l = c.get(e);
+        l && (c.delete(e), a ? l.reject(new Error(a)) : l.resolve(f));
+      }, s.onerror = () => {
+        n.failed = !0;
+        for (const [o, e] of c) e.helper === n && (c.delete(o), e.reject(new Error("3MF helper failed")));
+      }, i.push(n);
+    }
+  } catch {
+    for (const t of i) t.worker.terminate();
+    i = [];
+  }
+  return i;
+}
+function M(r, t) {
+  const s = ++h;
+  return new Promise((n, o) => {
+    c.set(s, { resolve: n, reject: o, helper: r }), r.worker.postMessage({ type: "item-job", id: s, job: t }, t.members.map((e) => e.data.buffer));
+  });
+}
+async function k(r) {
+  const t = w().filter((e) => !e.failed);
+  if (!t.length) return Promise.all(r.map(u));
+  const s = new Array(r.length);
+  let n = 0;
+  const o = async (e) => {
+    for (; n < r.length; ) {
+      const f = n++, a = r[f], l = a.members.map((m) => m.data.slice());
+      try {
+        s[f] = await M(e, a);
+      } catch {
+        s[f] = await u({ ...a, members: a.members.map((m, d) => ({ ...m, data: l[d] })) });
+      }
+    }
+  };
+  return await Promise.all(t.slice(0, r.length).map(o)), s;
+}
+self.onmessage = async (r) => {
+  const t = r.data || {};
+  if (t.type === "item-job") {
+    try {
+      const e = await u(t.job);
+      self.postMessage({ id: t.id, result: e }, e.items.flatMap((f) => b(f.built)));
+    } catch (e) {
+      self.postMessage({ id: t.id, error: e && e.message || String(e) });
+    }
+    return;
+  }
+  const { id: s, buffer: n, baseName: o } = t;
+  try {
+    const { objects: e, project: f } = await p(n, o, { runJobs: k, bake: !0 });
+    self.postMessage({ id: s, objects: e, project: f }, e.flatMap((a) => [a.tris.buffer, a.baked.localPos.buffer, a.baked.normals.buffer]));
   } catch (e) {
     self.postMessage({ id: s, error: e && e.message || String(e) });
   }

package/dist/toolpath.js

@@ -1,113 +1,113 @@
-import { a as V, b as Mt, p as ot, h as Nt, T as bt, r as St, D as It } from "./toolpath_palette-B8xEl-qa.js";
-import { b as kt, a as Tt } from "./viewer_defaults-B7UUZ582.js";
-import { r as gt, S as nt, R as et, t as Pt } from "./toolpath_encoding-BuYs95qZ.js";
-import { T as Vt } from "./theme-2oyfMuvf.js";
-const rt = {};
-for (const t of Object.keys(V)) rt[t] = ot(V[t]);
-function _t(t) {
+import { a as Z, b as It, p as at, h as St, T as wt, r as Nt, D as Pt } from "./toolpath_palette-B8xEl-qa.js";
+import { b as Bt, a as Vt } from "./viewer_defaults-B7UUZ582.js";
+import { r as At, S as lt, R as et, t as _t } from "./toolpath_encoding-BuYs95qZ.js";
+import { T as kt } from "./theme-2oyfMuvf.js";
+const ct = {};
+for (const t of Object.keys(Z)) ct[t] = at(Z[t]);
+function Wt(t) {
   const e = new Float32Array(t.length);
-  for (let n = 0; n < t.length; n++) {
-    const r = Number(t[n]?.z) || 0, o = n > 0 && Number(t[n - 1]?.z) || 0, s = n > 0 ? r - o : r;
-    e[n] = s > 1e-6 ? s : Tt;
+  for (let o = 0; o < t.length; o++) {
+    const n = Number(t[o]?.z) || 0, r = o > 0 && Number(t[o - 1]?.z) || 0, c = o > 0 ? n - r : n;
+    e[o] = c > 1e-6 ? c : Vt;
   }
   return e;
 }
-const it = (t) => t?.paths?.length ? t.paths : null, wt = (t) => {
-  const e = it(t);
-  return e ? Math.floor(e.length / nt) : 0;
+const ft = (t) => t?.paths?.length ? t.paths : null, gt = (t) => {
+  const e = ft(t);
+  return e ? Math.floor(e.length / lt) : 0;
 };
-function jt(t, e) {
-  const n = Array.isArray(t) ? t : [], r = n.length, o = Number(e) > 0 ? Number(e) : kt, s = _t(n), f = new Uint32Array(r + 1), h = new Uint32Array(r + 1), c = new Uint32Array(r + 1);
-  let y = 0, l = 0, u = 0;
-  for (let v = 0; v < r; v++) {
-    const U = it(n[v]), w = wt(n[v]);
-    for (let D = 0; D < w; D++)
-      gt(U[D * nt + 3]) === et.TRAVEL ? l++ : y++;
-    u += w, f[v + 1] = y, h[v + 1] = l, c[v + 1] = u;
+function Ht(t, e) {
+  const o = Array.isArray(t) ? t : [], n = o.length, r = Number(e) > 0 ? Number(e) : Bt, c = Wt(o), h = new Uint32Array(n + 1), d = new Uint32Array(n + 1), u = new Uint32Array(n + 1);
+  let m = 0, s = 0, f = 0;
+  for (let p = 0; p < n; p++) {
+    const P = ft(o[p]), C = gt(o[p]);
+    for (let A = 0; A < C; A++)
+      At(P[A * lt + 3]) === et.TRAVEL ? s++ : m++;
+    f += C, h[p + 1] = m, d[p + 1] = s, u[p + 1] = f;
   }
-  const i = y * 2, b = new Float32Array(i * 4), x = new Float32Array(i * 4), p = new Uint32Array(i * 2), _ = new Uint8Array(i), M = new Uint8Array(i), O = new Float32Array(i), N = new Float32Array(i), z = new Int32Array(i), g = new Float32Array(l * 6), C = new Float32Array(u * 3), a = new Uint8Array(u), m = new Float64Array(16);
-  let A = !1, S = 0, I = 1 / 0, T = 1 / 0, W = 1 / 0, J = -1 / 0, Q = -1 / 0, $ = -1 / 0, L = 0, st = 0, lt = 0, B = 0;
-  for (let v = 0; v < r; v++) {
-    const U = n[v], w = it(U), D = wt(U), ct = U?.widths, E = s[v], ft = E / 2;
-    for (let R = 0; R < D; R++) {
-      const k = R * nt, X = w[k], Z = w[k + 1], q = w[k + 2], G = w[k + 4], Y = w[k + 5], H = w[k + 6], ut = w[k + 3] | 0, j = gt(ut), xt = Pt(ut);
-      if (Number.isFinite(X + Z + q + G + Y + H) || (A = !0), a[B] = j === et.TRAVEL ? 0 : 1, C[B * 3] = G, C[B * 3 + 1] = Y, C[B * 3 + 2] = H, B++, j === et.TRAVEL) {
-        const d = lt * 6;
-        g[d] = X, g[d + 1] = Z, g[d + 2] = q, g[d + 3] = G, g[d + 4] = Y, g[d + 5] = H, lt++;
+  const l = m * 2, L = new Float32Array(l * 4), I = new Float32Array(l * 4), v = new Uint32Array(l * 2), q = new Uint8Array(l), B = new Uint8Array(l), V = new Float32Array(l), ot = new Float32Array(l), T = new Int32Array(l), F = new Float32Array(s * 6), _ = new Float32Array(f * 3), j = new Uint8Array(f), nt = new Float64Array(16);
+  let J = !1, Y = 0, z = 1 / 0, k = 1 / 0, X = 1 / 0, W = -1 / 0, D = -1 / 0, i = -1 / 0, a = 0, b = 0, w = 0, x = 0;
+  for (let p = 0; p < n; p++) {
+    const P = o[p], C = ft(P), A = gt(P), Q = P?.widths, O = c[p], y = O / 2;
+    for (let g = 0; g < A; g++) {
+      const S = g * lt, G = C[S], rt = C[S + 1], it = C[S + 2], $ = C[S + 4], H = C[S + 5], R = C[S + 6], ht = C[S + 3] | 0, E = At(ht), Ct = _t(ht);
+      if (Number.isFinite(G + rt + it + $ + H + R) || (J = !0), j[x] = E === et.TRAVEL ? 0 : 1, _[x * 3] = $, _[x * 3 + 1] = H, _[x * 3 + 2] = R, x++, E === et.TRAVEL) {
+        const M = w * 6;
+        F[M] = G, F[M + 1] = rt, F[M + 2] = it, F[M + 3] = $, F[M + 4] = H, F[M + 5] = R, w++;
         continue;
       }
-      const tt = ct ? Number(ct[R]) : NaN, mt = Number.isFinite(tt) && tt > 0 ? tt : o, ht = G - X, pt = Y - Z, Ct = Math.atan2(pt, ht), vt = Math.hypot(ht, pt, H - q);
-      Number.isFinite(vt) && (m[j] += vt);
-      const Ft = rt[j] ?? rt[1];
-      for (const [d, P, yt] of [[X, Z, q], [G, Y, H]]) {
-        const F = L * 4;
-        b[F] = d, b[F + 1] = P, b[F + 2] = yt - ft, b[F + 3] = 0, x[F] = E, x[F + 1] = mt, x[F + 2] = Ct, x[F + 3] = Ft, p[L * 2] = st, p[L * 2 + 1] = v, _[L] = j, M[L] = xt, O[L] = mt, N[L] = E, z[L] = v, L++;
-        const K = yt - ft;
-        d < I && (I = d), d > J && (J = d), P < T && (T = P), P > Q && (Q = P), K < W && (W = K), K > $ && ($ = K);
-        const dt = Math.max(Math.abs(d), Math.abs(P), Math.abs(K));
-        dt > S && (S = dt);
+      const st = Q ? Number(Q[g]) : NaN, mt = Number.isFinite(st) && st > 0 ? st : r, pt = $ - G, yt = H - rt, Mt = Math.atan2(yt, pt), vt = Math.hypot(pt, yt, R - it);
+      Number.isFinite(vt) && (nt[E] += vt);
+      const Ft = ct[E] ?? ct[1];
+      for (const [M, K, dt] of [[G, rt, it], [$, H, R]]) {
+        const U = a * 4;
+        L[U] = M, L[U + 1] = K, L[U + 2] = dt - y, L[U + 3] = 0, I[U] = O, I[U + 1] = mt, I[U + 2] = Mt, I[U + 3] = Ft, v[a * 2] = b, v[a * 2 + 1] = p, q[a] = E, B[a] = Ct, V[a] = mt, ot[a] = O, T[a] = p, a++;
+        const tt = dt - y;
+        M < z && (z = M), M > W && (W = M), K < k && (k = K), K > D && (D = K), tt < X && (X = tt), tt > i && (i = tt);
+        const bt = Math.max(Math.abs(M), Math.abs(K), Math.abs(tt));
+        bt > Y && (Y = bt);
       }
-      st++;
+      b++;
     }
   }
-  const Lt = i > 0 && Number.isFinite(I) ? { min: [I, T, W], max: [J, Q, $] } : null;
+  const N = l > 0 && Number.isFinite(z) ? { min: [z, k, X], max: [W, D, i] } : null;
   return {
-    position: b,
-    hwa: x,
-    segIndex: p,
-    nV: i,
-    nSeg: y,
-    layerSegPrefix: f,
-    travelPos: g,
-    travelPrefix: h,
-    nTrav: l,
-    movePos: C,
-    moveKind: a,
-    movePrefix: c,
-    layerCount: r,
-    maxAbs: S,
-    hasNaN: A,
-    typeLengths: m,
-    bbox: Lt,
-    meta: { vType: _, vTool: M, vWidth: O, vHeight: N, vLayer: z }
+    position: L,
+    hwa: I,
+    segIndex: v,
+    nV: l,
+    nSeg: m,
+    layerSegPrefix: h,
+    travelPos: F,
+    travelPrefix: d,
+    nTrav: s,
+    movePos: _,
+    moveKind: j,
+    movePrefix: u,
+    layerCount: n,
+    maxAbs: Y,
+    hasNaN: J,
+    typeLengths: nt,
+    bbox: N,
+    meta: { vType: q, vTool: B, vWidth: V, vHeight: ot, vLayer: T }
   };
 }
-function Kt(t) {
+function Rt(t) {
   const e = t ?? [];
-  let n = 0;
-  for (let o = 0; o < 16; o++) n += Number(e[o]) || 0;
-  if (n <= 0) return [];
-  const r = [];
-  for (let o = 0; o < 16; o++) {
-    const s = Number(e[o]) || 0;
-    s <= 0 || r.push({ type: o, label: Mt[o] ?? String(o), pct: s / n * 100, color: V[o] ?? V[1] });
+  let o = 0;
+  for (let r = 0; r < 16; r++) o += Number(e[r]) || 0;
+  if (o <= 0) return [];
+  const n = [];
+  for (let r = 0; r < 16; r++) {
+    const c = Number(e[r]) || 0;
+    c <= 0 || n.push({ type: r, label: It[r] ?? String(r), pct: c / o * 100, color: Z[r] ?? Z[1] });
   }
-  return r.sort((o, s) => s.pct - o.pct);
+  return n.sort((r, c) => c.pct - r.pct);
 }
-const at = (t, e) => e >= 0 && e < t.layerCount ? t.movePrefix[e + 1] - t.movePrefix[e] : 0;
-function Rt(t, e) {
-  return at(t, e);
+const ut = (t, e) => e >= 0 && e < t.layerCount ? t.movePrefix[e + 1] - t.movePrefix[e] : 0;
+function Et(t, e) {
+  return ut(t, e);
 }
-function Xt(t, e, n) {
-  const r = Math.min(n, t.layerCount - 1);
-  for (let o = r; o >= e; o--) if (at(t, o) > 0) return o;
+function te(t, e, o) {
+  const n = Math.min(o, t.layerCount - 1);
+  for (let r = n; r >= e; r--) if (ut(t, r) > 0) return r;
   return e;
 }
-function Zt(t, e, n) {
-  const r = at(t, e), o = Math.max(0, Math.min(Number(n) || 0, r)), s = e >= 0 && e < t.layerCount ? t.movePrefix[e] : 0;
-  let f = 0, h = 0;
-  for (let y = 0; y < o; y++)
-    t.moveKind[s + y] === 0 ? h++ : f++;
-  if (o === 0) return { point: null, segCount: 0, travCount: 0, onTravel: !1 };
-  const c = s + o - 1;
+function ee(t, e, o) {
+  const n = ut(t, e), r = Math.max(0, Math.min(Number(o) || 0, n)), c = e >= 0 && e < t.layerCount ? t.movePrefix[e] : 0;
+  let h = 0, d = 0;
+  for (let m = 0; m < r; m++)
+    t.moveKind[c + m] === 0 ? d++ : h++;
+  if (r === 0) return { point: null, segCount: 0, travCount: 0, onTravel: !1 };
+  const u = c + r - 1;
   return {
-    point: [t.movePos[c * 3], t.movePos[c * 3 + 1], t.movePos[c * 3 + 2]],
-    segCount: f,
-    travCount: h,
-    onTravel: t.moveKind[c] === 0
+    point: [t.movePos[u * 3], t.movePos[u * 3 + 1], t.movePos[u * 3 + 2]],
+    segCount: h,
+    travCount: d,
+    onTravel: t.moveKind[u] === 0
   };
 }
-const At = [
+const Lt = [
   { key: "feature", label: "Feature type", cont: !1, unit: "" },
   { key: "speed", label: "Speed", cont: !0, unit: "mm/s" },
   { key: "height", label: "Layer Height", cont: !0, unit: "mm" },
@@ -119,47 +119,47 @@ const At = [
   //  extruder index is a label, and a heatmap over it would imply tool 2 sits "between" tools 1 and 3.
   { key: "filament", label: "Filament", cont: !1, unit: "" }
 ];
-function Ot(t, e, n, r) {
-  const o = e.vType[n], s = e.vLayer[n], f = s === 0;
+function Ot(t, e, o, n) {
+  const r = e.vType[o], c = e.vLayer[o], h = c === 0;
   switch (t) {
     case "height":
-      return e.vHeight[n];
+      return e.vHeight[o];
     case "width":
-      return e.vWidth[n];
+      return e.vWidth[o];
     case "speed":
-      return f ? r.firstLayerSpeed : r.speedByType[o] ?? r.speedByType[1];
+      return h ? n.firstLayerSpeed : n.speedByType[r] ?? n.speedByType[1];
     case "fan":
-      return s < r.closeFanLayers ? 0 : o === 9 ? 100 : r.fanNormal;
+      return c < n.closeFanLayers ? 0 : r === 9 ? 100 : n.fanNormal;
     case "temp":
-      return f ? r.tempFirst : r.tempNormal;
+      return h ? n.tempFirst : n.tempNormal;
     default:
       return 0;
   }
 }
-function qt(t, e, n) {
-  const { meta: r, nV: o } = t, s = new Float32Array(o * 4), f = At.find((l) => l.key === e) || At[0];
-  if (!f.cont) {
-    const l = (n?.toolColors ?? []).map((i) => i && Nt(i)), u = f.key === "filament" ? (i) => {
-      const b = r.vTool ? r.vTool[i] : 0;
-      return l[b] || bt[b % bt.length];
-    } : (i) => V[r.vType[i]] || V[1];
-    for (let i = 0; i < o; i++) s[i * 4] = ot(u(i));
-    return { color: s, min: 0, max: 0, viewType: e, label: f.label, unit: f.unit, cont: !1 };
+function oe(t, e, o) {
+  const { meta: n, nV: r } = t, c = new Float32Array(r * 4), h = Lt.find((s) => s.key === e) || Lt[0];
+  if (!h.cont) {
+    const s = (o?.toolColors ?? []).map((l) => l && St(l)), f = h.key === "filament" ? (l) => {
+      const L = n.vTool ? n.vTool[l] : 0;
+      return s[L] || wt[L % wt.length];
+    } : (l) => Z[n.vType[l]] || Z[1];
+    for (let l = 0; l < r; l++) c[l * 4] = at(f(l));
+    return { color: c, min: 0, max: 0, viewType: e, label: h.label, unit: h.unit, cont: !1 };
   }
-  let h = 1 / 0, c = -1 / 0;
-  const y = new Float32Array(o);
-  for (let l = 0; l < o; l++) {
-    const u = Ot(e, r, l, n), i = Number.isFinite(u) ? u : 0;
-    y[l] = i, i < h && (h = i), i > c && (c = i);
+  let d = 1 / 0, u = -1 / 0;
+  const m = new Float32Array(r);
+  for (let s = 0; s < r; s++) {
+    const f = Ot(e, n, s, o), l = Number.isFinite(f) ? f : 0;
+    m[s] = l, l < d && (d = l), l > u && (u = l);
   }
-  Number.isFinite(h) || (h = 0, c = 1);
-  for (let l = 0; l < o; l++) {
-    const u = St(y[l], h, c, It);
-    s[l * 4] = ot(u);
+  Number.isFinite(d) || (d = 0, u = 1);
+  for (let s = 0; s < r; s++) {
+    const f = Nt(m[s], d, u, Pt);
+    c[s * 4] = at(f);
   }
-  return { color: s, min: h, max: c, viewType: e, label: f.label, unit: f.unit, cont: !0 };
+  return { color: c, min: d, max: u, viewType: e, label: h.label, unit: h.unit, cont: !0 };
 }
-const zt = `
+const Ut = `
 precision highp float;
 
 uniform mat4 projectionMatrix;
@@ -219,7 +219,7 @@ void main() {
   vColor = unpackColor(iColor);
   gl_Position = projectionMatrix * modelViewMatrix * vec4(world, 1.0);
 }
-`, Wt = `
+`, zt = `
 precision highp float;
 
 in vec3 vColor;
@@ -227,15 +227,48 @@ in vec3 vNormal;
 out vec4 fragColor;
 
 void main() {
-  // Two-sided: the layer slider cuts the plate open, so back faces are seen and must not go black.
+  // Front faces only (the material culls the rest), so the normal never needs flipping.
   vec3 n = normalize(vNormal);
-  if (!gl_FrontFacing) n = -n;
   // A single head-on light plus a generous ambient. The point is to read the bead's ROUNDING — which
   //  face is up, which is the side — not to look lit.
   float lambert = max(dot(n, normalize(vec3(0.35, 0.35, 1.0))), 0.0);
   fragColor = vec4(vColor * (0.55 + 0.45 * lambert), 1.0);
 }
-`, Bt = new Float32Array([
+`, xt = [2, 4], Dt = 1.5;
+function Gt(t, e) {
+  let o = 0;
+  for (let n = 0; n < t.length; n += 2)
+    (t[n] === et.RAFT || t[n] === et.SKIRT) && e[n] > o && (o = e[n]);
+  return o;
+}
+function Tt(t, e, o, n) {
+  let r = 0;
+  for (let s = 0; s < e; s++) t(s) > r && (r = t(s));
+  const c = (s) => s <= n || (r - s) % o === 0;
+  let h = 0;
+  for (let s = 0; s < e; s++) c(t(s)) && h++;
+  const d = new Uint32Array(h), u = new Uint8Array(h);
+  let m = 0;
+  for (let s = 0; s < e; s++) {
+    const f = t(s);
+    c(f) && (d[m] = s, u[m] = 1, f > n && (u[m] = Math.min(o, f - n)), m++);
+  }
+  return { source: d, layers: u };
+}
+function jt(t, e) {
+  const o = Math.max(1, Math.floor(e / 4096)), n = [];
+  for (let r = 0; r < e; r += o) n.push(t(r));
+  return n.length ? (n.sort((r, c) => r - c), n[n.length >> 1]) : 0;
+}
+function Yt(t, e, o, n) {
+  return e > 0 ? t * (n / 2) / (e * Math.tan(o * Math.PI / 360)) : 1 / 0;
+}
+function Xt(t, e = xt) {
+  let o = 1;
+  for (const n of e) n * t <= Dt && n > o && (o = n);
+  return o;
+}
+const Kt = new Float32Array([
   0,
   0,
   0,
@@ -254,80 +287,119 @@ void main() {
   1,
   3
   // end ring
-]), Ut = (() => {
+]), Zt = (() => {
   const t = [];
   for (let e = 0; e < 4; e++) {
-    const n = e, r = (e + 1) % 4, o = 4 + (e + 1) % 4, s = 4 + e;
-    t.push(n, r, o, n, o, s);
+    const o = e, n = (e + 1) % 4, r = 4 + (e + 1) % 4, c = 4 + e;
+    t.push(o, n, r, o, r, c);
   }
   return t;
 })();
-function Jt(t, e) {
-  const { nSeg: n, nV: r, position: o, hwa: s, travelPos: f, travelPrefix: h, layerCount: c, meta: y } = e, l = new Float32Array(n * 3), u = new Float32Array(n * 3), i = new Float32Array(n * 2), b = new Float32Array(n), x = new Float32Array(n);
-  for (let a = 0; a < n; a++) {
-    const m = a * 2 * 4, A = (a * 2 + 1) * 4;
-    l[a * 3] = o[m], l[a * 3 + 1] = o[m + 1], l[a * 3 + 2] = o[m + 2], u[a * 3] = o[A], u[a * 3 + 1] = o[A + 1], u[a * 3 + 2] = o[A + 2], i[a * 2] = s[m], i[a * 2 + 1] = s[m + 1], b[a] = s[m + 3], x[a] = y.vLayer[a * 2];
+function ne(t, e) {
+  const { nSeg: o, nV: n, position: r, hwa: c, travelPos: h, travelPrefix: d, layerCount: u, meta: m } = e, s = new Float32Array(o * 3), f = new Float32Array(o * 3), l = new Float32Array(o * 2), L = new Float32Array(o), I = new Float32Array(o);
+  for (let i = 0; i < o; i++) {
+    const a = i * 2 * 4, b = (i * 2 + 1) * 4;
+    s[i * 3] = r[a], s[i * 3 + 1] = r[a + 1], s[i * 3 + 2] = r[a + 2], f[i * 3] = r[b], f[i * 3 + 1] = r[b + 1], f[i * 3 + 2] = r[b + 2], l[i * 2] = c[a], l[i * 2 + 1] = c[a + 1], L[i] = c[a + 3], I[i] = m.vLayer[i * 2];
   }
-  const p = new t.InstancedBufferGeometry();
-  p.setAttribute("tpl", new t.BufferAttribute(Bt, 2)), p.setIndex(Ut), p.setAttribute("iStart", new t.InstancedBufferAttribute(l, 3)), p.setAttribute("iEnd", new t.InstancedBufferAttribute(u, 3)), p.setAttribute("iHW", new t.InstancedBufferAttribute(i, 2));
-  const _ = new t.InstancedBufferAttribute(b, 1);
-  p.setAttribute("iColor", _), p.setAttribute("iLayer", new t.InstancedBufferAttribute(x, 1)), p.instanceCount = n, p.boundingSphere = new t.Sphere(new t.Vector3(0, 0, 0), (e.maxAbs || 1) * 2);
-  const M = new t.RawShaderMaterial({
-    vertexShader: zt,
-    fragmentShader: Wt,
+  const v = new t.InstancedBufferGeometry();
+  v.setAttribute("tpl", new t.BufferAttribute(Kt, 2)), v.setIndex(Zt), v.setAttribute("iStart", new t.InstancedBufferAttribute(s, 3)), v.setAttribute("iEnd", new t.InstancedBufferAttribute(f, 3)), v.setAttribute("iHW", new t.InstancedBufferAttribute(l, 2));
+  const q = new t.InstancedBufferAttribute(L, 1);
+  v.setAttribute("iColor", q), v.setAttribute("iLayer", new t.InstancedBufferAttribute(I, 1)), v.instanceCount = o, v.boundingSphere = new t.Sphere(new t.Vector3(0, 0, 0), (e.maxAbs || 1) * 2);
+  const B = new t.RawShaderMaterial({
+    vertexShader: Ut,
+    fragmentShader: zt,
     glslVersion: t.GLSL3,
-    side: t.DoubleSide,
-    uniforms: { uLayerLo: { value: 0 }, uLayerHi: { value: Math.max(0, c - 1) } }
-  }), O = new t.Mesh(p, M);
-  O.frustumCulled = !1;
-  const N = new t.BufferGeometry();
-  N.setAttribute("position", new t.BufferAttribute(f, 3));
-  const z = new t.LineBasicMaterial({ color: Vt.travel, transparent: !0, opacity: 0.6 }), g = new t.LineSegments(N, z);
-  g.visible = !1, g.frustumCulled = !1;
-  const C = (a, m) => {
-    const A = Math.max(0, c - 1), S = Math.max(0, Math.min(a | 0, A)), I = Math.max(S, Math.min(m | 0, A));
-    M.uniforms.uLayerLo.value = S, M.uniforms.uLayerHi.value = I;
-    const T = h[S] * 2, W = h[I + 1] * 2;
-    N.setDrawRange(T, Math.max(0, W - T));
+    // Every face of the template winds outward (test_toolpath_contract.mjs), so a back face is only ever the
+    //  inside of a bead seen through its open end. Drawing those doubled the GPU time of a frame: measured on a
+    //  14.6M-segment scene (6 plates, M5 Pro, DPR 2), 53.6 -> 29.4 ms with back faces culled.
+    side: t.FrontSide,
+    uniforms: { uLayerLo: { value: 0 }, uLayerHi: { value: Math.max(0, u - 1) } }
+  }), V = new t.Mesh(v, B);
+  V.frustumCulled = !1;
+  const ot = Gt(m.vType, m.vLayer), T = xt.map((i) => {
+    const { source: a, layers: b } = Tt((y) => I[y], o, i, ot), w = a.length, x = new Float32Array(w * 3), N = new Float32Array(w * 3), p = new Float32Array(w * 2), P = new Float32Array(w), C = new Float32Array(w);
+    for (let y = 0; y < w; y++) {
+      const g = a[y], S = l[g * 2], G = (b[y] - 1) * S / 2;
+      x[y * 3] = s[g * 3], x[y * 3 + 1] = s[g * 3 + 1], x[y * 3 + 2] = s[g * 3 + 2] - G, N[y * 3] = f[g * 3], N[y * 3 + 1] = f[g * 3 + 1], N[y * 3 + 2] = f[g * 3 + 2] - G, p[y * 2] = S * b[y], p[y * 2 + 1] = l[g * 2 + 1], P[y] = L[g], C[y] = I[g];
+    }
+    const A = new t.InstancedBufferGeometry();
+    A.setAttribute("tpl", v.attributes.tpl), A.setIndex(v.index), A.setAttribute("iStart", new t.InstancedBufferAttribute(x, 3)), A.setAttribute("iEnd", new t.InstancedBufferAttribute(N, 3)), A.setAttribute("iHW", new t.InstancedBufferAttribute(p, 2));
+    const Q = new t.InstancedBufferAttribute(P, 1);
+    A.setAttribute("iColor", Q), A.setAttribute("iLayer", new t.InstancedBufferAttribute(C, 1)), A.instanceCount = w;
+    const O = new t.Mesh(A, B);
+    return O.frustumCulled = !1, O.visible = !1, V.add(O), { k: i, mesh: O, source: a, colors: P, colorAttr: Q };
+  });
+  let F = 1, _ = !0;
+  const j = (i) => {
+    if (i !== F) {
+      F = i;
+      for (const a of T) a.mesh.visible = a.k === i;
+      v.instanceCount = 0, i === 1 && (v.instanceCount = o);
+    }
+  }, nt = jt((i) => l[i * 2], o), J = e.bbox && new t.Box3(new t.Vector3(...e.bbox.min), new t.Vector3(...e.bbox.max)), Y = new t.Box3(), z = (i, a) => {
+    if (!_ || !J || !i?.isPerspectiveCamera) {
+      j(1);
+      return;
+    }
+    Y.copy(J).applyMatrix4(V.matrixWorld), j(Xt(Yt(nt, Y.distanceToPoint(i.position), i.fov, a)));
+  };
+  V.userData.updateLod = z;
+  const k = new t.BufferGeometry();
+  k.setAttribute("position", new t.BufferAttribute(h, 3));
+  const X = new t.LineBasicMaterial({ color: kt.travel, transparent: !0, opacity: 0.6 }), W = new t.LineSegments(k, X);
+  W.visible = !1, W.frustumCulled = !1;
+  const D = (i, a) => {
+    const b = Math.max(0, u - 1), w = Math.max(0, Math.min(i | 0, b)), x = Math.max(w, Math.min(a | 0, b));
+    B.uniforms.uLayerLo.value = w, B.uniforms.uLayerHi.value = x, _ = w === 0 && x === b, _ || j(1);
+    const N = d[w] * 2, p = d[x + 1] * 2;
+    k.setDrawRange(N, Math.max(0, p - N));
   };
-  return C(0, c - 1), {
-    mesh: O,
-    travLines: g,
-    setLayerRange: C,
-    setVisibleLayers: (a) => C(0, (a | 0) - 1),
-    setTravelVisible: (a) => {
-      g.visible = !!a;
+  return D(0, u - 1), {
+    mesh: V,
+    travLines: W,
+    setLayerRange: D,
+    setVisibleLayers: (i) => D(0, (i | 0) - 1),
+    setTravelVisible: (i) => {
+      W.visible = !!i;
     },
     /** color is Float32Array(nV*4) with the packed value in .r — computeColors' output shape. One instance
      *  takes the colour of its first vertex; the two agree, since a segment is one colour. */
-    setColors: (a) => {
-      if (!(!a || a.length < r * 4)) {
-        for (let m = 0; m < n; m++) b[m] = a[m * 2 * 4];
-        _.needsUpdate = !0;
+    setColors: (i) => {
+      if (!(!i || i.length < n * 4)) {
+        for (let a = 0; a < o; a++) L[a] = i[a * 2 * 4];
+        q.needsUpdate = !0;
+        for (const a of T) {
+          for (let b = 0; b < a.source.length; b++) a.colors[b] = L[a.source[b]];
+          a.colorAttr.needsUpdate = !0;
+        }
       }
     },
+    /** Call once per frame before rendering; viewportPixels is the drawing buffer's height. */
+    updateLod: z,
+    lodLevel: () => F,
     dispose: () => {
-      p.dispose(), M.dispose(), N.dispose(), z.dispose();
+      for (const i of T) i.mesh.geometry.dispose();
+      v.dispose(), B.dispose(), k.dispose(), X.dispose();
     },
-    nSeg: n,
-    layerCount: c
+    nSeg: o,
+    layerCount: u
   };
 }
 export {
-  It as DEFAULT_RANGES_COLORS,
-  bt as TOOL_COLOR,
-  V as TYPE_COLOR,
-  Mt as TYPE_LABEL,
-  Ut as VERTEX_DATA,
-  At as VIEW_TYPES,
-  jt as buildSegmentData,
-  qt as computeColors,
-  Nt as hexToRgb,
-  Rt as layerMoveCount,
-  Jt as makeToolpath,
-  Zt as moveCursor,
-  ot as packColor,
-  St as rangeColorAt,
-  Kt as roleRatios,
-  Xt as topMoveLayer
+  Pt as DEFAULT_RANGES_COLORS,
+  wt as TOOL_COLOR,
+  Z as TYPE_COLOR,
+  It as TYPE_LABEL,
+  Zt as VERTEX_DATA,
+  Lt as VIEW_TYPES,
+  Ht as buildSegmentData,
+  oe as computeColors,
+  St as hexToRgb,
+  Et as layerMoveCount,
+  ne as makeToolpath,
+  ee as moveCursor,
+  at as packColor,
+  Nt as rangeColorAt,
+  Rt as roleRatios,
+  te as topMoveLayer
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "three-slicer-viewer",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "description": "The three-slicer viewer without the slicer — model loading, G-code parsing, GPU toolpath rendering and the settings transforms, under MIT. Plug a slicer in through the `slicer` prop.",
   "license": "MIT",
   "type": "module",
@@ -35,6 +35,10 @@
       "types": "./types/toggle.d.ts",
       "default": "./src/settings/toggle_eval.js"
     },
+    "./paint": {
+      "types": "./types/paint.d.ts",
+      "default": "./src/core/paint_tools.js"
+    },
     "./components": {
       "types": "./types/components.d.ts",
       "default": "./dist/components.js"
@@ -49,6 +53,7 @@
     "VIEWER.md",
     "data",
     "dist",
+    "src/core/paint_tools.js",
     "src/data.js",
     "src/settings",
     "types",