three-slicer 0.1.3 → 0.1.4

package/viewer/dist/gcode_parse.js

@@ -0,0 +1,190 @@
+const it = {
+  // OrcaSlicer / PrusaSlicer ;TYPE: names
+  "outer wall": 1,
+  "external perimeter": 1,
+  "inner wall": 1,
+  perimeter: 1,
+  "internal perimeter": 1,
+  "overhang wall": 1,
+  "overhang perimeter": 1,
+  "sparse infill": 2,
+  "internal infill": 2,
+  "solid infill": 3,
+  "internal solid infill": 3,
+  "top solid infill": 3,
+  "top surface": 3,
+  "bottom surface": 3,
+  skirt: 4,
+  brim: 4,
+  "skirt/brim": 4,
+  support: 5,
+  "support material": 5,
+  "support material interface": 5,
+  "support interface": 5,
+  "support transition": 5,
+  raft: 6,
+  "gap fill": 7,
+  "gap infill": 7,
+  "thin wall": 8,
+  bridge: 9,
+  "bridge infill": 9,
+  "internal bridge": 9,
+  "internal bridge infill": 9,
+  ironing: 10,
+  "prime tower": 11,
+  "wipe tower": 11,
+  custom: 1,
+  // Cura ;TYPE: names
+  "wall-outer": 1,
+  "wall-inner": 1,
+  fill: 2,
+  skin: 3,
+  "support-interface": 5,
+  "prime-tower": 11
+}, nt = [
+  ["skirt/brim", 4],
+  ["skirt", 4],
+  ["walls", 1],
+  ["thin-wall", 8],
+  ["gap-fill", 7],
+  ["bridge", 9],
+  ["ironing", 10],
+  ["support", 5],
+  ["prime tower", 11],
+  ["wipe_tower_real", 11]
+], st = (w, c) => w === c || c.length < w.length && " (:/".includes(w[c.length]) && w.startsWith(c), at = {
+  1: 1,
+  2: 1,
+  3: 1,
+  4: 2,
+  5: 3,
+  6: 3,
+  7: 3,
+  8: 10,
+  9: 9,
+  10: 9,
+  11: 7,
+  12: 4,
+  13: 4,
+  14: 5,
+  15: 5,
+  16: 5,
+  17: 11
+};
+function rt(w, c = {}) {
+  const V = Math.PI / 4 * (c.filamentDiameter > 0 ? c.filamentDiameter : 1.75) ** 2, tt = c.defaultLayerHeight > 0 ? c.defaultLayerHeight : 0.2;
+  let f = 0, u = 0, m = 0, L = 0, x = !0, v = !0, E = 0, P = 1, S = 0, p = null;
+  const g = [];
+  let z = !1, I = !0, R = NaN, q = 0, H = 0, O = 0;
+  const j = /* @__PURE__ */ new Set([0]), W = (s) => {
+    p = { z: s, p: [], w: [] }, g.push(p), I = !1, R = NaN, P = 1, S = 0;
+  }, et = () => g.length > 1 ? g[g.length - 2].z : 0, C = (s, o, d, b, N, e, t) => {
+    const a = Math.hypot(b - s, N - o, e - d);
+    if (!(a < 1e-6))
+      if (t > 1e-6) {
+        O += t, I ? W(Number.isNaN(R) ? e : R) : !z && e > p.z + 1e-3 && W(e);
+        const r = P + E * 16;
+        p.p.push(s, o, d, r, b, N, e, r);
+        const i = Math.max(0.02, p.z - et() || tt), F = S > 0 ? S : t * V / (a * i) + i * (1 - Math.PI / 4);
+        p.w.push(Math.min(3, Math.max(0.05, F))), q++;
+      } else p && (p.p.push(s, o, d, E * 16, b, N, e, E * 16), p.w.push(0), H++);
+  };
+  for (const s of w.split(`
+`)) {
+    const o = s.indexOf(";"), d = (o < 0 ? s : s.slice(0, o)).trim(), b = o < 0 ? "" : s.slice(o + 1).trim();
+    if (b && !d) {
+      const t = b.toLowerCase();
+      if (t.startsWith("type:")) {
+        P = it[t.slice(5).trim()] ?? 1;
+        continue;
+      }
+      if (t.startsWith("_extrusion_role:")) {
+        P = at[parseInt(t.slice(16), 10)] ?? 1;
+        continue;
+      }
+      if (t.startsWith("width:")) {
+        const i = parseFloat(t.slice(6));
+        S = i > 0 ? i : 0;
+        continue;
+      }
+      if (t.startsWith("layer_change") || t.startsWith("layer:")) {
+        z = !0, I = !0;
+        continue;
+      }
+      if (t.startsWith("z:")) {
+        const i = parseFloat(t.slice(2));
+        I && i > 0 && (z = !0, W(i));
+        continue;
+      }
+      const a = /^layer \d+ z([-\d.]+)/.exec(t);
+      if (a) {
+        z = !0, W(parseFloat(a[1]));
+        continue;
+      }
+      const r = nt.find(([i]) => st(t, i));
+      r && (P = r[1]);
+      continue;
+    }
+    if (!d) continue;
+    const N = d.split(/\s+/), e = N[0].toUpperCase();
+    if (e === "G90") {
+      x = !0;
+      continue;
+    }
+    if (e === "G91") {
+      x = !1;
+      continue;
+    }
+    if (e === "M82") {
+      v = !0;
+      continue;
+    }
+    if (e === "M83") {
+      v = !1;
+      continue;
+    }
+    if (/^T\d+$/.test(e)) {
+      E = parseInt(e.slice(1), 10), j.add(E);
+      continue;
+    }
+    if (e === "G92" || e === "G0" || e === "G1" || e === "G2" || e === "G3") {
+      let t = NaN, a = NaN, r = NaN, i = NaN, F = 0, D = 0;
+      for (let h = 1; h < N.length; h++) {
+        const n = N[h][0], l = parseFloat(N[h].slice(1));
+        Number.isNaN(l) || (n === "X" || n === "x" ? t = l : n === "Y" || n === "y" ? a = l : n === "Z" || n === "z" ? r = l : n === "E" || n === "e" ? i = l : n === "I" || n === "i" ? F = l : (n === "J" || n === "j") && (D = l));
+      }
+      if (e === "G92") {
+        Number.isNaN(t) || (f = t), Number.isNaN(a) || (u = a), Number.isNaN(r) || (m = r), Number.isNaN(i) || (L = i);
+        continue;
+      }
+      const k = Number.isNaN(t) ? f : x ? t : f + t, A = Number.isNaN(a) ? u : x ? a : u + a, Z = Number.isNaN(r) ? m : x ? r : m + r, K = Number.isNaN(i) ? 0 : v ? i - L : i;
+      if (e === "G2" || e === "G3") {
+        const h = f + F, n = u + D, l = Math.hypot(f - h, u - n), _ = Math.atan2(u - n, f - h);
+        let M = Math.atan2(A - n, k - h);
+        const T = e === "G3";
+        T && M <= _ + 1e-6 && (M += 2 * Math.PI), !T && M >= _ - 1e-6 && (M -= 2 * Math.PI);
+        const y = Math.max(1, Math.min(360, Math.ceil(Math.abs(M - _) * l / 0.3)));
+        let X = f, Y = u, J = m;
+        for (let G = 1; G <= y; G++) {
+          const U = _ + (M - _) * G / y, $ = G === y ? k : h + l * Math.cos(U), B = G === y ? A : n + l * Math.sin(U), Q = m + (Z - m) * G / y;
+          C(X, Y, J, $, B, Q, K / y), X = $, Y = B, J = Q;
+        }
+      } else
+        C(f, u, m, k, A, Z, K);
+      f = k, u = A, m = Z, Number.isNaN(i) || (L = v ? i : L + i);
+    }
+  }
+  return {
+    layers: g.map((s) => ({ z: s.z, paths: Float32Array.from(s.p), widths: Float32Array.from(s.w) })),
+    stats: {
+      layers: g.length,
+      path_segments: q,
+      travel_segments: H,
+      filament_mm: O,
+      tools: [...j].sort((s, o) => s - o)
+    }
+  };
+}
+export {
+  rt as parseGcode
+};

