Some refactoring and cleanup

src/slic3r/GUI/GCodeViewer.cpp

@@ -1175,15 +1175,13 @@ void GCodeViewer::render()
         std::memcpy(converted_view_matrix.data(), view_matrix.data(), 16 * sizeof(float));
         libvgcode::Mat4x4f converted_projetion_matrix;
         std::memcpy(converted_projetion_matrix.data(), projection_matrix.data(), 16 * sizeof(float));
-        libvgcode::Vec3f converted_camera_position;
-        std::memcpy(converted_camera_position.data(), camera_position.data(), 3 * sizeof(float));
         libvgcode::Vec3f converted_tool_marker_position;
         std::memcpy(converted_tool_marker_position.data(), m_sequential_view.current_position.data(), 3 * sizeof(float));
 
         m_gcode_viewer_2.set_cog_marker_scale_factor(m_cog_marker_fixed_screen_size ? 10.0f * m_cog_marker_size * camera.get_inv_zoom() : m_cog_marker_size);
         m_gcode_viewer_2.set_tool_marker_position(converted_tool_marker_position);
         m_gcode_viewer_2.set_tool_marker_scale_factor(m_tool_marker_fixed_screen_size ? 10.0f * m_tool_marker_size * camera.get_inv_zoom() : m_tool_marker_size);
-        m_gcode_viewer_2.render(converted_view_matrix, converted_projetion_matrix, converted_camera_position);
+        m_gcode_viewer_2.render(converted_view_matrix, converted_projetion_matrix);
     }
     else
 #endif // ENABLE_NEW_GCODE_VIEWER

src/slic3r/GUI/LibVGCode/CogMarker.cpp

@@ -63,7 +63,7 @@ void CogMarker::init(uint8_t resolution, float radius)
         const float xy = radius * std::cos(stack_angle);
         const float z = radius * std::sin(stack_angle);
         if (i == 0 || i == stack_count) {
-            const Vec3f pos = toVec3f(xy, 0.0f, z);
+            const Vec3f pos = { xy, 0.0f, z };
             const Vec3f norm = normalize(pos);
             add_vertex(pos, norm, vertices);
         }
@@ -71,7 +71,7 @@ void CogMarker::init(uint8_t resolution, float radius)
             for (uint16_t j = 0; j < sector_count; ++j) {
                 // from 0 to 2pi
                 const float sector_angle = sector_step * float(j);
-                const Vec3f pos = toVec3f(xy * std::cos(sector_angle), xy * std::sin(sector_angle), z);
+                const Vec3f pos = { xy * std::cos(sector_angle), xy * std::sin(sector_angle), z };
                 const Vec3f norm = normalize(pos);
                 add_vertex(pos, norm, vertices);
             }
@@ -145,14 +145,14 @@ void CogMarker::render()
 }
 
 void CogMarker::update(const Vec3f& position, float mass)
-{    
+{
-    m_total_position = m_total_position + toVec3f(mass * position[0], mass * position[1], mass * position[2]);
+    m_total_position = m_total_position + mass * position;
     m_total_mass += mass;
 }
 
 void CogMarker::reset()
 {
-    m_total_position = toVec3f(0.0f);
+    m_total_position = { 0.0f, 0.0f, 0.0f };
     m_total_mass = 0.0f;
 }
 
@@ -160,7 +160,7 @@ Vec3f CogMarker::get_position() const
 {
     assert(m_total_mass > 0.0f);
     const float inv_total_mass = 1.0f / m_total_mass;
-    return { m_total_position[0] * inv_total_mass, m_total_position[1] * inv_total_mass, m_total_position[2] * inv_total_mass };
+    return inv_total_mass * m_total_position;
 }
 
 } // namespace libvgcode

src/slic3r/GUI/LibVGCode/CogMarker.hpp

@@ -52,7 +52,7 @@ private:
     // Values used to calculate the center of gravity
     //
     float m_total_mass{ 0.0f };
