Fixed conflicts after merge with master + fixed rendering of hovered gizmo grabbers

7 files changed, 176 insertions, 110 deletions

diff --git a/src/libslic3r/GCode/GCodeProcessor.cpp b/src/libslic3r/GCode/GCodeProcessor.cpp
index f4b38e2ec..1e302c656 100644
--- a/src/libslic3r/GCode/GCodeProcessor.cpp
+++ b/src/libslic3r/GCode/GCodeProcessor.cpp
@@ -29,6 +29,11 @@ static const float MMMIN_TO_MMSEC = 1.0f / 60.0f;
 static const float DEFAULT_ACCELERATION = 1500.0f; // Prusa Firmware 1_75mm_MK2
 static const float DEFAULT_TRAVEL_ACCELERATION = 1250.0f;
 
+static const size_t MIN_EXTRUDERS_COUNT = 5;
+static const float DEFAULT_FILAMENT_DIAMETER = 1.75f;
+static const float DEFAULT_FILAMENT_DENSITY = 1.245f;
+static const Slic3r::Vec3f DEFAULT_EXTRUDER_OFFSET = Slic3r::Vec3f::Zero();
+
 namespace Slic3r {
 
 #if ENABLE_VALIDATE_CUSTOM_GCODE
@@ -187,72 +192,6 @@ void GCodeProcessor::TimeMachine::CustomGCodeTime::reset()
     times = std::vector<std::pair<CustomGCode::Type, float>>();
 }
 
-void GCodeProcessor::UsedFilaments::reset()
-{
-    color_change_cache = 0.0f;
-    volumes_per_color_change = std::vector<double>();
-
-    tool_change_cache = 0.0f;
-    volumes_per_extruder.clear();
-
-    role_cache = 0.0f;
-    filaments_per_role.clear();
-}
-
-void GCodeProcessor::UsedFilaments::increase_caches(double extruded_volume)
-{
-    color_change_cache  += extruded_volume;
-    tool_change_cache   += extruded_volume;
-    role_cache          += extruded_volume;
-}
-
-void GCodeProcessor::UsedFilaments::process_color_change_cache()
-{
-    if (color_change_cache != 0.0f) {
-        volumes_per_color_change.push_back(color_change_cache);
-        color_change_cache = 0.0f;
-    }
-}
-
-void GCodeProcessor::UsedFilaments::process_extruder_cache(GCodeProcessor* processor)
-{
-    size_t active_extruder_id = processor->m_extruder_id;
-    if (tool_change_cache != 0.0f) {
-        if (volumes_per_extruder.find(active_extruder_id) != volumes_per_extruder.end())
-            volumes_per_extruder[active_extruder_id] += tool_change_cache;
-        else
-            volumes_per_extruder[active_extruder_id] = tool_change_cache;
-        tool_change_cache = 0.0f;
-    }
-}
-
-void GCodeProcessor::UsedFilaments::process_role_cache(GCodeProcessor* processor)
-{
-    if (role_cache != 0.0f) {
-        std::pair<double, double> filament = { 0.0f, 0.0f };
-
-        double s = PI * sqr(0.5 * processor->m_filament_diameters[processor->m_extruder_id]);
-        filament.first = role_cache/s * 0.001;
-        filament.second = role_cache * processor->m_filament_densities[processor->m_extruder_id] * 0.001;
-
-        ExtrusionRole active_role = processor->m_extrusion_role;
-        if (filaments_per_role.find(active_role) != filaments_per_role.end()) {
-            filaments_per_role[active_role].first  += filament.first;
-            filaments_per_role[active_role].second += filament.second;
-        }
-        else
-            filaments_per_role[active_role] = filament;
-        role_cache = 0.0f;
-    }
-}
-
-void GCodeProcessor::UsedFilaments::process_caches(GCodeProcessor* processor)
-{
-    process_color_change_cache();
-    process_extruder_cache(processor);
-    process_role_cache(processor);
-}
-
 void GCodeProcessor::TimeMachine::reset()
 {
     enabled = false;
@@ -785,6 +724,95 @@ void GCodeProcessor::TimeProcessor::post_process(const std::string& filename)
             "Is " + out_path + " locked?" + '\n');
 }
 