package/viewer/dist/toolpath_gpu.js

@@ -1,4 +1,4 @@
-const U = {
+const W = {
   0: [0.42, 0.45, 0.5],
   1: [0.85, 0.51, 0.17],
   2: [0.21, 0.45, 0.76],
@@ -11,12 +11,27 @@ const U = {
   9: [0.9, 0.25, 0.25],
   10: [0.6, 0.82, 0.55],
   11: [0.3, 0.72, 0.7]
-};
-function ie(t) {
-  const i = Math.round(t[0] * 255), s = Math.round(t[1] * 255), n = Math.round(t[2] * 255);
-  return i << 16 | s << 8 | n;
+}, _e = [
+  [0.85, 0.28, 0.25],
+  [0.2, 0.52, 0.85],
+  [0.25, 0.72, 0.38],
+  [0.96, 0.74, 0.16],
+  [0.62, 0.36, 0.82],
+  [0.18, 0.74, 0.74],
+  [0.95, 0.5, 0.15],
+  [0.55, 0.56, 0.6]
+];
+function de(t) {
+  const i = String(t ?? "").trim().replace(/^#/, "");
+  if (i.length !== 3 && i.length !== 6) return null;
+  const o = i.length === 3 ? i.split("").map((a) => a + a).join("") : i, n = [0, 2, 4].map((a) => parseInt(o.slice(a, a + 2), 16) / 255);
+  return n.some(Number.isNaN) ? null : n;
+}
+function re(t) {
+  const i = Math.round(t[0] * 255), o = Math.round(t[1] * 255), n = Math.round(t[2] * 255);
+  return i << 16 | o << 8 | n;
 }
-const le = { 1: "Wall", 2: "Sparse", 3: "Solid", 4: "Skirt", 5: "Support", 6: "Raft", 7: "Gap fill", 8: "Thin wall", 9: "Bridge", 10: "Ironing", 11: "Prime" }, _e = [
+const fe = { 1: "Wall", 2: "Sparse", 3: "Solid", 4: "Skirt", 5: "Support", 6: "Raft", 7: "Gap fill", 8: "Thin wall", 9: "Bridge", 10: "Ironing", 11: "Prime" }, ue = [
   [11, 44, 122],
   [19, 89, 133],
   [28, 136, 145],
@@ -29,92 +44,93 @@ const le = { 1: "Wall", 2: "Sparse", 3: "Solid", 4: "Skirt", 5: "Support", 6: "R
   [194, 82, 60],
   [148, 38, 22]
 ].map((t) => [t[0] / 255, t[1] / 255, t[2] / 255]);
-function ce(t, i, s, n) {
-  const l = n.length;
-  if (!(s > i)) return n[0];
-  const a = (s - i) / (l - 1), h = (t - i) / a, _ = Math.max(0, Math.min(l - 1, Math.floor(h))), y = Math.max(0, Math.min(l - 1, _ + 1)), v = h - _, r = n[_], x = n[y];
-  return [r[0] + (x[0] - r[0]) * v, r[1] + (x[1] - r[1]) * v, r[2] + (x[2] - r[2]) * v];
+function pe(t, i, o, n) {
+  const a = n.length;
+  if (!(o > i)) return n[0];
+  const l = (o - i) / (a - 1), h = (t - i) / l, _ = Math.max(0, Math.min(a - 1, Math.floor(h))), x = Math.max(0, Math.min(a - 1, _ + 1)), g = h - _, s = n[_], u = n[x];
+  return [s[0] + (u[0] - s[0]) * g, s[1] + (u[1] - s[1]) * g, s[2] + (u[2] - s[2]) * g];
 }
-function pe(t, i) {
-  const s = t.length, n = i > 0 ? i : 0.42, l = new Array(s);
-  for (let e = 0; e < s; e++) {
-    const o = t[e].z;
-    l[e] = Math.max(0.02, e === 0 ? o : o - t[e - 1].z);
+const ge = 15, ve = 4;
+function be(t, i) {
+  const o = t.length, n = i > 0 ? i : 0.42, a = new Array(o);
+  for (let e = 0; e < o; e++) {
+    const r = t[e].z;
+    a[e] = Math.max(0.02, e === 0 ? r : r - t[e - 1].z);
   }
-  const a = [], h = [], _ = [], y = [], v = [], r = [], x = [], b = [], A = [], M = [], L = new Float64Array(16), P = [], D = [];
-  let W = -1, $ = 0, R = 0, H = 0, E = -1, c = 0;
-  const d = 1e-4, p = (e, o, g, m, u, w) => (a.push(e), h.push(o), _.push(g), r.push(m), y.push(u), v.push(w), x.push(c), b.push(!1), a.length - 1);
-  for (let e = 0; e < s; e++) {
-    const o = t[e].paths, g = t[e].widths, m = l[e];
-    if (c = e, !!o)
-      for (let u = 0; u < o.length; u += 8) {
-        const w = o[u + 3], F = o[u], S = o[u + 1], G = o[u + 2], I = o[u + 4], V = o[u + 5], B = o[u + 6];
-        if (w === 0) {
-          P.push(F, S, G, I, V, B), D.push(e);
+  const l = [], h = [], _ = [], x = [], g = [], s = [], u = [], v = [], z = [], S = [], I = [], P = new Float64Array(16), G = [], k = [];
+  let $ = -1, E = 0, ee = 0, te = 0, c = -1, f = 0;
+  const p = 1e-4, w = (e, r, m, y, d, F, A) => (l.push(e), h.push(r), _.push(m), s.push(y), u.push(d), x.push(F), g.push(A), v.push(f), z.push(!1), l.length - 1);
+  for (let e = 0; e < o; e++) {
+    const r = t[e].paths, m = t[e].widths, y = a[e];
+    if (f = e, !!r)
+      for (let d = 0; d < r.length; d += 8) {
+        const F = r[d + 3], A = F & ge, V = F >>> ve, B = r[d], O = r[d + 1], J = r[d + 2], L = r[d + 4], C = r[d + 5], D = r[d + 6];
+        if (A === 0) {
+          G.push(B, O, J, L, C, D), k.push(e);
           continue;
         }
-        const O = g && g[u / 8] > 0 ? g[u / 8] : n;
-        w < 16 && (L[w] += Math.hypot(I - F, V - S));
-        let k;
-        W >= 0 && E === w && Math.abs($ - F) < d && Math.abs(R - S) < d && Math.abs(H - G) < d ? (k = W, p(I, V, B, w, m, O)) : (k = p(F, S, G, w, m, O), p(I, V, B, w, m, O)), b[k] = !0, W = k + 1, $ = I, R = V, H = B, E = w, A.push(k), M.push(e);
+        const oe = m && m[d / 8] > 0 ? m[d / 8] : n;
+        P[A] += Math.hypot(L - B, C - O);
+        let Q;
+        $ >= 0 && c === F && Math.abs(E - B) < p && Math.abs(ee - O) < p && Math.abs(te - J) < p ? (Q = $, w(L, C, D, A, V, y, oe)) : (Q = w(B, O, J, A, V, y, oe), w(L, C, D, A, V, y, oe)), z[Q] = !0, $ = Q + 1, E = L, ee = C, te = D, c = F, S.push(Q), I.push(e);
       }
   }
-  const f = a.length, C = A.length, z = new Float32Array(f * 4), Y = new Float32Array(f * 4);
-  let ee = 0, ne = !1, T = 1 / 0, j = 1 / 0, X = 1 / 0, Z = -1 / 0, q = -1 / 0, J = -1 / 0;
-  for (let e = 0; e < f; e++) {
-    const o = y[e], g = a[e], m = h[e], u = _[e] - 0.5 * o;
-    z[e * 4] = g, z[e * 4 + 1] = m, z[e * 4 + 2] = u;
-    const w = e > 0 && b[e - 1], F = b[e];
-    let S = 0;
-    if (w || F) {
-      const G = w ? a[e] - a[e - 1] : 0, I = w ? h[e] - h[e - 1] : 0, V = w ? _[e] - _[e - 1] : 0, B = F ? a[e + 1] - a[e] : 0, O = F ? h[e + 1] - h[e] : 0, k = F ? _[e + 1] - _[e] : 0;
-      S = Math.atan2(G * O - I * B, G * B + I * O + V * k);
+  const b = l.length, M = S.length, R = new Float32Array(b * 4), U = new Float32Array(b * 4);
+  let ie = 0, ae = !1, Y = 1 / 0, j = 1 / 0, X = 1 / 0, K = -1 / 0, Z = -1 / 0, q = -1 / 0;
+  for (let e = 0; e < b; e++) {
+    const r = x[e], m = l[e], y = h[e], d = _[e] - 0.5 * r;
+    R[e * 4] = m, R[e * 4 + 1] = y, R[e * 4 + 2] = d;
+    const F = e > 0 && z[e - 1], A = z[e];
+    let V = 0;
+    if (F || A) {
+      const B = F ? l[e] - l[e - 1] : 0, O = F ? h[e] - h[e - 1] : 0, J = F ? _[e] - _[e - 1] : 0, L = A ? l[e + 1] - l[e] : 0, C = A ? h[e + 1] - h[e] : 0, D = A ? _[e + 1] - _[e] : 0;
+      V = Math.atan2(B * C - O * L, B * L + O * C + J * D);
     }
-    Y[e * 4] = o, Y[e * 4 + 1] = v[e], Y[e * 4 + 2] = S, Y[e * 4 + 3] = ie(U[r[e]] || U[1]), (!Number.isFinite(g) || !Number.isFinite(m) || !Number.isFinite(u) || !Number.isFinite(S)) && (ne = !0), ee = Math.max(ee, Math.abs(g), Math.abs(m), Math.abs(u)), g < T && (T = g), g > Z && (Z = g), m < j && (j = m), m > q && (q = m), u < X && (X = u), u > J && (J = u);
+    U[e * 4] = r, U[e * 4 + 1] = g[e], U[e * 4 + 2] = V, U[e * 4 + 3] = re(W[s[e]] || W[1]), (!Number.isFinite(m) || !Number.isFinite(y) || !Number.isFinite(d) || !Number.isFinite(V)) && (ae = !0), ie = Math.max(ie, Math.abs(m), Math.abs(y), Math.abs(d)), m < Y && (Y = m), m > K && (K = m), y < j && (j = y), y > Z && (Z = y), d < X && (X = d), d > q && (q = d);
   }
-  const te = new Uint32Array(C * 4);
-  for (let e = 0; e < C; e++)
-    te[e * 4] = A[e], te[e * 4 + 1] = M[e];
-  const K = { vType: new Uint8Array(f), vWidth: new Float32Array(f), vHeight: new Float32Array(f), vLayer: new Int32Array(f) };
-  for (let e = 0; e < f; e++)
-    K.vType[e] = r[e], K.vWidth[e] = v[e], K.vHeight[e] = y[e], K.vLayer[e] = x[e];
-  const oe = new Int32Array(s + 1);
+  const ne = new Uint32Array(M * 4);
+  for (let e = 0; e < M; e++)
+    ne[e * 4] = S[e], ne[e * 4 + 1] = I[e];
+  const T = { vType: new Uint8Array(b), vTool: new Uint8Array(b), vWidth: new Float32Array(b), vHeight: new Float32Array(b), vLayer: new Int32Array(b) };
+  for (let e = 0; e < b; e++)
+    T.vType[e] = s[e], T.vTool[e] = u[e], T.vWidth[e] = g[e], T.vHeight[e] = x[e], T.vLayer[e] = v[e];
+  const le = new Int32Array(o + 1);
   {
     let e = 0;
-    for (let o = 0; o < s; o++) {
-      for (; e < C && M[e] === o; ) e++;
-      oe[o + 1] = e;
+    for (let r = 0; r < o; r++) {
+      for (; e < M && I[e] === r; ) e++;
+      le[r + 1] = e;
     }
   }
-  const Q = D.length, N = new Float32Array(Q * 6);
-  for (let e = 0; e < N.length; e++) N[e] = P[e];
+  const H = k.length, N = new Float32Array(H * 6);
+  for (let e = 0; e < N.length; e++) N[e] = G[e];
   for (let e = 0; e < N.length; e += 3) {
-    const o = N[e], g = N[e + 1], m = N[e + 2];
-    o < T && (T = o), o > Z && (Z = o), g < j && (j = g), g > q && (q = g), m < X && (X = m), m > J && (J = m);
+    const r = N[e], m = N[e + 1], y = N[e + 2];
+    r < Y && (Y = r), r > K && (K = r), m < j && (j = m), m > Z && (Z = m), y < X && (X = y), y > q && (q = y);
   }
-  const re = new Int32Array(s + 1);
+  const se = new Int32Array(o + 1);
   {
     let e = 0;
-    for (let o = 0; o < s; o++) {
-      for (; e < Q && D[e] === o; ) e++;
-      re[o + 1] = e;
+    for (let r = 0; r < o; r++) {
+      for (; e < H && k[e] === r; ) e++;
+      se[r + 1] = e;
     }
   }
-  const se = f + Q > 0 ? { min: [T, j, X], max: [Z, q, J] } : null;
-  return { position: z, hwa: Y, segIndex: te, nV: f, nSeg: C, layerSegPrefix: oe, travelPos: N, travelPrefix: re, nTrav: Q, layerCount: s, maxAbs: ee, hasNaN: ne, meta: K, typeLengths: L, bbox: se };
+  const he = b + H > 0 ? { min: [Y, j, X], max: [K, Z, q] } : null;
+  return { position: R, hwa: U, segIndex: ne, nV: b, nSeg: M, layerSegPrefix: le, travelPos: N, travelPrefix: se, nTrav: H, layerCount: o, maxAbs: ie, hasNaN: ae, meta: T, typeLengths: P, bbox: he };
 }
-function ve(t) {
+function ze(t) {
   let i = 0;
   for (let n = 1; n < 16; n++) i += t[n] || 0;
-  const s = [];
-  if (i <= 0) return s;
+  const o = [];
+  if (i <= 0) return o;
   for (let n = 1; n < 16; n++) {
-    const l = t[n] || 0;
-    l > 0 && s.push({ type: n, label: le[n] || "t" + n, pct: 100 * l / i, color: U[n] || U[1] });
+    const a = t[n] || 0;
+    a > 0 && o.push({ type: n, label: fe[n] || "t" + n, pct: 100 * a / i, color: W[n] || W[1] });
   }
-  return s.sort((n, l) => l.pct - n.pct);
+  return o.sort((n, a) => a.pct - n.pct);
 }
-const he = `
+const me = `
 precision highp float;
 precision highp int;
 precision highp sampler2D;
@@ -234,14 +250,14 @@ void main() {
   color = color_base * lighting(eye_position, eye_normal);
   gl_Position = projection_matrix * vec4(eye_position, 1.0);
 }
-`, de = `
+`, ye = `
 precision highp float;
 in vec3 color;
 out vec4 fragment_color;
 void main() {
   fragment_color = vec4(color, 1.0);
 }
-`, fe = [
+`, xe = [
   0,
   1,
   2,
@@ -271,16 +287,16 @@ void main() {
   6
   // back spike
 ];
-function ge(t, i) {
-  const s = (c, d) => {
-    const p = Math.min(2048, Math.max(1, d)), f = Math.max(1, Math.ceil(d / p)), C = new Float32Array(p * f * 4);
-    C.set(c.subarray(0, Math.min(c.length, p * f * 4)));
-    const z = new t.DataTexture(C, p, f, t.RGBAFormat, t.FloatType);
-    return z.minFilter = z.magFilter = t.NearestFilter, z.generateMipmaps = !1, z.needsUpdate = !0, z;
-  }, n = s(i.position, i.nV), l = s(i.hwa, i.nV), a = new t.InstancedBufferGeometry();
-  a.setIndex(fe), a.setAttribute("position", new t.BufferAttribute(new Float32Array(8 * 3), 3)), a.setAttribute("vertex_id_float", new t.BufferAttribute(new Float32Array([0, 1, 2, 3, 4, 5, 6, 7]), 1));
+function Ae(t, i) {
+  const o = (c, f) => {
+    const p = Math.min(2048, Math.max(1, f)), w = Math.max(1, Math.ceil(f / p)), b = new Float32Array(p * w * 4);
+    b.set(c.subarray(0, Math.min(c.length, p * w * 4)));
+    const M = new t.DataTexture(b, p, w, t.RGBAFormat, t.FloatType);
+    return M.minFilter = M.magFilter = t.NearestFilter, M.generateMipmaps = !1, M.needsUpdate = !0, M;
+  }, n = o(i.position, i.nV), a = o(i.hwa, i.nV), l = new t.InstancedBufferGeometry();
+  l.setIndex(xe), l.setAttribute("position", new t.BufferAttribute(new Float32Array(8 * 3), 3)), l.setAttribute("vertex_id_float", new t.BufferAttribute(new Float32Array([0, 1, 2, 3, 4, 5, 6, 7]), 1));
   const h = new t.InstancedInterleavedBuffer(i.segIndex, 4);
-  a.setAttribute("seg_id_a_u", new t.InterleavedBufferAttribute(h, 1, 0)), a.setAttribute("seg_layer_u", new t.InterleavedBufferAttribute(h, 1, 1)), a.instanceCount = 0;
+  l.setAttribute("seg_id_a_u", new t.InterleavedBufferAttribute(h, 1, 0)), l.setAttribute("seg_layer_u", new t.InterleavedBufferAttribute(h, 1, 1)), l.instanceCount = 0;
   const _ = new t.RawShaderMaterial({
     glslVersion: t.GLSL3,
     uniforms: {
@@ -288,98 +304,107 @@ function ge(t, i) {
       projection_matrix: { value: new t.Matrix4() },
       camera_position: { value: new t.Vector3() },
       position_tex: { value: n },
-      height_width_angle_tex: { value: l },
+      height_width_angle_tex: { value: a },
       layer_lo: { value: 0 },
       layer_hi: { value: i.layerCount }
     },
-    vertexShader: he,
-    fragmentShader: de,
+    vertexShader: me,
+    fragmentShader: ye,
     side: t.DoubleSide
-  }), y = new t.Mesh(a, _);
-  let v = null;
+  }), x = new t.Mesh(l, _);
+  let g = null;
   if (i.bbox) {
-    const { min: c, max: d } = i.bbox, p = new t.Vector3((c[0] + d[0]) / 2, (c[1] + d[1]) / 2, (c[2] + d[2]) / 2), f = Math.hypot(d[0] - c[0], d[1] - c[1], d[2] - c[2]) / 2 + 2;
-    v = new t.Sphere(p, f);
+    const { min: c, max: f } = i.bbox, p = new t.Vector3((c[0] + f[0]) / 2, (c[1] + f[1]) / 2, (c[2] + f[2]) / 2), w = Math.hypot(f[0] - c[0], f[1] - c[1], f[2] - c[2]) / 2 + 2;
+    g = new t.Sphere(p, w);
   }
-  y.frustumCulled = !!v, v && (a.boundingSphere = v);
-  const r = new t.Matrix4(), x = new t.Vector3();
-  y.onBeforeRender = (c, d, p) => {
-    _.uniforms.projection_matrix.value.copy(p.projectionMatrix), _.uniforms.view_matrix.value.multiplyMatrices(p.matrixWorldInverse, y.matrixWorld), r.copy(y.matrixWorld).invert(), p.getWorldPosition(x).applyMatrix4(r), _.uniforms.camera_position.value.copy(x);
+  x.frustumCulled = !!g, g && (l.boundingSphere = g);
+  const s = new t.Matrix4(), u = new t.Vector3();
+  x.onBeforeRender = (c, f, p) => {
+    _.uniforms.projection_matrix.value.copy(p.projectionMatrix), _.uniforms.view_matrix.value.multiplyMatrices(p.matrixWorldInverse, x.matrixWorld), s.copy(x.matrixWorld).invert(), p.getWorldPosition(u).applyMatrix4(s), _.uniforms.camera_position.value.copy(u);
   };
-  const b = new t.BufferGeometry();
-  b.setAttribute("position", new t.BufferAttribute(i.travelPos, 3)), b.setDrawRange(0, 0);
-  const A = new t.LineSegments(b, new t.LineBasicMaterial({ color: 7041658 }));
-  A.frustumCulled = !!v, A.visible = !1, v && (b.boundingSphere = v);
-  let M = !1, L = 0, P = i.layerCount - 1;
-  const D = () => {
-    const c = i.travelPrefix[L], d = i.travelPrefix[P + 1];
-    b.setDrawRange(M ? c * 2 : 0, M ? (d - c) * 2 : 0);
-  }, W = (c, d) => {
+  const v = new t.BufferGeometry();
+  v.setAttribute("position", new t.BufferAttribute(i.travelPos, 3)), v.setDrawRange(0, 0);
+  const z = new t.LineSegments(v, new t.LineBasicMaterial({ color: 7041658 }));
+  z.frustumCulled = !!g, z.visible = !1, g && (v.boundingSphere = g);
+  let S = !1, I = 0, P = i.layerCount - 1;
+  const G = () => {
+    const c = i.travelPrefix[I], f = i.travelPrefix[P + 1];
+    v.setDrawRange(S ? c * 2 : 0, S ? (f - c) * 2 : 0);
+  }, k = (c, f) => {
     const p = i.layerCount;
-    L = Math.max(0, Math.min(p - 1, c | 0)), P = Math.max(L, Math.min(p - 1, d | 0)), _.uniforms.layer_lo.value = L, _.uniforms.layer_hi.value = P, a.instanceCount = i.layerSegPrefix[P + 1], D();
+    I = Math.max(0, Math.min(p - 1, c | 0)), P = Math.max(I, Math.min(p - 1, f | 0)), _.uniforms.layer_lo.value = I, _.uniforms.layer_hi.value = P, l.instanceCount = i.layerSegPrefix[P + 1], G();
   };
-  return { mesh: y, travLines: A, setVisibleLayers: (c) => W(0, (c | 0) - 1), setLayerRange: W, setTravelVisible: (c) => {
-    M = !!c, A.visible = M, D();
+  return { mesh: x, travLines: z, setVisibleLayers: (c) => k(0, (c | 0) - 1), setLayerRange: k, setTravelVisible: (c) => {
+    S = !!c, z.visible = S, G();
   }, setColors: (c) => {
-    const d = l.image.data, p = Math.min(c.length, d.length) / 4;
-    for (let f = 0; f < p; f++) d[f * 4 + 3] = c[f * 4];
-    l.needsUpdate = !0;
+    const f = a.image.data, p = Math.min(c.length, f.length) / 4;
+    for (let w = 0; w < p; w++) f[w * 4 + 3] = c[w * 4];
+    a.needsUpdate = !0;
   }, dispose: () => {
-    a.dispose(), _.dispose(), n.dispose(), l.dispose(), b.dispose(), A.material.dispose();
+    l.dispose(), _.dispose(), n.dispose(), a.dispose(), v.dispose(), z.material.dispose();
   }, nSeg: i.nSeg, layerCount: i.layerCount };
 }
-const ae = [
+const ce = [
   { 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" },
   { key: "width", label: "Line Width", cont: !0, unit: "mm" },
   { key: "fan", label: "Fan Speed", cont: !0, unit: "%" },
-  { key: "temp", label: "Temperature", cont: !0, unit: "°C" }
+  { key: "temp", label: "Temperature", cont: !0, unit: "°C" },
+  // Last, like upstream's EViewType::Tool: it answers "did my painted regions come out on the extruder I assigned?",
+  //  which is a check you run after slicing, not a property you scrub through. Discrete like the feature view — an
+  //  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 ue(t, i, s, n) {
-  const l = i.vType[s], a = i.vLayer[s], h = a === 0;
+function we(t, i, o, n) {
+  const a = i.vType[o], l = i.vLayer[o], h = l === 0;
   switch (t) {
     case "height":
-      return i.vHeight[s];
+      return i.vHeight[o];
     case "width":
-      return i.vWidth[s];
+      return i.vWidth[o];
     case "speed":
-      return h ? n.firstLayerSpeed : n.speedByType[l] ?? n.speedByType[1];
+      return h ? n.firstLayerSpeed : n.speedByType[a] ?? n.speedByType[1];
     case "fan":
-      return a < n.closeFanLayers ? 0 : l === 9 ? 100 : n.fanNormal;
+      return l < n.closeFanLayers ? 0 : a === 9 ? 100 : n.fanNormal;
     case "temp":
       return h ? n.tempFirst : n.tempNormal;
     default:
       return 0;
   }
 }
-function me(t, i, s) {
-  const { meta: n, nV: l } = t, a = new Float32Array(l * 4), h = ae.find((r) => r.key === i) || ae[0];
+function Fe(t, i, o) {
+  const { meta: n, nV: a } = t, l = new Float32Array(a * 4), h = ce.find((s) => s.key === i) || ce[0];
   if (!h.cont) {
-    for (let r = 0; r < l; r++) a[r * 4] = ie(U[n.vType[r]] || U[1]);
-    return { color: a, min: 0, max: 0, viewType: i, label: h.label, unit: h.unit, cont: !1 };
+    const s = ((o == null ? void 0 : o.toolColors) ?? []).map(de), u = h.key === "filament" ? (v) => {
+      const z = n.vTool ? n.vTool[v] : 0;
+      return s[z] || _e[z % _e.length];
+    } : (v) => W[n.vType[v]] || W[1];
+    for (let v = 0; v < a; v++) l[v * 4] = re(u(v));
+    return { color: l, min: 0, max: 0, viewType: i, label: h.label, unit: h.unit, cont: !1 };
   }
-  let _ = 1 / 0, y = -1 / 0;
-  const v = new Float32Array(l);
-  for (let r = 0; r < l; r++) {
-    const x = ue(i, n, r, s);
-    v[r] = x, x < _ && (_ = x), x > y && (y = x);
+  let _ = 1 / 0, x = -1 / 0;
+  const g = new Float32Array(a);
+  for (let s = 0; s < a; s++) {
+    const u = we(i, n, s, o);
+    g[s] = u, u < _ && (_ = u), u > x && (x = u);
   }
-  Number.isFinite(_) || (_ = 0, y = 1);
-  for (let r = 0; r < l; r++) {
-    const x = ce(v[r], _, y, _e);
-    a[r * 4] = ie(x);
+  Number.isFinite(_) || (_ = 0, x = 1);
+  for (let s = 0; s < a; s++) {
+    const u = pe(g[s], _, x, ue);
+    l[s * 4] = re(u);
   }
-  return { color: a, min: _, max: y, viewType: i, label: h.label, unit: h.unit, cont: !0 };
+  return { color: l, min: _, max: x, viewType: i, label: h.label, unit: h.unit, cont: !0 };
 }
 export {
-  _e as DEFAULT_RANGES_COLORS,
-  U as TYPE_COLOR,
-  le as TYPE_LABEL,
-  fe as VERTEX_DATA,
-  ae as VIEW_TYPES,
-  pe as buildSegmentData,
-  me as computeColors,
-  ge as makeToolpath,
-  ve as roleRatios
+  ue as DEFAULT_RANGES_COLORS,
+  _e as TOOL_COLOR,
+  W as TYPE_COLOR,
+  fe as TYPE_LABEL,
+  xe as VERTEX_DATA,
+  ce as VIEW_TYPES,
+  be as buildSegmentData,
+  Fe as computeColors,
+  Ae as makeToolpath,
+  ze as roleRatios
 };