-    Vec3f m_total_position{ toVec3f(0.0f) };
+    Vec3f m_total_position{ 0.0f, 0.0f, 0.0f };
 
     uint16_t m_indices_count{ 0 };
     unsigned int m_vao_id{ 0 };

src/slic3r/GUI/LibVGCode/OptionTemplate.cpp

@@ -50,10 +50,10 @@ void OptionTemplate::init(uint8_t resolution)
     //
     std::vector<float> top_vertices;
     top_vertices.reserve(6 * m_vertices_count);
-    add_vertex(toVec3f(0.0f, 0.0f, 0.5f), toVec3f(0.0f, 0.0f, 1.0f), top_vertices);
+    add_vertex({ 0.0f, 0.0f, 0.5f }, { 0.0f, 0.0f, 1.0f }, top_vertices);
     for (uint8_t i = 0; i <= m_resolution; ++i) {
         const float ii = float(i) * step;
-        const Vec3f pos = toVec3f(0.5f * ::cos(ii), 0.5f * ::sin(ii), 0.0f);
+        const Vec3f pos = { 0.5f * ::cos(ii), 0.5f * ::sin(ii), 0.0f };
         const Vec3f norm = normalize(pos);
         add_vertex(pos, norm, top_vertices);
     }
@@ -63,10 +63,10 @@ void OptionTemplate::init(uint8_t resolution)
     //
     std::vector<float> bottom_vertices;
     bottom_vertices.reserve(6 * m_vertices_count);
-    add_vertex(toVec3f(0.0f, 0.0f, -0.5f), toVec3f(0.0f, 0.0f, -1.0f), bottom_vertices);
+    add_vertex({ 0.0f, 0.0f, -0.5f }, { 0.0f, 0.0f, -1.0f }, bottom_vertices);
     for (uint8_t i = 0; i <= m_resolution; ++i) {
         const float ii = -float(i) * step;
-        const Vec3f pos = toVec3f(0.5f * ::cos(ii), 0.5f * ::sin(ii), 0.0f);
+        const Vec3f pos = { 0.5f * ::cos(ii), 0.5f * ::sin(ii), 0.0f };
         const Vec3f norm = normalize(pos);
         add_vertex(pos, norm, bottom_vertices);
     }

src/slic3r/GUI/LibVGCode/PathVertex.hpp

