three-slicer 0.2.0 → 0.2.2

package/viewer/dist/toolpath_gpu-4foc4FaU.js

@@ -0,0 +1,482 @@
+const X = {
+  0: [0.42, 0.45, 0.5],
+  1: [0.85, 0.51, 0.17],
+  2: [0.21, 0.45, 0.76],
+  3: [0.35, 0.75, 0.85],
+  4: [0.16, 0.68, 0.4],
+  5: [0.66, 0.42, 0.85],
+  6: [0.55, 0.45, 0.35],
+  7: [0.95, 0.85, 0.25],
+  8: [0.9, 0.35, 0.65],
+  9: [0.9, 0.25, 0.25],
+  10: [0.6, 0.82, 0.55],
+  11: [0.3, 0.72, 0.7]
+}, fe = [
+  [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 ge(t) {
+  const i = String(t ?? "").trim().replace(/^#/, "");
+  if (i.length !== 3 && i.length !== 6) return null;
+  const o = i.length === 3 ? i.split("").map((l) => l + l).join("") : i, n = [0, 2, 4].map((l) => parseInt(o.slice(l, l + 2), 16) / 255);
+  return n.some(Number.isNaN) ? null : n;
+}
+function ae(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 me = { 1: "Wall", 2: "Sparse", 3: "Solid", 4: "Skirt", 5: "Support", 6: "Raft", 7: "Gap fill", 8: "Thin wall", 9: "Bridge", 10: "Ironing", 11: "Prime" }, ye = [
+  [11, 44, 122],
+  [19, 89, 133],
+  [28, 136, 145],
+  [4, 214, 15],
+  [170, 242, 0],
+  [252, 249, 3],
+  [245, 206, 10],
+  [227, 136, 32],
+  [209, 104, 48],
+  [194, 82, 60],
+  [148, 38, 22]
+].map((t) => [t[0] / 255, t[1] / 255, t[2] / 255]);
+function xe(t, i, o, n) {
+  const l = n.length;
+  if (!(o > i)) return n[0];
+  const r = (o - i) / (l - 1), u = (t - i) / r, h = Math.max(0, Math.min(l - 1, Math.floor(u))), f = Math.max(0, Math.min(l - 1, h + 1)), p = u - h, c = n[h], v = n[f];
+  return [c[0] + (v[0] - c[0]) * p, c[1] + (v[1] - c[1]) * p, c[2] + (v[2] - c[2]) * p];
+}
+const we = 15, be = 4;
+function Ie(t, i) {
+  const o = t.length, n = i > 0 ? i : 0.42, l = new Array(o);
+  for (let e = 0; e < o; e++) {
+    const _ = t[e].z;
+    l[e] = Math.max(0.02, e === 0 ? _ : _ - t[e - 1].z);
+  }
+  const r = [], u = [], h = [], f = [], p = [], c = [], v = [], g = [], M = [], S = [], m = [], P = new Float64Array(16), A = [], N = [], k = [];
+  let D = -1, K = 0, te = 0, ie = 0, ne = -1, oe = 0;
+  const E = 1e-4, a = (e, _, y, x, z, w, F) => (r.push(e), u.push(_), h.push(y), c.push(x), v.push(z), f.push(w), p.push(F), g.push(oe), M.push(!1), r.length - 1);
+  for (let e = 0; e < o; e++) {
+    const _ = t[e].paths, y = t[e].widths, x = l[e];
+    if (oe = e, !_) continue;
+    const z = S.length;
+    for (let w = 0; w < _.length; w += 8) {
+      const F = _[w + 3], C = F & we, U = F >>> be, V = _[w], Y = _[w + 1], j = _[w + 2], B = _[w + 4], O = _[w + 5], ee = _[w + 6];
+      if (C === 0) {
+        A.push(V, Y, j, B, O, ee), N.push(e), k.push(S.length - z);
+        continue;
+      }
+      const le = y && y[w / 8] > 0 ? y[w / 8] : n;
+      P[C] += Math.hypot(B - V, O - Y);
+      let H;
+      D >= 0 && ne === F && Math.abs(K - V) < E && Math.abs(te - Y) < E && Math.abs(ie - j) < E ? (H = D, a(B, O, ee, C, U, x, le)) : (H = a(V, Y, j, C, U, x, le), a(B, O, ee, C, U, x, le)), M[H] = !0, D = H + 1, K = B, te = O, ie = ee, ne = F, S.push(H), m.push(e);
+    }
+  }
+  const s = r.length, d = S.length, b = new Float32Array(s * 4), L = new Float32Array(s * 4);
+  let I = 0, _e = !1, Z = 1 / 0, q = 1 / 0, J = 1 / 0, Q = -1 / 0, $ = -1 / 0, R = -1 / 0;
+  for (let e = 0; e < s; e++) {
+    const _ = f[e], y = r[e], x = u[e], z = h[e] - 0.5 * _;
+    b[e * 4] = y, b[e * 4 + 1] = x, b[e * 4 + 2] = z;
+    const w = e > 0 && M[e - 1], F = M[e];
+    let C = 0;
+    if (w || F) {
+      const U = w ? r[e] - r[e - 1] : 0, V = w ? u[e] - u[e - 1] : 0, Y = w ? h[e] - h[e - 1] : 0, j = F ? r[e + 1] - r[e] : 0, B = F ? u[e + 1] - u[e] : 0, O = F ? h[e + 1] - h[e] : 0;
+      C = Math.atan2(U * B - V * j, U * j + V * B + Y * O);
+    }
+    L[e * 4] = _, L[e * 4 + 1] = p[e], L[e * 4 + 2] = C, L[e * 4 + 3] = ae(X[c[e]] || X[1]), (!Number.isFinite(y) || !Number.isFinite(x) || !Number.isFinite(z) || !Number.isFinite(C)) && (_e = !0), I = Math.max(I, Math.abs(y), Math.abs(x), Math.abs(z)), y < Z && (Z = y), y > Q && (Q = y), x < q && (q = x), x > $ && ($ = x), z < J && (J = z), z > R && (R = z);
+  }
+  const re = new Uint32Array(d * 4);
+  for (let e = 0; e < d; e++)
+    re[e * 4] = S[e], re[e * 4 + 1] = m[e];
+  const W = { vType: new Uint8Array(s), vTool: new Uint8Array(s), vWidth: new Float32Array(s), vHeight: new Float32Array(s), vLayer: new Int32Array(s) };
+  for (let e = 0; e < s; e++)
+    W.vType[e] = c[e], W.vTool[e] = v[e], W.vWidth[e] = p[e], W.vHeight[e] = f[e], W.vLayer[e] = g[e];
+  const ce = new Int32Array(o + 1);
+  {
+    let e = 0;
+    for (let _ = 0; _ < o; _++) {
+      for (; e < d && m[e] === _; ) e++;
+      ce[_ + 1] = e;
+    }
+  }
+  const G = N.length, T = new Float32Array(G * 6);
+  for (let e = 0; e < T.length; e++) T[e] = A[e];
+  for (let e = 0; e < T.length; e += 3) {
+    const _ = T[e], y = T[e + 1], x = T[e + 2];
+    _ < Z && (Z = _), _ > Q && (Q = _), y < q && (q = y), y > $ && ($ = y), x < J && (J = x), x > R && (R = x);
+  }
+  const he = new Int32Array(o + 1);
+  {
+    let e = 0;
+    for (let _ = 0; _ < o; _++) {
+      for (; e < G && N[e] === _; ) e++;
+      he[_ + 1] = e;
+    }
+  }
+  const ue = new Int32Array(G);
+  for (let e = 0; e < G; e++) ue[e] = k[e];
+  const de = s + G > 0 ? { min: [Z, q, J], max: [Q, $, R] } : null;
+  return {
+    position: b,
+    hwa: L,
+    segIndex: re,
+    nV: s,
+    nSeg: d,
+    layerSegPrefix: ce,
+    travelPos: T,
+    travelPrefix: he,
+    travelSegBefore: ue,
+    nTrav: G,
+    layerCount: o,
+    maxAbs: I,
+    hasNaN: _e,
+    meta: W,
+    typeLengths: P,
+    bbox: de
+  };
+}
+function pe(t, i) {
+  const o = Math.max(0, Math.min(t.layerCount - 1, i | 0));
+  return t.layerSegPrefix[o + 1] - t.layerSegPrefix[o] + (t.travelPrefix[o + 1] - t.travelPrefix[o]);
+}
+function Me(t, i, o) {
+  const n = t.layerCount - 1, l = Math.max(0, Math.min(n, i | 0)), r = Math.max(l, Math.min(n, o | 0));
+  for (let u = r; u >= l; u--) if (pe(t, u) > 0) return u;
+  return r;
+}
+function se(t, i, o) {
+  const n = Math.max(0, Math.min(t.layerCount - 1, i | 0)), l = t.layerSegPrefix[n], r = t.travelPrefix[n], u = pe(t, n), h = Math.max(0, Math.min(u, o | 0));
+  let f = r, p = t.travelPrefix[n + 1];
+  for (; f < p; ) {
+    const m = f + p >> 1;
+    t.travelSegBefore[m] + (m - r) < h ? f = m + 1 : p = m;
+  }
+  const c = f - r, v = h - c;
+  if (h === 0) return { segCount: 0, travCount: 0, point: null, onTravel: !1 };
+  if (f > r && t.travelSegBefore[f - 1] + (f - 1 - r) === h - 1) {
+    const m = (f - 1) * 6;
+    return { segCount: v, travCount: c, onTravel: !0, point: [t.travelPos[m + 3], t.travelPos[m + 4], t.travelPos[m + 5]] };
+  }
+  const M = l + v - 1, S = t.segIndex[M * 4] + 1;
+  return {
+    segCount: v,
+    travCount: c,
+    onTravel: !1,
+    point: [t.position[S * 4], t.position[S * 4 + 1], t.position[S * 4 + 2] + 0.5 * t.hwa[S * 4]]
+  };
+}
+function Ce(t) {
+  let i = 0;
+  for (let n = 1; n < 16; n++) i += t[n] || 0;
+  const o = [];
+  if (i <= 0) return o;
+  for (let n = 1; n < 16; n++) {
+    const l = t[n] || 0;
+    l > 0 && o.push({ type: n, label: me[n] || "t" + n, pct: 100 * l / i, color: X[n] || X[1] });
+  }
+  return o.sort((n, l) => l.pct - n.pct);
+}
+const Se = `
+precision highp float;
+precision highp int;
+precision highp sampler2D;
+precision highp usampler2D;
+#define POINTY_CAPS
+#define FIX_TWISTING
+const vec3  light_top_dir = vec3(-0.4574957, 0.4574957, 0.7624929);
+const float light_top_diffuse = 0.6 * 0.8;
+const float light_top_specular = 0.6 * 0.125;
+const float light_top_shininess = 20.0;
+const vec3  light_front_dir = vec3(0.6985074, 0.1397015, 0.6985074);
+const float light_front_diffuse = 0.6 * 0.3;
+const float ambient = 0.3;
+const float emission = 0.15;
+const vec3 UP = vec3(0, 0, 1);
+uniform mat4 view_matrix;
+uniform mat4 projection_matrix;
+uniform vec3 camera_position;
+uniform sampler2D position_tex;
+uniform sampler2D height_width_angle_tex;
+uniform int layer_lo;   // stage 25: dual slider lower bound (layer). The shader clips out-of-range segments in O(1).
+uniform int layer_hi;   //          the upper bound is cut via instanceCount (sorted by layer).
+in float vertex_id_float;
+in uint seg_id_a_u;     // instance attribute (formerly segment_index_tex.r) — attribute fetch is cheaper than texelFetch
+in uint seg_layer_u;    // instance attribute (formerly segment_index_tex.g)
+out vec3 color;
+vec3 decode_color(float col) {
+  int c = int(round(col));
+  int r = (c >> 16) & 0xFF;
+  int g = (c >> 8) & 0xFF;
+  int b = (c >> 0) & 0xFF;
+  float f = 1.0 / 255.0;
+  return f * vec3(r, g, b);
+}
+float lighting(vec3 eye_position, vec3 eye_normal) {
+  float top_diffuse = light_top_diffuse * max(dot(eye_normal, light_top_dir), 0.0);
+  float front_diffuse = light_front_diffuse * max(dot(eye_normal, light_front_dir), 0.0);
+  float top_specular = light_top_specular * pow(max(dot(-normalize(eye_position), reflect(-light_top_dir, eye_normal)), 0.0), light_top_shininess);
+  return ambient + top_diffuse + front_diffuse + top_specular + emission;
+}
+ivec2 tex_coord(sampler2D sampler, int id) {
+  ivec2 tex_size = textureSize(sampler, 0);
+  return (tex_size.y == 1) ? ivec2(id, 0) : ivec2(id % tex_size.x, id / tex_size.x);
+}
+void main() {
+  int vertex_id = int(vertex_id_float);
+  int seg_layer = int(seg_layer_u);
+  if (seg_layer < layer_lo || seg_layer > layer_hi) { gl_Position = vec4(2.0, 2.0, 2.0, 1.0); return; }   // out of range -> clip
+  int id_a = int(seg_id_a_u);
+  int id_b = id_a + 1;
+  vec3 pos_a = texelFetch(position_tex, tex_coord(position_tex, id_a), 0).xyz;
+  vec3 pos_b = texelFetch(position_tex, tex_coord(position_tex, id_b), 0).xyz;
+  vec3 line = pos_b - pos_a;
+  float line_len = length(line);
+  vec3 line_dir;
+  if (line_len < 1e-4)
+    line_dir = vec3(1.0, 0.0, 0.0);
+  else
+    line_dir = line / line_len;
+  vec3 line_right_dir;
+  if (abs(dot(line_dir, UP)) > 0.9) {
+    line_right_dir = normalize(cross(vec3(1, 0, 0), line_dir));
+  }
+  else
+    line_right_dir = normalize(cross(line_dir, UP));
+  vec3 line_up_dir = normalize(cross(line_right_dir, line_dir));
+  const vec2 horizontal_vertical_view_signs_array[16] = vec2[](
+    vec2(1.0, 0.0), vec2(0.0, 1.0), vec2(0.0, 0.0), vec2(0.0, -1.0),
+    vec2(0.0, -1.0), vec2(1.0, 0.0), vec2(0.0, 1.0), vec2(0.0, 0.0),
+    vec2(0.0, 1.0), vec2(-1.0, 0.0), vec2(0.0, 0.0), vec2(1.0, 0.0),
+    vec2(1.0, 0.0), vec2(0.0, 1.0), vec2(-1.0, 0.0), vec2(0.0, 0.0)
+    );
+  int id = vertex_id < 4 ? id_a : id_b;
+  vec3 endpoint_pos = vertex_id < 4 ? pos_a : pos_b;
+  vec4 hwa_color = texelFetch(height_width_angle_tex, tex_coord(height_width_angle_tex, id), 0);   // .xyz=h/w/angle, .w=packed color
+  vec3 height_width_angle = hwa_color.xyz;
+#ifdef FIX_TWISTING
+  int closer_id = (dot(camera_position - pos_a, camera_position - pos_a) < dot(camera_position - pos_b, camera_position - pos_b)) ? id_a : id_b;
+  vec3 closer_pos = (closer_id == id_a) ? pos_a : pos_b;
+  vec3 camera_view_dir = normalize(closer_pos - camera_position);
+  vec3 closer_height_width_angle = texelFetch(height_width_angle_tex, tex_coord(height_width_angle_tex, closer_id), 0).xyz;
+  vec3 diagonal_dir_border = normalize(closer_height_width_angle.x * line_up_dir + closer_height_width_angle.y * line_right_dir);
+#else
+  vec3 camera_view_dir = normalize(endpoint_pos - camera_position);
+  vec3 diagonal_dir_border = normalize(height_width_angle.x * line_up_dir + height_width_angle.y * line_right_dir);
+#endif
+  bool is_vertical_view = abs(dot(camera_view_dir, line_up_dir)) / abs(dot(diagonal_dir_border, line_up_dir)) >
+    abs(dot(camera_view_dir, line_right_dir)) / abs(dot(diagonal_dir_border, line_right_dir));
+  vec2 signs = horizontal_vertical_view_signs_array[vertex_id + 8 * int(is_vertical_view)];
+#ifndef POINTY_CAPS
+  if (vertex_id == 2 || vertex_id == 7) signs = -horizontal_vertical_view_signs_array[(vertex_id - 2) + 8 * int(is_vertical_view)];
+#endif
+  float view_right_sign = sign(dot(-camera_view_dir, line_right_dir));
+  float view_top_sign = sign(dot(-camera_view_dir, line_up_dir));
+  float half_height = 0.5 * height_width_angle.x;
+  float half_width = 0.5 * height_width_angle.y;
+  vec3 horizontal_dir = half_width * line_right_dir;
+  vec3 vertical_dir = half_height * line_up_dir;
+  float horizontal_sign = signs.x * view_right_sign;
+  float vertical_sign = signs.y * view_top_sign;
+  vec3 pos = endpoint_pos + horizontal_sign * horizontal_dir + vertical_sign * vertical_dir;
+  if (vertex_id == 2 || vertex_id == 7) {
+    float line_dir_sign = (vertex_id == 2) ? -1.0 : 1.0;
+    if (height_width_angle.z == 0.0) {
+#ifdef POINTY_CAPS
+      pos += line_dir_sign * line_dir * half_width;
+#endif
+    }
+    else {
+      pos += line_dir_sign * line_dir * half_width * sin(abs(height_width_angle.z) * 0.5);
+      pos += sign(height_width_angle.z) * horizontal_dir * cos(abs(height_width_angle.z) * 0.5);
+    }
+  }
+  vec3 eye_position = (view_matrix * vec4(pos, 1.0)).xyz;
+  vec3 eye_normal = (view_matrix * vec4(normalize(pos - endpoint_pos), 0.0)).xyz;
+  vec3 color_base = decode_color(hwa_color.w);
+  color = color_base * lighting(eye_position, eye_normal);
+  gl_Position = projection_matrix * vec4(eye_position, 1.0);
+}
+`, Ae = `
+precision highp float;
+in vec3 color;
+out vec4 fragment_color;
+void main() {
+  fragment_color = vec4(color, 1.0);
+}
+`, ze = [
+  0,
+  1,
+  2,
+  0,
+  2,
+  3,
+  // front spike
+  0,
+  3,
+  4,
+  0,
+  4,
+  5,
+  // right/bottom body
+  0,
+  5,
+  6,
+  0,
+  6,
+  1,
+  // left/top body
+  5,
+  4,
+  7,
+  5,
+  7,
+  6
+  // back spike
+];
+function Pe(t, i) {
+  const o = (a, s) => {
+    const d = Math.min(2048, Math.max(1, s)), b = Math.max(1, Math.ceil(s / d)), L = new Float32Array(d * b * 4);
+    L.set(a.subarray(0, Math.min(a.length, d * b * 4)));
+    const I = new t.DataTexture(L, d, b, t.RGBAFormat, t.FloatType);
+    return I.minFilter = I.magFilter = t.NearestFilter, I.generateMipmaps = !1, I.needsUpdate = !0, I;
+  }, n = o(i.position, i.nV), l = o(i.hwa, i.nV), r = new t.InstancedBufferGeometry();
+  r.setIndex(ze), r.setAttribute("position", new t.BufferAttribute(new Float32Array(8 * 3), 3)), r.setAttribute("vertex_id_float", new t.BufferAttribute(new Float32Array([0, 1, 2, 3, 4, 5, 6, 7]), 1));
+  const u = new t.InstancedInterleavedBuffer(i.segIndex, 4);
+  r.setAttribute("seg_id_a_u", new t.InterleavedBufferAttribute(u, 1, 0)), r.setAttribute("seg_layer_u", new t.InterleavedBufferAttribute(u, 1, 1)), r.instanceCount = 0;
+  const h = new t.RawShaderMaterial({
+    glslVersion: t.GLSL3,
+    uniforms: {
+      view_matrix: { value: new t.Matrix4() },
+      projection_matrix: { value: new t.Matrix4() },
+      camera_position: { value: new t.Vector3() },
+      position_tex: { value: n },
+      height_width_angle_tex: { value: l },
+      layer_lo: { value: 0 },
+      layer_hi: { value: i.layerCount }
+    },
+    vertexShader: Se,
+    fragmentShader: Ae,
+    side: t.DoubleSide
+  }), f = new t.Mesh(r, h);
+  let p = null;
+  if (i.bbox) {
+    const { min: a, max: s } = i.bbox, d = new t.Vector3((a[0] + s[0]) / 2, (a[1] + s[1]) / 2, (a[2] + s[2]) / 2), b = Math.hypot(s[0] - a[0], s[1] - a[1], s[2] - a[2]) / 2 + 2;
+    p = new t.Sphere(d, b);
+  }
+  f.frustumCulled = !!p, p && (r.boundingSphere = p);
+  const c = new t.Matrix4(), v = new t.Vector3();
+  f.onBeforeRender = (a, s, d) => {
+    h.uniforms.projection_matrix.value.copy(d.projectionMatrix), h.uniforms.view_matrix.value.multiplyMatrices(d.matrixWorldInverse, f.matrixWorld), c.copy(f.matrixWorld).invert(), d.getWorldPosition(v).applyMatrix4(c), h.uniforms.camera_position.value.copy(v);
+  };
+  const g = new t.BufferGeometry();
+  g.setAttribute("position", new t.BufferAttribute(i.travelPos, 3)), g.setDrawRange(0, 0);
+  const M = new t.LineSegments(g, new t.LineBasicMaterial({ color: 7041658 }));
+  M.frustumCulled = !!p, M.visible = !1, p && (g.boundingSphere = p);
+  let S = !1, m = 0, P = i.layerCount - 1, A = null;
+  const N = () => Me(i, m, P), k = () => {
+    const a = i.travelPrefix[m], s = N(), d = A == null ? i.travelPrefix[P + 1] : i.travelPrefix[s] + se(i, s, A).travCount, b = Math.max(0, d - a);
+    g.setDrawRange(S ? a * 2 : 0, S ? b * 2 : 0);
+  }, D = () => {
+    const a = N();
+    r.instanceCount = A == null ? i.layerSegPrefix[P + 1] : i.layerSegPrefix[a] + se(i, a, A).segCount;
+  }, K = (a, s) => {
+    const d = i.layerCount;
+    m = Math.max(0, Math.min(d - 1, a | 0)), P = Math.max(m, Math.min(d - 1, s | 0)), h.uniforms.layer_lo.value = m, h.uniforms.layer_hi.value = P, A = null, D(), k();
+  };
+  return {
+    mesh: f,
+    travLines: M,
+    setVisibleLayers: (a) => K(0, (a | 0) - 1),
+    setLayerRange: K,
+    setMoveRange: (a) => {
+      if (A = a == null ? null : Math.max(0, a | 0), D(), k(), A == null) return null;
+      const s = N();
+      return { layer: s, ...se(i, s, A) };
+    },
+    setTravelVisible: (a) => {
+      S = !!a, M.visible = S, k();
+    },
+    setColors: (a) => {
+      const s = l.image.data, d = Math.min(a.length, s.length) / 4;
+      for (let b = 0; b < d; b++) s[b * 4 + 3] = a[b * 4];
+      l.needsUpdate = !0;
+    },
+    dispose: () => {
+      r.dispose(), h.dispose(), n.dispose(), l.dispose(), g.dispose(), M.material.dispose();
+    },
+    data: i,
+    nSeg: i.nSeg,
+    layerCount: i.layerCount
+  };
+}
+const ve = [
+  { 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" },
+  // 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 Fe(t, i, o, n) {
+  const l = i.vType[o], r = i.vLayer[o], u = r === 0;
+  switch (t) {
+    case "height":
+      return i.vHeight[o];
+    case "width":
+      return i.vWidth[o];
+    case "speed":
+      return u ? n.firstLayerSpeed : n.speedByType[l] ?? n.speedByType[1];
+    case "fan":
+      return r < n.closeFanLayers ? 0 : l === 9 ? 100 : n.fanNormal;
+    case "temp":
+      return u ? n.tempFirst : n.tempNormal;
+    default:
+      return 0;
+  }
+}
+function Le(t, i, o) {
+  const { meta: n, nV: l } = t, r = new Float32Array(l * 4), u = ve.find((c) => c.key === i) || ve[0];
+  if (!u.cont) {
+    const c = ((o == null ? void 0 : o.toolColors) ?? []).map(ge), v = u.key === "filament" ? (g) => {
+      const M = n.vTool ? n.vTool[g] : 0;
+      return c[M] || fe[M % fe.length];
+    } : (g) => X[n.vType[g]] || X[1];
+    for (let g = 0; g < l; g++) r[g * 4] = ae(v(g));
+    return { color: r, min: 0, max: 0, viewType: i, label: u.label, unit: u.unit, cont: !1 };
+  }
+  let h = 1 / 0, f = -1 / 0;
+  const p = new Float32Array(l);
+  for (let c = 0; c < l; c++) {
+    const v = Fe(i, n, c, o);
+    p[c] = v, v < h && (h = v), v > f && (f = v);
+  }
+  Number.isFinite(h) || (h = 0, f = 1);
+  for (let c = 0; c < l; c++) {
+    const v = xe(p[c], h, f, ye);
+    r[c * 4] = ae(v);
+  }
+  return { color: r, min: h, max: f, viewType: i, label: u.label, unit: u.unit, cont: !0 };
+}
+export {
+  ye as D,
+  fe as T,
+  ve as V,
+  Pe as a,
+  Ie as b,
+  Le as c,
+  X as d,
+  me as e,
+  ze as f,
+  pe as l,
+  se as m,
+  Ce as r,
+  Me as t
+};