+void GCodeProcessor::UsedFilaments::reset()
+{
+    color_change_cache = 0.0f;
+    volumes_per_color_change = std::vector<double>();
+
+    tool_change_cache = 0.0f;
+    volumes_per_extruder.clear();
+
+    role_cache = 0.0f;
+    filaments_per_role.clear();
+}
+
+void GCodeProcessor::UsedFilaments::increase_caches(double extruded_volume)
+{
+    color_change_cache += extruded_volume;
+    tool_change_cache += extruded_volume;
+    role_cache += extruded_volume;
+}
+
+void GCodeProcessor::UsedFilaments::process_color_change_cache()
+{
+    if (color_change_cache != 0.0f) {
+        volumes_per_color_change.push_back(color_change_cache);
+        color_change_cache = 0.0f;
+    }
+}
+
+void GCodeProcessor::UsedFilaments::process_extruder_cache(GCodeProcessor* processor)
+{
+    size_t active_extruder_id = processor->m_extruder_id;
+    if (tool_change_cache != 0.0f) {
+        if (volumes_per_extruder.find(active_extruder_id) != volumes_per_extruder.end())
+            volumes_per_extruder[active_extruder_id] += tool_change_cache;
+        else
+            volumes_per_extruder[active_extruder_id] = tool_change_cache;
+        tool_change_cache = 0.0f;
+    }
+}
+
+void GCodeProcessor::UsedFilaments::process_role_cache(GCodeProcessor* processor)
+{
+    if (role_cache != 0.0f) {
+        std::pair<double, double> filament = { 0.0f, 0.0f };
+
+        double s = PI * sqr(0.5 * processor->m_result.filament_diameters[processor->m_extruder_id]);
+        filament.first = role_cache / s * 0.001;
+        filament.second = role_cache * processor->m_result.filament_densities[processor->m_extruder_id] * 0.001;
+
+        ExtrusionRole active_role = processor->m_extrusion_role;
+        if (filaments_per_role.find(active_role) != filaments_per_role.end()) {
+            filaments_per_role[active_role].first += filament.first;
+            filaments_per_role[active_role].second += filament.second;
+        }
+        else
+            filaments_per_role[active_role] = filament;
+        role_cache = 0.0f;
+    }
+}
+
+void GCodeProcessor::UsedFilaments::process_caches(GCodeProcessor* processor)
+{
+    process_color_change_cache();
+    process_extruder_cache(processor);
+    process_role_cache(processor);
+}
+
+#if ENABLE_GCODE_VIEWER_STATISTICS
+void GCodeProcessor::Result::reset() {
+    moves = std::vector<GCodeProcessor::MoveVertex>();
+    bed_shape = Pointfs();
+    settings_ids.reset();
+    extruders_count = 0;
+    extruder_colors = std::vector<std::string>();
+    filament_diameters = std::vector<float>(MIN_EXTRUDERS_COUNT, DEFAULT_FILAMENT_DIAMETER);
+    filament_densities = std::vector<float>(MIN_EXTRUDERS_COUNT, DEFAULT_FILAMENT_DENSITY);
+    time = 0;
+}
+#else
+void GCodeProcessor::Result::reset() {
+    moves = std::vector<GCodeProcessor::MoveVertex>();
+    bed_shape = Pointfs();
+    settings_ids.reset();
+    extruders_count = 0;
+    extruder_colors = std::vector<std::string>();
+    filament_diameters = std::vector<float>(MIN_EXTRUDERS_COUNT, DEFAULT_FILAMENT_DIAMETER);
+    filament_densities = std::vector<float>(MIN_EXTRUDERS_COUNT, DEFAULT_FILAMENT_DENSITY);
+}
+#endif // ENABLE_GCODE_VIEWER_STATISTICS
+
 const std::vector<std::pair<GCodeProcessor::EProducer, std::string>> GCodeProcessor::Producers = {
     { EProducer::PrusaSlicer, "PrusaSlicer" },
     { EProducer::Slic3rPE,    "Slic3r Prusa Edition" },
@@ -886,14 +914,14 @@ void GCodeProcessor::apply_config(const PrintConfig& config)
 
     m_extruder_temps.resize(extruders_count);
 
-    m_filament_diameters.resize(config.filament_diameter.values.size());
+    m_result.filament_diameters.resize(config.filament_diameter.values.size());
     for (size_t i = 0; i < config.filament_diameter.values.size(); ++i) {
-        m_filament_diameters[i] = static_cast<float>(config.filament_diameter.values[i]);
+        m_result.filament_diameters[i] = static_cast<float>(config.filament_diameter.values[i]);
     }
 
-    m_filament_densities.resize(config.filament_density.values.size());
+    m_result.filament_densities.resize(config.filament_density.values.size());
     for (size_t i = 0; i < config.filament_density.values.size(); ++i) {
-        m_filament_densities[i] = static_cast<float>(config.filament_density.values[i]);
+        m_result.filament_densities[i] = static_cast<float>(config.filament_density.values[i]);
     }
 
     if ((m_flavor == gcfMarlinLegacy || m_flavor == gcfMarlinFirmware) && config.machine_limits_usage.value != MachineLimitsUsage::Ignore) {
@@ -959,21 +987,37 @@ void GCodeProcessor::apply_config(const DynamicPrintConfig& config)
     if (printer_settings_id != nullptr)
         m_result.settings_ids.printer = printer_settings_id->value;
 
+    m_result.extruders_count = config.option<ConfigOptionFloats>("nozzle_diameter")->values.size();
+
     const ConfigOptionFloats* filament_diameters = config.option<ConfigOptionFloats>("filament_diameter");
     if (filament_diameters != nullptr) {
-        for (double diam : filament_diameters->values) {
-            m_filament_diameters.push_back(static_cast<float>(diam));
+        m_result.filament_diameters.clear();
+        m_result.filament_diameters.resize(filament_diameters->values.size());
+        for (size_t i = 0; i < filament_diameters->values.size(); ++i) {
+            m_result.filament_diameters[i] = static_cast<float>(filament_diameters->values[i]);
+        }
+    }
+
+    if (m_result.filament_diameters.size() < m_result.extruders_count) {
+        for (size_t i = m_result.filament_diameters.size(); i < m_result.extruders_count; ++i) {
+            m_result.filament_diameters.emplace_back(DEFAULT_FILAMENT_DIAMETER);
         }
     }
 
     const ConfigOptionFloats* filament_densities = config.option<ConfigOptionFloats>("filament_density");
     if (filament_densities != nullptr) {
-        for (double dens : filament_densities->values) {
-            m_filament_densities.push_back(static_cast<float>(dens));
+        m_result.filament_densities.clear();
+        m_result.filament_densities.resize(filament_densities->values.size());
+        for (size_t i = 0; i < filament_densities->values.size(); ++i) {
+            m_result.filament_densities[i] = static_cast<float>(filament_densities->values[i]);
         }
     }
 
-    m_result.extruders_count = config.option<ConfigOptionFloats>("nozzle_diameter")->values.size();
+    if (m_result.filament_densities.size() < m_result.extruders_count) {
+        for (size_t i = m_result.filament_densities.size(); i < m_result.extruders_count; ++i) {
+            m_result.filament_densities.emplace_back(DEFAULT_FILAMENT_DENSITY);
+        }
+    }
 
     const ConfigOptionPoints* extruder_offset = config.option<ConfigOptionPoints>("extruder_offset");
     if (extruder_offset != nullptr) {
@@ -983,6 +1027,12 @@ void GCodeProcessor::apply_config(const DynamicPrintConfig& config)
             m_extruder_offsets[i] = { offset(0), offset(1), 0.0f };
         }
     }
+    
+    if (m_extruder_offsets.size() < m_result.extruders_count) {
+        for (size_t i = m_extruder_offsets.size(); i < m_result.extruders_count; ++i) {
+            m_extruder_offsets.emplace_back(DEFAULT_EXTRUDER_OFFSET);
+        }
+    }
 
     const ConfigOptionStrings* extruder_colour = config.option<ConfigOptionStrings>("extruder_colour");
     if (extruder_colour != nullptr) {
@@ -998,6 +1048,12 @@ void GCodeProcessor::apply_config(const DynamicPrintConfig& config)
         }
     }
 
+    if (m_result.extruder_colors.size() < m_result.extruders_count) {
+        for (size_t i = m_result.extruder_colors.size(); i < m_result.extruders_count; ++i) {
+            m_result.extruder_colors.emplace_back(std::string());
+        }
+    }
+
     // replace missing values with default
     std::string default_color = "#FF8000";
     for (size_t i = 0; i < m_result.extruder_colors.size(); ++i) {
@@ -1133,12 +1189,10 @@ void GCodeProcessor::enable_stealth_time_estimator(bool enabled)
 
 void GCodeProcessor::reset()
 {
-    static const size_t Min_Extruder_Count = 5;
-
     m_units = EUnits::Millimeters;
     m_global_positioning_type = EPositioningType::Absolute;
     m_e_local_positioning_type = EPositioningType::Absolute;
-    m_extruder_offsets = std::vector<Vec3f>(Min_Extruder_Count, Vec3f::Zero());
+    m_extruder_offsets = std::vector<Vec3f>(MIN_EXTRUDERS_COUNT, Vec3f::Zero());
     m_flavor = gcfRepRapSprinter;
 
     m_start_position = { 0.0f, 0.0f, 0.0f, 0.0f };
@@ -1163,17 +1217,15 @@ void GCodeProcessor::reset()
 
     m_extrusion_role = erNone;
     m_extruder_id = 0;
-    m_extruder_colors.resize(Min_Extruder_Count);
-    for (size_t i = 0; i < Min_Extruder_Count; ++i) {
+    m_extruder_colors.resize(MIN_EXTRUDERS_COUNT);
+    for (size_t i = 0; i < MIN_EXTRUDERS_COUNT; ++i) {
         m_extruder_colors[i] = static_cast<unsigned char>(i);
     }
-    m_extruder_temps.resize(Min_Extruder_Count);
-    for (size_t i = 0; i < Min_Extruder_Count; ++i) {
+    m_extruder_temps.resize(MIN_EXTRUDERS_COUNT);
+    for (size_t i = 0; i < MIN_EXTRUDERS_COUNT; ++i) {
         m_extruder_temps[i] = 0.0f;
     }
 
-    m_filament_diameters = std::vector<float>(Min_Extruder_Count, 1.75f);
-    m_filament_densities = std::vector<float>(Min_Extruder_Count, 1.245f);
     m_extruded_last_z = 0.0f;
 #if ENABLE_START_GCODE_VISUALIZATION
     m_first_layer_height = 0.0f;
@@ -2205,7 +2257,7 @@ void GCodeProcessor::process_G0(const GCodeReader::GCodeLine& line)
 
 void GCodeProcessor::process_G1(const GCodeReader::GCodeLine& line)
 {
-    float filament_diameter = (static_cast<size_t>(m_extruder_id) < m_filament_diameters.size()) ? m_filament_diameters[m_extruder_id] : m_filament_diameters.back();
+    float filament_diameter = (static_cast<size_t>(m_extruder_id) < m_result.filament_diameters.size()) ? m_result.filament_diameters[m_extruder_id] : m_result.filament_diameters.back();
     float filament_radius = 0.5f * filament_diameter;
     float area_filament_cross_section = static_cast<float>(M_PI) * sqr(filament_radius);
     auto absolute_position = [this, area_filament_cross_section](Axis axis, const GCodeReader::GCodeLine& lineG1) {
@@ -2307,7 +2359,7 @@ void GCodeProcessor::process_G1(const GCodeReader::GCodeLine& line)
             m_width = delta_pos[E] * static_cast<float>(M_PI * sqr(1.05f * filament_radius)) / (delta_xyz * m_height);
         else if (m_extrusion_role == erBridgeInfill || m_extrusion_role == erNone)
             // cross section: circle
-            m_width = static_cast<float>(m_filament_diameters[m_extruder_id]) * std::sqrt(delta_pos[E] / delta_xyz);
+            m_width = static_cast<float>(m_result.filament_diameters[m_extruder_id]) * std::sqrt(delta_pos[E] / delta_xyz);
         else
             // cross section: rectangle + 2 semicircles
             m_width = delta_pos[E] * static_cast<float>(M_PI * sqr(filament_radius)) / (delta_xyz * m_height) + static_cast<float>(1.0 - 0.25 * M_PI) * m_height;
@@ -2945,8 +2997,7 @@ void GCodeProcessor::process_T(const std::string_view command)
         } else {
             unsigned char id = static_cast<unsigned char>(eid);
             if (m_extruder_id != id) {
-                unsigned char extruders_count = static_cast<unsigned char>(m_extruder_offsets.size());
-                if (id >= extruders_count)
+                if (id >= m_result.extruders_count)
                     BOOST_LOG_TRIVIAL(error) << "GCodeProcessor encountered an invalid toolchange, maybe from a custom gcode.";
                 else {
                     unsigned char old_extruder_id = m_extruder_id;
diff --git a/src/libslic3r/GCode/GCodeProcessor.hpp b/src/libslic3r/GCode/GCodeProcessor.hpp
index 8975255ec..616731b49 100644
--- a/src/libslic3r/GCode/GCodeProcessor.hpp
+++ b/src/libslic3r/GCode/GCodeProcessor.hpp
@@ -343,7 +343,6 @@ namespace Slic3r {
             std::map<size_t, double> volumes_per_extruder;
 
             double role_cache;
-            //       ExtrusionRole : <used_filament_m, used_filament_g>
             std::map<ExtrusionRole, std::pair<double, double>> filaments_per_role;
 
             void reset();
@@ -403,27 +402,14 @@ namespace Slic3r {
             SettingsIds settings_ids;
             size_t extruders_count;
             std::vector<std::string> extruder_colors;
+            std::vector<float> filament_diameters;
+            std::vector<float> filament_densities;
             PrintEstimatedStatistics print_statistics;
 
 #if ENABLE_GCODE_VIEWER_STATISTICS
             int64_t time{ 0 };
-            void reset() {
-                time = 0;
-                moves = std::vector<MoveVertex>();
-                bed_shape = Pointfs();
-                extruder_colors = std::vector<std::string>();
-                extruders_count = 0;
-                settings_ids.reset();
-            }
-#else
-            void reset() {
-                moves = std::vector<MoveVertex>();
-                bed_shape = Pointfs();
-                extruder_colors = std::vector<std::string>();
-                extruders_count = 0;
-                settings_ids.reset();
-            }
 #endif // ENABLE_GCODE_VIEWER_STATISTICS
+            void reset();
         };
 
 #if ENABLE_SEAMS_VISUALIZATION
@@ -549,8 +535,6 @@ namespace Slic3r {
         unsigned char m_extruder_id;
         ExtruderColors m_extruder_colors;
         ExtruderTemps m_extruder_temps;
-        std::vector<float> m_filament_diameters;
-        std::vector<float> m_filament_densities;
         float m_extruded_last_z;
 #if ENABLE_START_GCODE_VISUALIZATION
         float m_first_layer_height; // mm
diff --git a/src/libslic3r/Point.hpp b/src/libslic3r/Point.hpp
index e5ce68420..ceb235244 100644
--- a/src/libslic3r/Point.hpp
+++ b/src/libslic3r/Point.hpp
@@ -27,6 +27,7 @@ using Vec2crd = Eigen::Matrix<coord_t,  2, 1, Eigen::DontAlign>;
 using Vec3crd = Eigen::Matrix<coord_t,  3, 1, Eigen::DontAlign>;
 using Vec2i   = Eigen::Matrix<int,      2, 1, Eigen::DontAlign>;
 using Vec3i   = Eigen::Matrix<int,      3, 1, Eigen::DontAlign>;
+using Vec4i   = Eigen::Matrix<int,      4, 1, Eigen::DontAlign>;
 using Vec2i32 = Eigen::Matrix<int32_t,  2, 1, Eigen::DontAlign>;
 using Vec2i64 = Eigen::Matrix<int64_t,  2, 1, Eigen::DontAlign>;
 using Vec3i32 = Eigen::Matrix<int32_t,  3, 1, Eigen::DontAlign>;
@@ -50,12 +51,15 @@ using Matrix2f       = Eigen::Matrix<float,  2, 2, Eigen::DontAlign>;
 using Matrix2d       = Eigen::Matrix<double, 2, 2, Eigen::DontAlign>;
 using Matrix3f       = Eigen::Matrix<float,  3, 3, Eigen::DontAlign>;
 using Matrix3d       = Eigen::Matrix<double, 3, 3, Eigen::DontAlign>;
+using Matrix4f       = Eigen::Matrix<float,  4, 4, Eigen::DontAlign>;
+using Matrix4d       = Eigen::Matrix<double, 4, 4, Eigen::DontAlign>;
 
 using Transform2f    = Eigen::Transform<float,  2, Eigen::Affine, Eigen::DontAlign>;
 using Transform2d    = Eigen::Transform<double, 2, Eigen::Affine, Eigen::DontAlign>;
 using Transform3f    = Eigen::Transform<float,  3, Eigen::Affine, Eigen::DontAlign>;
 using Transform3d    = Eigen::Transform<double, 3, Eigen::Affine, Eigen::DontAlign>;
 
+
 inline bool operator<(const Vec2d &lhs, const Vec2d &rhs) { return lhs(0) < rhs(0) || (lhs(0) == rhs(0) && lhs(1) < rhs(1)); }
 
 template<int Options>
diff --git a/src/libslic3r/SLA/Hollowing.cpp b/src/libslic3r/SLA/Hollowing.cpp
index 1d3016bde..32a881037 100644
--- a/src/libslic3r/SLA/Hollowing.cpp
+++ b/src/libslic3r/SLA/Hollowing.cpp
@@ -1,4 +1,5 @@
 #include <functional>
+#include <optional>
 
 #include <libslic3r/OpenVDBUtils.hpp>
 #include <libslic3r/TriangleMesh.hpp>
diff --git a/src/libslic3r/SLA/SupportTreeBuildsteps.hpp b/src/libslic3r/SLA/SupportTreeBuildsteps.hpp
index 013666f07..478e2df1f 100644
--- a/src/libslic3r/SLA/SupportTreeBuildsteps.hpp
+++ b/src/libslic3r/SLA/SupportTreeBuildsteps.hpp
@@ -2,6 +2,7 @@
 #define SLASUPPORTTREEALGORITHM_H
 
 #include <cstdint>
+#include <optional>
 
 #include <libslic3r/SLA/SupportTreeBuilder.hpp>
 #include <libslic3r/SLA/Clustering.hpp>
diff --git a/src/libslic3r/TriangleMesh.cpp b/src/libslic3r/TriangleMesh.cpp
index fba1429ea..99f2c9641 100644
--- a/src/libslic3r/TriangleMesh.cpp
+++ b/src/libslic3r/TriangleMesh.cpp
@@ -1014,6 +1014,33 @@ TriangleMesh make_cylinder(double r, double h, double fa)
     return mesh;
 }
 
+
+TriangleMesh make_cone(double r, double h, double fa)
+{
+    Pointf3s vertices;
+    std::vector<Vec3i>	facets;
+    vertices.reserve(3+size_t(2*PI/fa));
+    vertices.reserve(3+2*size_t(2*PI/fa));
+
+    vertices = { Vec3d::Zero(), Vec3d(0., 0., h) }; // base center and top vertex
+    size_t i = 0;
+    for (double angle=0; angle<2*PI; angle+=fa) {
+        vertices.emplace_back(r*std::cos(angle), r*std::sin(angle), 0.);
+        if (angle > 0.) {
+            facets.emplace_back(0, i+2, i+1);
+            facets.emplace_back(1, i+1, i+2);
+        }
+        ++i;
+    }
+    facets.emplace_back(0, 2, i+1); // close the shape
+    facets.emplace_back(1, i+1, 2);
+
+    TriangleMesh mesh(std::move(vertices), std::move(facets));
+    mesh.repair();
+    return mesh;
+}
+
+
 // Generates mesh for a sphere centered about the origin, using the generated angle
 // to determine the granularity. 
 // Default angle is 1 degree.
diff --git a/src/libslic3r/TriangleMesh.hpp b/src/libslic3r/TriangleMesh.hpp
index 49b11465e..24447d896 100644
--- a/src/libslic3r/TriangleMesh.hpp
+++ b/src/libslic3r/TriangleMesh.hpp
@@ -122,10 +122,8 @@ Polygon its_convex_hull_2d_above(const indexed_triangle_set &its, const Matrix3f
 Polygon its_convex_hull_2d_above(const indexed_triangle_set &its, const Transform3f &t, const float z);
 
 TriangleMesh make_cube(double x, double y, double z);
-
-// Generate a TriangleMesh of a cylinder
 TriangleMesh make_cylinder(double r, double h, double fa=(2*PI/360));
-
+TriangleMesh make_cone(double r, double h, double fa=(2*PI/360));
 TriangleMesh make_sphere(double rho, double fa=(2*PI/360));
 
 }