@@ -18,7 +18,7 @@ namespace libvgcode {
 
 struct PathVertex
 {
-    Vec3f position{ toVec3f(0.0f) };
+    Vec3f position{ 0.0f, 0.0f, 0.0f };
     float height{ 0.0f };
     float width{ 0.0f };
     float feedrate{ 0.0f };

src/slic3r/GUI/LibVGCode/ToolMarker.cpp

@@ -64,9 +64,9 @@ void ToolMarker::init(uint16_t resolution, float tip_radius, float tip_height, f
     const float total_height = tip_height + stem_height;
 
     // tip vertices
-    add_vertex(toVec3f(0.0f), toVec3f(0.0f, 0.0f, -1.0f), vertices);
+    add_vertex({ 0.0f, 0.0f, 0.0f }, { 0.0f, 0.0f, -1.0f }, vertices);
     for (uint16_t i = 0; i < resolution; ++i) {
-        add_vertex(toVec3f(tip_radius * sines[i], tip_radius * cosines[i], tip_height), toVec3f(sines[i], cosines[i], 0.0f), vertices);
+        add_vertex({ tip_radius * sines[i], tip_radius * cosines[i], tip_height }, { sines[i], cosines[i], 0.0f }, vertices);
     }
 
     // tip triangles
@@ -77,12 +77,12 @@ void ToolMarker::init(uint16_t resolution, float tip_radius, float tip_height, f
 
     // tip cap outer perimeter vertices
     for (uint16_t i = 0; i < resolution; ++i) {
-        add_vertex(toVec3f(tip_radius * sines[i], tip_radius * cosines[i], tip_height), toVec3f(0.0f, 0.0f, 1.0f), vertices);
+        add_vertex({ tip_radius * sines[i], tip_radius * cosines[i], tip_height }, { 0.0f, 0.0f, 1.0f }, vertices);
     }
 
     // tip cap inner perimeter vertices
     for (uint16_t i = 0; i < resolution; ++i) {
-        add_vertex(toVec3f(stem_radius * sines[i], stem_radius * cosines[i], tip_height), toVec3f(0.0f, 0.0f, 1.0f), vertices);
+        add_vertex({ stem_radius * sines[i], stem_radius * cosines[i], tip_height }, { 0.0f, 0.0f, 1.0f }, vertices);
     }
 
     // tip cap triangles
@@ -95,12 +95,12 @@ void ToolMarker::init(uint16_t resolution, float tip_radius, float tip_height, f
 
     // stem bottom vertices
     for (uint16_t i = 0; i < resolution; ++i) {
-        add_vertex(toVec3f(stem_radius * sines[i], stem_radius * cosines[i], tip_height), toVec3f(sines[i], cosines[i], 0.0f), vertices);
+        add_vertex({ stem_radius * sines[i], stem_radius * cosines[i], tip_height }, { sines[i], cosines[i], 0.0f }, vertices);
     }
 
     // stem top vertices
     for (uint16_t i = 0; i < resolution; ++i) {
-        add_vertex(toVec3f(stem_radius * sines[i], stem_radius * cosines[i], total_height), toVec3f(sines[i], cosines[i], 0.0f), vertices);
+        add_vertex({ stem_radius * sines[i], stem_radius * cosines[i], total_height }, { sines[i], cosines[i], 0.0f }, vertices);
     }
 
     // stem triangles
@@ -112,9 +112,9 @@ void ToolMarker::init(uint16_t resolution, float tip_radius, float tip_height, f
     }
 
     // stem cap vertices
-    add_vertex(toVec3f(0.0f, 0.0f, total_height), toVec3f(0.0f, 0.0f, 1.0f), vertices);
+    add_vertex({ 0.0f, 0.0f, total_height }, { 0.0f, 0.0f, 1.0f }, vertices);
     for (uint16_t i = 0; i < resolution; ++i) {
-        add_vertex(toVec3f(stem_radius * sines[i], stem_radius * cosines[i], total_height), toVec3f(0.0f, 0.0f, 1.0f), vertices);
+        add_vertex({ stem_radius * sines[i], stem_radius * cosines[i], total_height }, { 0.0f, 0.0f, 1.0f }, vertices);
     }
 
     // stem cap triangles

src/slic3r/GUI/LibVGCode/ToolMarker.hpp

@@ -39,7 +39,7 @@ public:
     void set_alpha(float alpha);
 
 private:
-    Vec3f m_position{ toVec3f(0.0f) };
+    Vec3f m_position{ 0.0f, 0.0f, 0.0f };
     Color m_color{ 1.0f, 1.0f, 1.0f };
     float m_alpha{ 0.5f };
 

src/slic3r/GUI/LibVGCode/Toolpaths.cpp

@@ -12,6 +12,7 @@
 #include "Settings.hpp"
 #include "Shaders.hpp"
 #include "OpenGLUtils.hpp"
+#include "Utils.hpp"
 
 //################################################################################################################################
 // PrusaSlicer development only -> !!!TO BE REMOVED!!!
@@ -27,14 +28,14 @@ namespace libvgcode {
 
 //################################################################################################################################
 // PrusaSlicer development only -> !!!TO BE REMOVED!!!
-static uint8_t valueof(Slic3r::EMoveType type)
+static EMoveType valueof(Slic3r::EMoveType type)
 {
-    return static_cast<uint8_t>(type);
+    return static_cast<EMoveType>(static_cast<uint8_t>(type));
 }
 
-static uint8_t valueof(Slic3r::GCodeExtrusionRole role)
+static EGCodeExtrusionRole valueof(Slic3r::GCodeExtrusionRole role)
 {
-    return static_cast<uint8_t>(role);
+    return static_cast<EGCodeExtrusionRole>(static_cast<uint8_t>(role));
 }
 
 static Vec3f toVec3f(const Eigen::Matrix<float, 3, 1, Eigen::DontAlign>& v)
@@ -166,6 +167,137 @@ bool decode_colors(const std::vector<std::string>& colors_in, std::vector<Color>
     return true;
 }
 
+static Mat4x4f inverse(const Mat4x4f& m)
+{
+    // ref: https://stackoverflow.com/questions/1148309/inverting-a-4x4-matrix
+
+    std::array<float, 16> inv;
+
+    inv[0] = m[5] * m[10] * m[15] -
+             m[5] * m[11] * m[14] -
+             m[9] * m[6] * m[15] +
+             m[9] * m[7] * m[14] +
+             m[13] * m[6] * m[11] -
+             m[13] * m[7] * m[10];
+
+    inv[4] = -m[4] * m[10] * m[15] +
+             m[4] * m[11] * m[14] +
+             m[8] * m[6] * m[15] -
+             m[8] * m[7] * m[14] -
+             m[12] * m[6] * m[11] +
+             m[12] * m[7] * m[10];
+
+    inv[8] = m[4] * m[9] * m[15] -
+             m[4] * m[11] * m[13] -
+             m[8] * m[5] * m[15] +
+             m[8] * m[7] * m[13] +
+             m[12] * m[5] * m[11] -
+             m[12] * m[7] * m[9];
+
+    inv[12] = -m[4] * m[9] * m[14] +
+               m[4] * m[10] * m[13] +
+               m[8] * m[5] * m[14] -
+               m[8] * m[6] * m[13] -
+               m[12] * m[5] * m[10] +
+               m[12] * m[6] * m[9];
+
+    inv[1] = -m[1] * m[10] * m[15] +
+             m[1] * m[11] * m[14] +
+             m[9] * m[2] * m[15] -
+             m[9] * m[3] * m[14] -
+             m[13] * m[2] * m[11] +
+             m[13] * m[3] * m[10];
+
+    inv[5] = m[0] * m[10] * m[15] -
+             m[0] * m[11] * m[14] -
+             m[8] * m[2] * m[15] +
+             m[8] * m[3] * m[14] +
+             m[12] * m[2] * m[11] -
+             m[12] * m[3] * m[10];
+
+    inv[9] = -m[0] * m[9] * m[15] +
+             m[0] * m[11] * m[13] +
+             m[8] * m[1] * m[15] -
+             m[8] * m[3] * m[13] -
+             m[12] * m[1] * m[11] +
+             m[12] * m[3] * m[9];
+
+    inv[13] = m[0] * m[9] * m[14] -
+             m[0] * m[10] * m[13] -
+             m[8] * m[1] * m[14] +
+             m[8] * m[2] * m[13] +
+             m[12] * m[1] * m[10] -
+             m[12] * m[2] * m[9];
+
+    inv[2] = m[1] * m[6] * m[15] -
+             m[1] * m[7] * m[14] -
+             m[5] * m[2] * m[15] +
+             m[5] * m[3] * m[14] +
+             m[13] * m[2] * m[7] -
+             m[13] * m[3] * m[6];
+
+    inv[6] = -m[0] * m[6] * m[15] +
+             m[0] * m[7] * m[14] +
+             m[4] * m[2] * m[15] -
+             m[4] * m[3] * m[14] -
+             m[12] * m[2] * m[7] +
+             m[12] * m[3] * m[6];
+
+    inv[10] = m[0] * m[5] * m[15] -
+              m[0] * m[7] * m[13] -
+              m[4] * m[1] * m[15] +
+              m[4] * m[3] * m[13] +
+              m[12] * m[1] * m[7] -
+              m[12] * m[3] * m[5];
+
+    inv[14] = -m[0] * m[5] * m[14] +
+              m[0] * m[6] * m[13] +
+              m[4] * m[1] * m[14] -
+              m[4] * m[2] * m[13] -
+              m[12] * m[1] * m[6] +
+              m[12] * m[2] * m[5];
+
+    inv[3] = -m[1] * m[6] * m[11] +
+             m[1] * m[7] * m[10] +
+             m[5] * m[2] * m[11] -
+             m[5] * m[3] * m[10] -
+             m[9] * m[2] * m[7] +
+             m[9] * m[3] * m[6];
+
+    inv[7] = m[0] * m[6] * m[11] -
+             m[0] * m[7] * m[10] -
+             m[4] * m[2] * m[11] +
+             m[4] * m[3] * m[10] +
+             m[8] * m[2] * m[7] -
+             m[8] * m[3] * m[6];
+
+    inv[11] = -m[0] * m[5] * m[11] +
+             m[0] * m[7] * m[9] +
+             m[4] * m[1] * m[11] -
+             m[4] * m[3] * m[9] -
+             m[8] * m[1] * m[7] +
+             m[8] * m[3] * m[5];
+
+    inv[15] = m[0] * m[5] * m[10] -
+              m[0] * m[6] * m[9] -
+              m[4] * m[1] * m[10] +
+              m[4] * m[2] * m[9] +
+              m[8] * m[1] * m[6] -
+              m[8] * m[2] * m[5];
+
+    float det = m[0] * inv[0] + m[1] * inv[4] + m[2] * inv[8] + m[3] * inv[12];
+    assert(det != 0.0f);
+
+    det = 1.0 / det;
+
+    std::array<float, 16> ret = {};
+    for (int i = 0; i < 16; ++i) {
+        ret[i] = inv[i] * det;
+    }
+
+    return ret;
+}
+
 std::string check_shader(GLuint handle)
 {
     std::string ret;
@@ -370,8 +502,8 @@ void Toolpaths::load(const Slic3r::GCodeProcessorResult& gcode_result, const std
     for (size_t i = 1; i < gcode_result.moves.size(); ++i) {
         const Slic3r::GCodeProcessorResult::MoveVertex& curr = gcode_result.moves[i];
         const Slic3r::GCodeProcessorResult::MoveVertex& prev = gcode_result.moves[i - 1];
-        const EMoveType curr_type = static_cast<EMoveType>(valueof(curr.type));
+        const EMoveType curr_type = valueof(curr.type);
-        const EGCodeExtrusionRole curr_role = static_cast<EGCodeExtrusionRole>(valueof(curr.extrusion_role));
+        const EGCodeExtrusionRole curr_role = valueof(curr.extrusion_role);
 
         EGCodeExtrusionRole extrusion_role;
         if (curr_type == EMoveType::Travel) {
@@ -430,6 +562,8 @@ void Toolpaths::load(const Slic3r::GCodeProcessorResult& gcode_result, const std
     m_valid_lines_bitset = BitSet<>(m_vertices.size());
     m_valid_lines_bitset.setAll();
 
+    static constexpr const Vec3f ZERO = { 0.0f, 0.0f, 0.0f };
+
     // buffers to send to gpu
     std::vector<Vec3f> positions;
     std::vector<Vec3f> heights_widths_angles;
@@ -440,13 +574,13 @@ void Toolpaths::load(const Slic3r::GCodeProcessorResult& gcode_result, const std
         const EMoveType move_type = v.type;
 
         const bool prev_line_valid = i > 0 && m_valid_lines_bitset[i - 1];
-        const Vec3f prev_line = prev_line_valid ? v.position - m_vertices[i - 1].position : toVec3f(0.0f);
+        const Vec3f prev_line = prev_line_valid ? v.position - m_vertices[i - 1].position : ZERO;
 
         const bool this_line_valid = i + 1 < m_vertices.size() &&
                                      m_vertices[i + 1].position != v.position &&
                                      m_vertices[i + 1].type == move_type &&
                                      move_type != EMoveType::Seam;
-        const Vec3f this_line = this_line_valid ? m_vertices[i + 1].position - v.position : toVec3f(0.0f);
+        const Vec3f this_line = this_line_valid ? m_vertices[i + 1].position - v.position : ZERO;
 
         if (this_line_valid) {
             // there is a valid path between point i and i+1.
@@ -463,7 +597,7 @@ void Toolpaths::load(const Slic3r::GCodeProcessorResult& gcode_result, const std
         positions.emplace_back(position);
 
         const float angle = atan2(prev_line[0] * this_line[1] - prev_line[1] * this_line[0], dot(prev_line, this_line));
-        heights_widths_angles.push_back(toVec3f(v.height, v.width, angle));
+        heights_widths_angles.push_back({ v.height, v.width, angle });
     }
 
     if (!positions.empty()) {
@@ -601,8 +735,11 @@ void Toolpaths::update_colors(const Settings& settings)
     glsafe(glBindBuffer(GL_TEXTURE_BUFFER, 0));
 }
 
-void Toolpaths::render(const Mat4x4f& view_matrix, const Mat4x4f& projection_matrix, const Vec3f& camera_position, const Settings& settings)
+void Toolpaths::render(const Mat4x4f& view_matrix, const Mat4x4f& projection_matrix, const Settings& settings)
 {
+    const Mat4x4f inv_view_matrix = inverse(view_matrix);
+    const Vec3f camera_position = { inv_view_matrix[12], inv_view_matrix[13], inv_view_matrix[14] };
+
     render_segments(view_matrix, projection_matrix, camera_position);
     render_options(view_matrix, projection_matrix);
     if (settings.options_visibility.at(EOptionType::ToolMarker))
@@ -871,7 +1008,7 @@ Color Toolpaths::select_color(const PathVertex& v, const Settings& settings) con
     }
     case EViewType::Tool:
     {
-        assert(v.get_extruder_id() < m_tool_colors.size());
+        assert(static_cast<size_t>(v.extruder_id) < m_tool_colors.size());
         return m_tool_colors[v.extruder_id];
     }
     case EViewType::ColorPrint:

src/slic3r/GUI/LibVGCode/Toolpaths.hpp

@@ -69,8 +69,7 @@ public:
     //
     // Render the toolpaths
     //
-    void render(const Mat4x4f& view_matrix, const Mat4x4f& projection_matrix,
+    void render(const Mat4x4f& view_matrix, const Mat4x4f& projection_matrix, const Settings& settings);
-        const Vec3f& camera_position, const Settings& settings);
 
     //
     // Properties getters

src/slic3r/GUI/LibVGCode/Types.hpp

@@ -10,86 +10,17 @@
 #if ENABLE_NEW_GCODE_VIEWER
 //################################################################################################################################
 
-#define LIBVGCODE_USE_EIGEN 0
-#if LIBVGCODE_USE_EIGEN
-#include <Eigen/Geometry>
-#else
-#include <map>
 #include <array>
-#endif // LIBVGCODE_USE_EIGEN
 
 namespace libvgcode {
 
-#if LIBVGCODE_USE_EIGEN
-using Vec3f   = Eigen::Matrix<float, 3, 1, Eigen::DontAlign>;
-using Mat4x4f = Eigen::Matrix<float, 4, 4, Eigen::DontAlign>;
-
-static float dot(const Vec3f& v1, const Vec3f& v2)
-{
-    return v1.dot(v2);
-}
-
-static Vec3f normalize(const Vec3f& v)
-{
-    return v.normalized();
-}
-
-static float length(const Vec3f& v)
-{
-    return v.norm();
-}
-#else
-using Vec3f   = std::array<float, 3>;
-using Mat4x4f = std::array<float, 16>;
-
-static float dot(const Vec3f& v1, const Vec3f& v2)
-{
-    return v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2];
-}
-
-static Vec3f normalize(const Vec3f& v)
-{
-    const float length = std::sqrt(dot(v, v));
-    assert(length > 0.0f);
-    const float inv_length = 1.0f / length;
-    return { v[0] * inv_length, v[1] * inv_length, v[2] * inv_length };
-}
-
-static float length(const Vec3f& v)
-{
-    return std::sqrt(dot(v, v));
-}
-#endif // LIBVGCODE_USE_EIGEN
-
-static_assert(sizeof(Vec3f) == 3 * sizeof(float));
-
-static Vec3f toVec3f(float value) { return { value, value, value }; };
-static Vec3f toVec3f(float x, float y, float z) { return { x, y, z }; };
-
-static bool operator == (const Vec3f& v1, const Vec3f& v2) {
-    return v1[0] == v2[0] && v1[1] == v2[1] && v1[2] == v2[2];
-}
-
-static bool operator != (const Vec3f& v1, const Vec3f& v2) {
-    return v1[0] != v2[0] || v1[1] != v2[1] || v1[2] != v2[2];
-}
-
-static Vec3f operator + (const Vec3f& v1, const Vec3f& v2) {
-    return { v1[0] + v2[0], v1[1] + v2[1], v1[2] + v2[2] };
-}
-
-static Vec3f operator - (const Vec3f& v1, const Vec3f& v2) {
-    return { v1[0] - v2[0], v1[1] - v2[1], v1[2] - v2[2] };
-}
-
-static Vec3f operator * (float f, const Vec3f& v) {
-    return { f * v[0], f * v[1], f * v[2] };
-}
-
-using Color = std::array<float, 3>;
-
 static constexpr float PI = 3.141592f;
 
+using Vec3f   = std::array<float, 3>;
+// 4 by 4 square matrix with column-major order
+using Mat4x4f = std::array<float, 16>;
+using Color   = std::array<float, 3>;
+
 // Alias for GCodeViewer::EViewType defined into GCodeViewer.hpp
 enum class EViewType : uint8_t
 {
@@ -103,7 +34,8 @@ enum class EViewType : uint8_t
     LayerTimeLinear,
     LayerTimeLogarithmic,
     Tool,
-    ColorPrint
+    ColorPrint,
+    COUNT
 };
 
 // Alias for EMoveType defined into GCodeProcessor.hpp
@@ -119,7 +51,8 @@ enum class EMoveType : uint8_t
     CustomGCode,
     Travel,
     Wipe,
-    Extrude
+    Extrude,
+    COUNT
 };
 
 // Alias for GCodeExtrusionRole defined into ExtrusionRole.hpp
@@ -139,7 +72,8 @@ enum class EGCodeExtrusionRole : uint8_t
 	  SupportMaterial,
 	  SupportMaterialInterface,
 	  WipeTower,
-	  Custom
+	  Custom,
+    COUNT
 };
 
 // Alias for Preview::OptionType defined into GUI_Preview.hpp
@@ -168,11 +102,6 @@ enum class ETimeMode : uint8_t
     COUNT
 };
 
-static uint8_t valueof(EMoveType type)
-{
-    return static_cast<uint8_t>(type);
-}
-
 } // namespace libvgcode
 
 //################################################################################################################################

src/slic3r/GUI/LibVGCode/Utils.cpp

@@ -9,6 +9,8 @@
 ///|/
 #include "Utils.hpp"
 
+#include <cmath>
+
 //################################################################################################################################
 // PrusaSlicer development only -> !!!TO BE REMOVED!!!
 #if ENABLE_NEW_GCODE_VIEWER
@@ -33,6 +35,44 @@ void add_triangle(uint16_t v1, uint16_t v2, uint16_t v3, std::vector<uint16_t>&
     indices.emplace_back(v3);
 }
 
+Vec3f normalize(const Vec3f& v)
+{
+    const float length = std::sqrt(dot(v, v));
+    assert(length > 0.0f);
+    const float inv_length = 1.0f / length;
+    return { v[0] * inv_length, v[1] * inv_length, v[2] * inv_length };
+}
+
+float dot(const Vec3f& v1, const Vec3f& v2)
+{
+    return v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2];
+}
+
+float length(const Vec3f& v)
+{
+    return std::sqrt(dot(v, v));
+}
+
+bool operator == (const Vec3f& v1, const Vec3f& v2) {
+    return v1[0] == v2[0] && v1[1] == v2[1] && v1[2] == v2[2];
+}
+
+bool operator != (const Vec3f& v1, const Vec3f& v2) {
+    return v1[0] != v2[0] || v1[1] != v2[1] || v1[2] != v2[2];
+}
+
+Vec3f operator + (const Vec3f& v1, const Vec3f& v2) {
+    return { v1[0] + v2[0], v1[1] + v2[1], v1[2] + v2[2] };
+}
+
+Vec3f operator - (const Vec3f& v1, const Vec3f& v2) {
+    return { v1[0] - v2[0], v1[1] - v2[1], v1[2] - v2[2] };
+}
+
+Vec3f operator * (float f, const Vec3f& v) {
+    return { f * v[0], f * v[1], f * v[2] };
+}
+
 } // namespace libvgcode
 
 //################################################################################################################################

src/slic3r/GUI/LibVGCode/Utils.hpp

@@ -19,6 +19,14 @@ namespace libvgcode {
 
 extern void add_vertex(const Vec3f& position, const Vec3f& normal, std::vector<float>& vertices);
 extern void add_triangle(uint16_t v1, uint16_t v2, uint16_t v3, std::vector<uint16_t>& indices);
+extern Vec3f normalize(const Vec3f& v);
+extern float dot(const Vec3f& v1, const Vec3f& v2);
+extern float length(const Vec3f& v);
+extern bool operator == (const Vec3f& v1, const Vec3f& v2);
+extern bool operator != (const Vec3f& v1, const Vec3f& v2);
+extern Vec3f operator + (const Vec3f& v1, const Vec3f& v2);
+extern Vec3f operator - (const Vec3f& v1, const Vec3f& v2);
+extern Vec3f operator * (float f, const Vec3f& v);
 
 } // namespace libvgcode
 

src/slic3r/GUI/LibVGCode/Viewer.cpp

@@ -110,7 +110,7 @@ void Viewer::load(const Slic3r::GCodeProcessorResult& gcode_result, const std::v
     m_settings.update_colors = true;
 }
 
-void Viewer::render(const Mat4x4f& view_matrix, const Mat4x4f& projection_matrix, const Vec3f& camera_position)
+void Viewer::render(const Mat4x4f& view_matrix, const Mat4x4f& projection_matrix)
 {
     if (m_settings.update_enabled_entities) {
         m_toolpaths.update_enabled_entities(m_view_range, m_settings);
@@ -122,7 +122,7 @@ void Viewer::render(const Mat4x4f& view_matrix, const Mat4x4f& projection_matrix
         m_settings.update_colors = false;
     }
 
-    m_toolpaths.render(view_matrix, projection_matrix, camera_position, m_settings);
+    m_toolpaths.render(view_matrix, projection_matrix, m_settings);
 
 //################################################################################################################################
     // Debug

src/slic3r/GUI/LibVGCode/Viewer.hpp

@@ -36,7 +36,7 @@ public:
 
     void init();
     void load(const Slic3r::GCodeProcessorResult& gcode_result, const std::vector<std::string>& str_tool_colors);
-    void render(const Mat4x4f& view_matrix, const Mat4x4f& projection_matrix, const Vec3f& camera_position);
+    void render(const Mat4x4f& view_matrix, const Mat4x4f& projection_matrix);
 
     EViewType get_view_type() const;
     void set_view_type(EViewType type);