Merge remote-tracking branch 'origin/master' into ys_msw_dpi

CMakeLists.txt

@@ -321,7 +321,7 @@ include_directories(${GLEW_INCLUDE_DIRS})
 # l10n
 set(L10N_DIR "${SLIC3R_RESOURCES_DIR}/localization")
 add_custom_target(pot
-    COMMAND xgettext --keyword=L --from-code=UTF-8 --debug
+    COMMAND xgettext --keyword=L --add-comments=TRN --from-code=UTF-8 --debug
         -f "${L10N_DIR}/list.txt"
         -o "${L10N_DIR}/Slic3rPE.pot"
     WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}

doc/Localization_guide.md

@@ -46,7 +46,7 @@ https://github.com/prusa3d/Slic3r/tree/master/resources/localization/list.txt.
 
 2.  Create template file(*.POT) with GNUgettext command:
     ```
-        xgettext --keyword=L --from-code=UTF-8 --debug -o Slic3rPE.pot -f list.txt
+        xgettext --keyword=L --add-comments=TRN --from-code=UTF-8 --debug -o Slic3rPE.pot -f list.txt
     ```
 
     Use flag `--from-code=UTF-8` to specify that the source strings are in UTF-8 encoding

src/libslic3r/Model.cpp

@@ -943,7 +943,7 @@ BoundingBoxf3 ModelObject::instance_bounding_box(size_t instance_idx, bool dont_
 // Calculate 2D convex hull of of a projection of the transformed printable volumes into the XY plane.
 // This method is cheap in that it does not make any unnecessary copy of the volume meshes.
 // This method is used by the auto arrange function.
-Polygon ModelObject::convex_hull_2d(const Transform3d &trafo_instance)
+Polygon ModelObject::convex_hull_2d(const Transform3d &trafo_instance) const
 {
     Points pts;
     for (const ModelVolume *v : this->volumes)

src/libslic3r/Model.hpp

@@ -234,7 +234,7 @@ public:
     // Calculate 2D convex hull of of a projection of the transformed printable volumes into the XY plane.
     // This method is cheap in that it does not make any unnecessary copy of the volume meshes.
     // This method is used by the auto arrange function.
-    Polygon       convex_hull_2d(const Transform3d &trafo_instance);
+    Polygon       convex_hull_2d(const Transform3d &trafo_instance) const;
 
 #if ENABLE_VOLUMES_CENTERING_FIXES
     void center_around_origin(bool include_modifiers = true);

src/libslic3r/ModelArrange.cpp

@@ -1,5 +1,6 @@
 #include "ModelArrange.hpp"
 #include "Model.hpp"
+#include "Geometry.hpp"
 #include "SVG.hpp"
 
 #include <libnest2d.h>
@@ -551,7 +552,7 @@ ShapeData2D projectModelFromTop(const Slic3r::Model &model) {
     ret.reserve(s);
 
     for(ModelObject* objptr : model.objects) {
-        if(objptr) {
+        if (! objptr->instances.empty()) {
 
             // TODO export the exact 2D projection. Cannot do it as libnest2d
             // does not support concave shapes (yet).
@@ -572,8 +573,9 @@ ShapeData2D projectModelFromTop(const Slic3r::Model &model) {
                 clpath = Slic3rMultiPoint_to_ClipperPath(p);
             }
 
+            Vec3d rotation0 = objptr->instances.front()->get_rotation();
+            rotation0(2) = 0.;
             for(ModelInstance* objinst : objptr->instances) {
-                if(objinst) {
                 ClipperLib::Polygon pn;
                 pn.Contour = clpath;
 
@@ -582,7 +584,7 @@ ShapeData2D projectModelFromTop(const Slic3r::Model &model) {
 
                 // Invalid geometries would throw exceptions when arranging
                 if(item.vertexCount() > 3) {
-                        item.rotation(objinst->get_rotation(Z));
+                    item.rotation(float(Geometry::rotation_diff_z(rotation0, objinst->get_rotation()))),
                     item.translation({
                     ClipperLib::cInt(objinst->get_offset(X)/SCALING_FACTOR),
                     ClipperLib::cInt(objinst->get_offset(Y)/SCALING_FACTOR)
@@ -592,7 +594,6 @@ ShapeData2D projectModelFromTop(const Slic3r::Model &model) {
             }
         }
     }
-    }
 
     return ret;
 }

src/libslic3r/Print.cpp

@@ -1139,31 +1139,29 @@ std::string Print::validate() const
         // Check horizontal clearance.
         {
             Polygons convex_hulls_other;
-            for (const PrintObject *object : m_objects) {
+            for (const PrintObject *print_object : m_objects) {
+                assert(! print_object->model_object()->instances.empty());
+                assert(! print_object->copies().empty());
                 // Get convex hull of all meshes assigned to this print object.
-                Polygon convex_hull;
+                ModelInstance *model_instance0 = print_object->model_object()->instances.front();
-                {
+                Vec3d          rotation        = model_instance0->get_rotation();
-                    Polygons mesh_convex_hulls;
+                rotation.z() = 0.;
-                    for (const std::vector<int> &volumes : object->region_volumes)
+                // Calculate the convex hull of a printable object centered around X=0,Y=0. 
-                        for (int volume_id : volumes)
-                            mesh_convex_hulls.emplace_back(object->model_object()->volumes[volume_id]->mesh.convex_hull());
-                    // make a single convex hull for all of them
-                    convex_hull = Slic3r::Geometry::convex_hull(mesh_convex_hulls);
-                }
-                // Apply the same transformations we apply to the actual meshes when slicing them.
-                object->model_object()->instances.front()->transform_polygon(&convex_hull);
                 // Grow convex hull with the clearance margin.
                 // FIXME: Arrangement has different parameters for offsetting (jtMiter, limit 2)
                 // which causes that the warning will be showed after arrangement with the
                 // appropriate object distance. Even if I set this to jtMiter the warning still shows up.
-                convex_hull = offset(convex_hull, scale_(m_config.extruder_clearance_radius.value)/2, jtRound, scale_(0.1)).front();
+                Polygon        convex_hull0    = offset(
+                    print_object->model_object()->convex_hull_2d(
+                        Geometry::assemble_transform(Vec3d::Zero(), rotation, model_instance0->get_scaling_factor(), model_instance0->get_mirror())),
+                    scale_(m_config.extruder_clearance_radius.value) / 2., jtRound, scale_(0.1)).front();
                 // Now we check that no instance of convex_hull intersects any of the previously checked object instances.
-                for (const Point &copy : object->m_copies) {
+                for (const Point &copy : print_object->m_copies) {
-                    Polygon p = convex_hull;
+                    Polygon convex_hull = convex_hull0;
-                    p.translate(copy);
+                    convex_hull.translate(copy);
-                    if (! intersection(convex_hulls_other, p).empty())
+                    if (! intersection(convex_hulls_other, convex_hull).empty())
                         return L("Some objects are too close; your extruder will collide with them.");
-                    polygons_append(convex_hulls_other, p);
+                    polygons_append(convex_hulls_other, convex_hull);
                 }
             }
         }

src/libslic3r/PrintConfig.cpp

@@ -2926,7 +2926,7 @@ CLIActionsConfigDef::CLIActionsConfigDef()
     
     // Actions:
     def = this->add("export_obj", coBool);
-    def->label = L("Export SVG");
+    def->label = L("Export OBJ");
     def->tooltip = L("Export the model(s) as OBJ.");
     def->default_value = new ConfigOptionBool(false);
     

src/libslic3r/SLAPrint.cpp

@@ -598,8 +598,9 @@ std::string SLAPrint::validate() const
     for(SLAPrintObject * po : m_objects) {
 
         const ModelObject *mo = po->model_object();
+        bool supports_en = po->config().supports_enable.getBool();
 
-        if(po->config().supports_enable.getBool() &&
+        if(supports_en &&
            mo->sla_points_status == sla::PointsStatus::UserModified &&
            mo->sla_support_points.empty())
             return L("Cannot proceed without support points! "
@@ -613,7 +614,7 @@ std::string SLAPrint::validate() const
                 2 * cfg.head_back_radius_mm -
                 cfg.head_penetration_mm;
 
-        if(pinhead_width > cfg.object_elevation_mm)
+        if(supports_en && pinhead_width > cfg.object_elevation_mm)
             return L("Elevation is too low for object.");
     }
 
@@ -696,6 +697,7 @@ void SLAPrint::process()
                 po.closest_slice_record(po.m_slice_index, float(bb3d.min(Z)));
 
         if(slindex_it == po.m_slice_index.end())
+			//TRN To be shown at the status bar on SLA slicing error.
             throw std::runtime_error(L("Slicing had to be stopped "
                                        "due to an internal error."));
 

src/libslic3r/SupportMaterial.cpp

@@ -160,17 +160,13 @@ PrintObjectSupportMaterial::PrintObjectSupportMaterial(const PrintObject *object
         m_support_material_interface_flow = m_support_material_flow;
     }
 
+    // Evaluate the XY gap between the object outer perimeters and the support structures.
     // Evaluate the XY gap between the object outer perimeters and the support structures.
     coordf_t external_perimeter_width = 0.;
-    for (size_t region_id = 0; region_id < object->region_volumes.size(); ++ region_id) {
+    for (size_t region_id = 0; region_id < object->region_volumes.size(); ++ region_id)
-        if (! object->region_volumes[region_id].empty()) {
+        if (! object->region_volumes[region_id].empty())
-            const PrintRegionConfig &config = object->print()->get_region(region_id)->config();
+            external_perimeter_width = std::max(external_perimeter_width,
-            coordf_t width = config.external_perimeter_extrusion_width.get_abs_value(slicing_params.layer_height);
+                (coordf_t)object->print()->get_region(region_id)->flow(frExternalPerimeter, slicing_params.layer_height, false, false, -1, *object).width);
-            if (width <= 0.)
-                width = m_print_config->nozzle_diameter.get_at(config.perimeter_extruder-1);
-            external_perimeter_width = std::max(external_perimeter_width, width);
-        }
-    }
     m_gap_xy = m_object_config->support_material_xy_spacing.get_abs_value(external_perimeter_width);
 
     m_can_merge_support_regions = m_object_config->support_material_extruder.value == m_object_config->support_material_interface_extruder.value;

src/slic3r/GUI/ConfigWizard.cpp

@@ -782,6 +782,8 @@ void ConfigWizardIndex::on_paint(wxPaintEvent & evt)
     const int yoff_text = bullet_h > em_h ? (bullet_h - em_h) / 2 : 0;
     const int yinc = item_height();
 
+    int index_width = 0;
+
     unsigned y = 0;
     for (size_t i = 0; i < items.size(); i++) {
         const Item& item = items[i];
@@ -799,8 +801,18 @@ void ConfigWizardIndex::on_paint(wxPaintEvent & evt)
         else if (i < item_active)  { dc.DrawBitmap(bullet_black.bmp(), x, y + yoff_icon, false); }
         else if (i > item_active)  { dc.DrawBitmap(bullet_white.bmp(), x, y + yoff_icon, false); }
 
-        dc.DrawText(item.label, x + bullet_w + em/2, y + yoff_text);
+        x += + bullet_w + em/2;
+        const auto text_size = dc.GetTextExtent(item.label);
+        dc.DrawText(item.label, x, y + yoff_text);
+
         y += yinc;
+        index_width = std::max(index_width, (int)x + text_size.x);
+    }
+
+    if (GetMinSize().x < index_width) {
+        CallAfter([this, index_width]() {
+            SetMinSize(wxSize(index_width, GetMinSize().y));
+        });
     }
 }
 

src/slic3r/GUI/GLCanvas3D.cpp

@@ -2390,6 +2390,10 @@ void GLCanvas3D::on_mouse_wheel(wxMouseEvent& evt)
         }
     }
 
+    // Inform gizmos about the event so they have the opportunity to react.
+    if (m_gizmos.on_mouse_wheel(evt, *this))
+        return;
+
     // Calculate the zoom delta and apply it to the current zoom factor
     float zoom = (float)evt.GetWheelRotation() / (float)evt.GetWheelDelta();
     set_camera_zoom(zoom);

src/slic3r/GUI/GUI_App.cpp

@@ -34,7 +34,7 @@
 
 #include "../Utils/PresetUpdater.hpp"
 #include "../Utils/PrintHost.hpp"
-#include "ConfigWizard_private.hpp"
+#include "ConfigWizard.hpp"
 #include "slic3r/Config/Snapshot.hpp"
 #include "ConfigSnapshotDialog.hpp"
 #include "FirmwareDialog.hpp"
@@ -230,7 +230,7 @@ bool GUI_App::on_init_inner()
         // and after MainFrame is created & shown.
         // The extra CallAfter() is needed because of Mac, where this is the only way
         // to popup a modal dialog on start without screwing combo boxes.
-        // This is ugly but I honestly found not better way to do it.
+        // This is ugly but I honestly found no better way to do it.
         // Neither wxShowEvent nor wxWindowCreateEvent work reliably.
         static bool once = true;
         if (once) {

src/slic3r/GUI/Gizmos/GLGizmoSlaSupports.cpp

@@ -92,28 +92,29 @@ void GLGizmoSlaSupports::on_render(const Selection& selection) const
     glsafe(::glEnable(GL_BLEND));
     glsafe(::glEnable(GL_DEPTH_TEST));
 
-    // we'll recover current look direction from the modelview matrix (in world coords):
-    Eigen::Matrix<double, 4, 4, Eigen::DontAlign> modelview_matrix;
-    ::glGetDoublev(GL_MODELVIEW_MATRIX, modelview_matrix.data());
-    Vec3d direction_to_camera(modelview_matrix.data()[2], modelview_matrix.data()[6], modelview_matrix.data()[10]);
     m_z_shift = selection.get_volume(*selection.get_volume_idxs().begin())->get_sla_shift_z();
 
     if (m_quadric != nullptr && selection.is_from_single_instance())
-        render_points(selection, direction_to_camera, false);
+        render_points(selection, false);
 
     render_selection_rectangle();
-    render_clipping_plane(selection, direction_to_camera);
+    render_clipping_plane(selection);
 
     glsafe(::glDisable(GL_BLEND));
 }
 
 
 
-void GLGizmoSlaSupports::render_clipping_plane(const Selection& selection, const Vec3d& direction_to_camera) const
+void GLGizmoSlaSupports::render_clipping_plane(const Selection& selection) const
 {
     if (m_clipping_plane_distance == 0.f)
         return;
 
+    if (m_clipping_plane_normal == Vec3d::Zero())
+        reset_clipping_plane_normal();
+
+    const Vec3d& direction_to_camera = m_clipping_plane_normal;
+
     // First cache instance transformation to be used later.
     const GLVolume* vol = selection.get_volume(*selection.get_volume_idxs().begin());
     Transform3f instance_matrix = vol->get_instance_transformation().get_matrix().cast<float>();
@@ -137,9 +138,9 @@ void GLGizmoSlaSupports::render_clipping_plane(const Selection& selection, const
     // In case either of these was recently changed, the cached triangulated ExPolygons are invalid now.
     // We are gonna recalculate them both for the object and for the support structures.
     if (m_clipping_plane_distance != m_old_clipping_plane_distance
-     || m_old_direction_to_camera != direction_to_camera) {
+     || m_old_clipping_plane_normal != direction_to_camera) {
 
-        m_old_direction_to_camera = direction_to_camera;
+        m_old_clipping_plane_normal = direction_to_camera;
         m_old_clipping_plane_distance = m_clipping_plane_distance;
 
         // Now initialize the TMS for the object, perform the cut and save the result.
@@ -198,8 +199,6 @@ void GLGizmoSlaSupports::render_clipping_plane(const Selection& selection, const
     }
 
     // At this point we have the triangulated cuts for both the object and supports - let's render.
-    ::glColor3f(1.0f, 0.37f, 0.0f);
-
 	if (! m_triangles.empty()) {
 		::glPushMatrix();
 		::glTranslated(0.0, 0.0, m_z_shift);
@@ -208,7 +207,8 @@ void GLGizmoSlaSupports::render_clipping_plane(const Selection& selection, const
 		q.setFromTwoVectors(Vec3f::UnitZ(), up);
 		Eigen::AngleAxisf aa(q);
 		::glRotatef(aa.angle() * (180./M_PI), aa.axis()(0), aa.axis()(1), aa.axis()(2));
-		::glTranslatef(0.f, 0.f, -0.001f); // to make sure the cut is safely beyond the near clipping plane
+		::glTranslatef(0.f, 0.f, 0.01f); // to make sure the cut does not intersect the structure itself
+        ::glColor3f(1.0f, 0.37f, 0.0f);
         ::glBegin(GL_TRIANGLES);
         for (const Vec2f& point : m_triangles)
             ::glVertex3f(point(0), point(1), height_mesh);
@@ -217,14 +217,16 @@ void GLGizmoSlaSupports::render_clipping_plane(const Selection& selection, const
 		::glPopMatrix();
 	}
 
-    if (! m_supports_triangles.empty()) {
+    if (! m_supports_triangles.empty() && !m_editing_mode) {
+        // The supports are hidden in the editing mode, so it makes no sense to render the cuts.
 		::glPushMatrix();
         ::glMultMatrixd(supports_trafo.data());
         Eigen::Quaternionf q;
 		q.setFromTwoVectors(Vec3f::UnitZ(), up_supports);
 		Eigen::AngleAxisf aa(q);
 		::glRotatef(aa.angle() * (180./M_PI), aa.axis()(0), aa.axis()(1), aa.axis()(2));
-		::glTranslatef(0.f, 0.f, -0.001f); // to make sure the cut is safely beyond the near clipping plane
+		::glTranslatef(0.f, 0.f, 0.01f);
+        ::glColor3f(1.0f, 0.f, 0.37f);
         ::glBegin(GL_TRIANGLES);
         for (const Vec2f& point : m_supports_triangles)
             ::glVertex3f(point(0), point(1), height_supports);
@@ -284,16 +286,10 @@ void GLGizmoSlaSupports::render_selection_rectangle() const
 void GLGizmoSlaSupports::on_render_for_picking(const Selection& selection) const
 {
     glsafe(::glEnable(GL_DEPTH_TEST));
-
+    render_points(selection, true);
-    // we'll recover current look direction from the modelview matrix (in world coords):
-    Eigen::Matrix<double, 4, 4, Eigen::DontAlign> modelview_matrix;
-    ::glGetDoublev(GL_MODELVIEW_MATRIX, modelview_matrix.data());
-    Vec3d direction_to_camera(modelview_matrix.data()[2], modelview_matrix.data()[6], modelview_matrix.data()[10]);
-
-    render_points(selection, direction_to_camera, true);
 }
 
-void GLGizmoSlaSupports::render_points(const Selection& selection, const Vec3d& direction_to_camera, bool picking) const
+void GLGizmoSlaSupports::render_points(const Selection& selection, bool picking) const
 {
     if (!picking)
         glsafe(::glEnable(GL_LIGHTING));
@@ -312,7 +308,7 @@ void GLGizmoSlaSupports::render_points(const Selection& selection, const Vec3d&
         const sla::SupportPoint& support_point = m_editing_mode_cache[i].support_point;
         const bool& point_selected = m_editing_mode_cache[i].selected;
 
-        if (is_point_clipped(support_point.pos.cast<double>(), direction_to_camera))
+        if (is_point_clipped(support_point.pos.cast<double>()))
             continue;
 
         // First decide about the color of the point.
@@ -386,8 +382,10 @@ void GLGizmoSlaSupports::render_points(const Selection& selection, const Vec3d&
 
 
 
-bool GLGizmoSlaSupports::is_point_clipped(const Vec3d& point, const Vec3d& direction_to_camera) const
+bool GLGizmoSlaSupports::is_point_clipped(const Vec3d& point) const
 {
+    const Vec3d& direction_to_camera = m_clipping_plane_normal;
+
     if (m_clipping_plane_distance == 0.f)
         return false;
 
@@ -457,9 +455,6 @@ std::pair<Vec3f, Vec3f> GLGizmoSlaSupports::unproject_on_mesh(const Vec2d& mouse
     const Selection& selection = m_parent.get_selection();
     const GLVolume* volume = selection.get_volume(*selection.get_volume_idxs().begin());
 
-    // we'll recover current look direction from the modelview matrix (in world coords):
-    Vec3d direction_to_camera(modelview_matrix.data()[2], modelview_matrix.data()[6], modelview_matrix.data()[10]);
-
     point1(2) -= m_z_shift;
 	point2(2) -= m_z_shift;
 
@@ -486,7 +481,7 @@ std::pair<Vec3f, Vec3f> GLGizmoSlaSupports::unproject_on_mesh(const Vec2d& mouse
         a = (m_V.row(m_F(fid, 1)) - m_V.row(m_F(fid, 0)));
         b = (m_V.row(m_F(fid, 2)) - m_V.row(m_F(fid, 0)));
         result = bc(0) * m_V.row(m_F(fid, 0)) + bc(1) * m_V.row(m_F(fid, 1)) + bc(2)*m_V.row(m_F(fid, 2));
-        if (m_clipping_plane_distance == 0.f || !is_point_clipped(result.cast<double>(), direction_to_camera))
+        if (m_clipping_plane_distance == 0.f || !is_point_clipped(result.cast<double>()))
             break;
     }
 
@@ -591,7 +586,7 @@ bool GLGizmoSlaSupports::gizmo_event(SLAGizmoEventType action, const Vec2d& mous
                   ::gluProject((GLdouble)pos(0), (GLdouble)pos(1), (GLdouble)pos(2), (GLdouble*)modelview_matrix.data(), (GLdouble*)projection_matrix.data(), (GLint*)viewport.data(), &out_x, &out_y, &out_z);
                   out_y = m_canvas_height - out_y;
 
-                if (rectangle.contains(Point(out_x, out_y)) && !is_point_clipped(support_point.pos.cast<double>(), direction_to_camera.cast<double>())) {
+                if (rectangle.contains(Point(out_x, out_y)) && !is_point_clipped(support_point.pos.cast<double>())) {
                     bool is_obscured = false;
                     // Cast a ray in the direction of the camera and look for intersection with the mesh:
                     std::vector<igl::Hit> hits;
@@ -615,7 +610,7 @@ bool GLGizmoSlaSupports::gizmo_event(SLAGizmoEventType action, const Vec2d& mous
 
                                 Vec3f bc = Vec3f(1-hit.u-hit.v, hit.u, hit.v); // barycentric coordinates of the hit
                                 Vec3f hit_pos = bc(0) * m_V.row(m_F(fid, 0)) + bc(1) * m_V.row(m_F(fid, 1)) + bc(2)*m_V.row(m_F(fid, 2));
-                                if (is_point_clipped(hit_pos.cast<double>(), direction_to_camera.cast<double>())) {
+                                if (is_point_clipped(hit_pos.cast<double>())) {
                                     hits.erase(hits.begin()+j);
                                     --j;
                                 }
@@ -707,6 +702,23 @@ bool GLGizmoSlaSupports::gizmo_event(SLAGizmoEventType action, const Vec2d& mous
         }
     }
 
+    if (action == SLAGizmoEventType::MouseWheelUp && control_down) {
+        m_clipping_plane_distance = std::min(1.f, m_clipping_plane_distance + 0.01f);
+        m_parent.set_as_dirty();
+        return true;
+    }
+
+    if (action == SLAGizmoEventType::MouseWheelDown && control_down) {
+        m_clipping_plane_distance = std::max(0.f, m_clipping_plane_distance - 0.01f);
+        m_parent.set_as_dirty();
+        return true;
+    }
+
+    if (action == SLAGizmoEventType::ResetClippingPlane) {
+        reset_clipping_plane_normal();
+        return true;
+    }
+
     return false;
 }
 
@@ -790,11 +802,12 @@ ClippingPlane GLGizmoSlaSupports::get_sla_clipping_plane() const
     if (!m_model_object || m_state == Off)
         return ClippingPlane::ClipsNothing();
 
-    Eigen::Matrix<GLdouble, 4, 4, Eigen::DontAlign> modelview_matrix;
+    //Eigen::Matrix<GLdouble, 4, 4, Eigen::DontAlign> modelview_matrix;
-    ::glGetDoublev(GL_MODELVIEW_MATRIX, modelview_matrix.data());
+    //::glGetDoublev(GL_MODELVIEW_MATRIX, modelview_matrix.data());
-
     // we'll recover current look direction from the modelview matrix (in world coords):
-    Vec3d direction_to_camera(modelview_matrix.data()[2], modelview_matrix.data()[6], modelview_matrix.data()[10]);
+    //Vec3d direction_to_camera(modelview_matrix.data()[2], modelview_matrix.data()[6], modelview_matrix.data()[10]);
+
+    const Vec3d& direction_to_camera = m_clipping_plane_normal;
     float dist = direction_to_camera.dot(m_model_object->instances[m_active_instance]->get_offset() + Vec3d(0., 0., m_z_shift));
 
     return ClippingPlane(-direction_to_camera.normalized(),(dist - (-m_active_instance_bb_radius) - m_clipping_plane_distance * 2*m_active_instance_bb_radius));
@@ -953,18 +966,27 @@ RENDER_AGAIN:
 
         m_imgui->text("");
 
-        m_imgui->text(m_model_object->sla_points_status == sla::PointsStatus::None ? "No points  (will be autogenerated)" :
+        m_imgui->text(m_model_object->sla_points_status == sla::PointsStatus::None ? _(L("No points  (will be autogenerated)")) :
-                     (m_model_object->sla_points_status == sla::PointsStatus::AutoGenerated ? "Autogenerated points (no modifications)" :
+                     (m_model_object->sla_points_status == sla::PointsStatus::AutoGenerated ? _(L("Autogenerated points (no modifications)")) :
-                     (m_model_object->sla_points_status == sla::PointsStatus::UserModified ? "User-modified points" :
+                     (m_model_object->sla_points_status == sla::PointsStatus::UserModified ? _(L("User-modified points")) :
-                     (m_model_object->sla_points_status == sla::PointsStatus::Generating ? "Generation in progress..." : "UNKNOWN STATUS"))));
+                     (m_model_object->sla_points_status == sla::PointsStatus::Generating ? _(L("Generation in progress...")) : "UNKNOWN STATUS"))));
     }
 
 
     // Following is rendered in both editing and non-editing mode:
+    if (m_clipping_plane_distance == 0.f)
         m_imgui->text("Clipping of view: ");
-    ImGui::SameLine();
+    else {
+        if (m_imgui->button(_(L("Reset direction [R] ")))) {
+            wxGetApp().CallAfter([this](){
+                    reset_clipping_plane_normal();
+                });
+        }
+    }
+
+    ImGui::SameLine(140.f);
     ImGui::PushItemWidth(150.0f);
-    bool value_changed = ImGui::SliderFloat("  ", &m_clipping_plane_distance, 0.f, 1.f, "%.2f");
+    ImGui::SliderFloat("  ", &m_clipping_plane_distance, 0.f, 1.f, "%.2f");
     
     m_imgui->end();
 
@@ -1207,5 +1229,17 @@ void GLGizmoSlaSupports::switch_to_editing_mode()
     m_editing_mode = true;
 }
 
+
+
+void GLGizmoSlaSupports::reset_clipping_plane_normal() const
+{
+    Eigen::Matrix<double, 4, 4, Eigen::DontAlign> modelview_matrix;
+    ::glGetDoublev(GL_MODELVIEW_MATRIX, modelview_matrix.data());
+    m_clipping_plane_normal = Vec3d(modelview_matrix.data()[2], modelview_matrix.data()[6], modelview_matrix.data()[10]);
+    m_parent.set_as_dirty();
+}
+
+
+
 } // namespace GUI
 } // namespace Slic3r

src/slic3r/GUI/Gizmos/GLGizmoSlaSupports.hpp

@@ -73,8 +73,8 @@ private:
     virtual void on_render_for_picking(const Selection& selection) const;
 
     void render_selection_rectangle() const;
-    void render_points(const Selection& selection, const Vec3d& direction_to_camera, bool picking = false) const;
+    void render_points(const Selection& selection, bool picking = false) const;
-    void render_clipping_plane(const Selection& selection, const Vec3d& direction_to_camera) const;
+    void render_clipping_plane(const Selection& selection) const;
     bool is_mesh_update_necessary() const;
     void update_mesh();
     void update_cache_entry_normal(unsigned int i) const;
@@ -87,7 +87,8 @@ private:
     mutable std::vector<CacheEntry> m_editing_mode_cache; // a support point and whether it is currently selected
     float m_clipping_plane_distance = 0.f;
     mutable float m_old_clipping_plane_distance = 0.f;
-    mutable Vec3d m_old_direction_to_camera;
+    mutable Vec3d m_old_clipping_plane_normal;
+    mutable Vec3d m_clipping_plane_normal = Vec3d::Zero();
 
     enum SelectionRectangleStatus {
         srOff = 0,
@@ -108,8 +109,8 @@ private:
     mutable std::unique_ptr<TriangleMeshSlicer> m_supports_tms;
 
     std::vector<const ConfigOption*> get_config_options(const std::vector<std::string>& keys) const;
-    bool is_point_clipped(const Vec3d& point, const Vec3d& direction_to_camera) const;
+    bool is_point_clipped(const Vec3d& point) const;
-    void find_intersecting_facets(const igl::AABB<Eigen::MatrixXf, 3>* aabb, const Vec3f& normal, double offset, std::vector<unsigned int>& out) const;
+    //void find_intersecting_facets(const igl::AABB<Eigen::MatrixXf, 3>* aabb, const Vec3f& normal, double offset, std::vector<unsigned int>& out) const;
 
     // Methods that do the model_object and editing cache synchronization,
     // editing mode selection, etc:
@@ -125,6 +126,7 @@ private:
     void get_data_from_backend();
     void auto_generate();
     void switch_to_editing_mode();
+    void reset_clipping_plane_normal() const;
 
 protected:
     void on_set_state() override;

src/slic3r/GUI/Gizmos/GLGizmos.hpp

@@ -14,7 +14,10 @@ enum class SLAGizmoEventType {
     ApplyChanges,
     DiscardChanges,
     AutomaticGeneration,
-    ManualEditing
+    ManualEditing,
+    MouseWheelUp,
+    MouseWheelDown,
+    ResetClippingPlane
 };
 
 #include "slic3r/GUI/Gizmos/GLGizmoMove.hpp"

src/slic3r/GUI/Gizmos/GLGizmosManager.cpp

@@ -520,6 +520,23 @@ void GLGizmosManager::render_overlay(const GLCanvas3D& canvas, const Selection&
     glsafe(::glPopMatrix());
 }
 
+
+
+bool GLGizmosManager::on_mouse_wheel(wxMouseEvent& evt, GLCanvas3D& canvas)
+{
+    bool processed = false;
+
+    if (m_current == SlaSupports) {
+        float rot = (float)evt.GetWheelRotation() / (float)evt.GetWheelDelta();
+        if (gizmo_event((rot > 0.f ? SLAGizmoEventType::MouseWheelUp : SLAGizmoEventType::MouseWheelDown), Vec2d::Zero(), evt.ShiftDown(), evt.AltDown(), evt.ControlDown()))
+            processed = true;
+    }
+
+    return processed;
+}
+
+
+
 bool GLGizmosManager::on_mouse(wxMouseEvent& evt, GLCanvas3D& canvas)
 {
     Point pos(evt.GetX(), evt.GetY());
@@ -761,6 +778,16 @@ bool GLGizmosManager::on_char(wxKeyEvent& evt, GLCanvas3D& canvas)
 
             break;
         }
+
+        case 'r' :
+        case 'R' :
+        {
+            if ((m_current == SlaSupports) && gizmo_event(SLAGizmoEventType::ResetClippingPlane))
+                processed = true;
+
+            break;
+        }
+
 #ifdef __APPLE__
         case WXK_BACK: // the low cost Apple solutions are not equipped with a Delete key, use Backspace instead.
 #else /* __APPLE__ */
@@ -794,7 +821,7 @@ bool GLGizmosManager::on_char(wxKeyEvent& evt, GLCanvas3D& canvas)
         }
     }
 
-    if (!processed)
+    if (!processed && !evt.HasModifiers())
     {
         if (handle_shortcut(keyCode, canvas.get_selection()))
         {

src/slic3r/GUI/Gizmos/GLGizmosManager.hpp

@@ -157,6 +157,7 @@ public:
     const std::string& get_tooltip() const { return m_tooltip; }
 
     bool on_mouse(wxMouseEvent& evt, GLCanvas3D& canvas);
+    bool on_mouse_wheel(wxMouseEvent& evt, GLCanvas3D& canvas);
     bool on_char(wxKeyEvent& evt, GLCanvas3D& canvas);
     bool on_key(wxKeyEvent& evt, GLCanvas3D& canvas);
 

src/slic3r/GUI/Plater.cpp

@@ -1239,8 +1239,8 @@ struct Plater::priv
     wxString project_filename;
 
     BackgroundSlicingProcess    background_process;
-    std::atomic<bool>           arranging;
+    bool                        arranging;
-    std::atomic<bool>           rotoptimizing;
+    bool                        rotoptimizing;
     bool                        delayed_scene_refresh;
     std::string                 delayed_error_message;
 
@@ -1403,8 +1403,8 @@ Plater::priv::priv(Plater *q, MainFrame *main_frame)
     , view_toolbar(GLToolbar::Radio)
 #endif // ENABLE_SVG_ICONS
 {
-    arranging.store(false);
+    arranging = false;
-    rotoptimizing.store(false);
+    rotoptimizing = false;
     background_process.set_fff_print(&fff_print);
 	background_process.set_sla_print(&sla_print);
     background_process.set_gcode_preview_data(&gcode_preview_data);
@@ -2095,15 +2095,14 @@ void Plater::priv::mirror(Axis axis)
 
 void Plater::priv::arrange()
 {
-    // don't do anything if currently arranging. Then this is a re-entrance
+    if (arranging) { return; }
-    if(arranging.load()) return;
+    arranging = true;
-
+    Slic3r::ScopeGuard arranging_guard([this]() { arranging = false; });
-    // Guard the arrange process
-    arranging.store(true);
 
     wxBusyCursor wait;
 
     this->background_process.stop();
+
     unsigned count = 0;
     for(auto obj : model.objects) count += obj->instances.size();
 
@@ -2119,14 +2118,14 @@ void Plater::priv::arrange()
         statusbar()->set_progress(count - st);
         statusbar()->set_status_text(msg);
 
-        // ok, this is dangerous, but we are protected by the atomic flag
+        // ok, this is dangerous, but we are protected by the flag
         // 'arranging' and the arrange button is also disabled.
         // This call is needed for the cancel button to work.
         wxYieldIfNeeded();
     };
 
     statusbar()->set_cancel_callback([this, statusfn](){
-        arranging.store(false);
+        arranging = false;
         statusfn(0, L("Arranging canceled"));
     });
 
@@ -2162,7 +2161,7 @@ void Plater::priv::arrange()
                      hint,
                      false, // create many piles not just one pile
                      [statusfn](unsigned st) { statusfn(st, arrangestr); },
-                     [this] () { return !arranging.load(); });
+                     [this] () { return !arranging; });
     } catch(std::exception& /*e*/) {
         GUI::show_error(this->q, L("Could not arrange model objects! "
                                    "Some geometries may be invalid."));
@@ -2171,7 +2170,6 @@ void Plater::priv::arrange()
     statusfn(0, L("Arranging done."));
     statusbar()->set_range(prev_range);
     statusbar()->set_cancel_callback(); // remove cancel button
-    arranging.store(false);
 
     // Do a full refresh of scene tree, including regenerating all the GLVolumes.
     //FIXME The update function shall just reload the modified matrices.
@@ -2186,11 +2184,12 @@ void Plater::priv::sla_optimize_rotation() {
     // running we should probably disable explicit slicing and background
     // processing
 
-    if(rotoptimizing.load()) return;
+    if (rotoptimizing) { return; }
-    rotoptimizing.store(true);
+    rotoptimizing = true;
+    Slic3r::ScopeGuard rotoptimizing_guard([this]() { rotoptimizing = false; });
 
     int obj_idx = get_selected_object_idx();
-    if(obj_idx < 0) { rotoptimizing.store(false); return; }
+    if (obj_idx < 0) { return; }
 
     ModelObject * o = model.objects[size_t(obj_idx)];
 
@@ -2208,14 +2207,14 @@ void Plater::priv::sla_optimize_rotation() {
     };
 
     statusbar()->set_cancel_callback([this, stfn](){
-        rotoptimizing.store(false);
+        rotoptimizing = false;
         stfn(0, L("Orientation search canceled"));
     });
 
     auto r = sla::find_best_rotation(
                 *o, .005f,
                 [stfn](unsigned s) { stfn(s, L("Searching for optimal orientation")); },
-                [this](){ return !rotoptimizing.load(); }
+                [this](){ return !rotoptimizing; }
     );
 
     const auto *bed_shape_opt = config->opt<ConfigOptionPoints>("bed_shape");
@@ -2228,7 +2227,7 @@ void Plater::priv::sla_optimize_rotation() {
     double mindist = 6.0; // FIXME
     double offs = mindist / 2.0 - EPSILON;
 
-    if(rotoptimizing.load()) // wasn't canceled
+    if(rotoptimizing) // wasn't canceled
     for(ModelInstance * oi : o->instances) {
         oi->set_rotation({r[X], r[Y], r[Z]});
 
@@ -2278,7 +2277,6 @@ void Plater::priv::sla_optimize_rotation() {
     stfn(0, L("Orientation found."));
     statusbar()->set_range(prev_range);
     statusbar()->set_cancel_callback();
-    rotoptimizing.store(false);
 
     update(true);
 }
@@ -2456,6 +2454,11 @@ unsigned int Plater::priv::update_background_process(bool force_validation)
 // Restart background processing thread based on a bitmask of UpdateBackgroundProcessReturnState.
 bool Plater::priv::restart_background_process(unsigned int state)
 {
+    if (arranging || rotoptimizing) {
+        // Avoid a race condition
+        return false;
+    }
+
 	if ( ! this->background_process.empty() &&
 		 (state & priv::UPDATE_BACKGROUND_PROCESS_INVALID) == 0 &&
 		 ( ((state & UPDATE_BACKGROUND_PROCESS_FORCE_RESTART) != 0 && ! this->background_process.finished()) ||
@@ -2682,6 +2685,11 @@ void Plater::priv::on_select_preset(wxCommandEvent &evt)
 void Plater::priv::on_slicing_update(SlicingStatusEvent &evt)
 {
     if (evt.status.percent >= -1) {
+        if (arranging || rotoptimizing) {
+            // Avoid a race condition
+            return;
+        }
+
         this->statusbar()->set_progress(evt.status.percent);
         this->statusbar()->set_status_text(_(L(evt.status.text)) + wxString::FromUTF8("…"));
     }
@@ -3139,12 +3147,20 @@ bool Plater::priv::can_delete_all() const
 
 bool Plater::priv::can_increase_instances() const
 {
+    if (arranging || rotoptimizing) {
+        return false;
+    }
+
     int obj_idx = get_selected_object_idx();
     return (0 <= obj_idx) && (obj_idx < (int)model.objects.size());
 }
 
 bool Plater::priv::can_decrease_instances() const
 {
+    if (arranging || rotoptimizing) {
+        return false;
+    }
+
     int obj_idx = get_selected_object_idx();
     return (0 <= obj_idx) && (obj_idx < (int)model.objects.size()) && (model.objects[obj_idx]->instances.size() > 1);
 }
@@ -3161,7 +3177,7 @@ bool Plater::priv::can_split_to_volumes() const
 
 bool Plater::priv::can_arrange() const
 {
-    return !model.objects.empty() && !arranging.load();
+    return !model.objects.empty() && !arranging;
 }
 
 bool Plater::priv::can_layers_editing() const
@@ -3302,9 +3318,9 @@ void Plater::remove_selected()
 
 void Plater::increase_instances(size_t num)
 {
+    if (! can_increase_instances()) { return; }
+
     int obj_idx = p->get_selected_object_idx();
-    if (obj_idx == -1)
-        return;
 
     ModelObject* model_object = p->model.objects[obj_idx];
     ModelInstance* model_instance = model_object->instances.back();
@@ -3336,9 +3352,9 @@ void Plater::increase_instances(size_t num)
 
 void Plater::decrease_instances(size_t num)
 {
+    if (! can_decrease_instances()) { return; }
+
     int obj_idx = p->get_selected_object_idx();
-    if (obj_idx == -1)
-        return;
 
     ModelObject* model_object = p->model.objects[obj_idx];
     if (model_object->instances.size() > num) {

src/slic3r/GUI/UpdateDialogs.cpp

@@ -27,7 +27,7 @@ static const std::string CONFIG_UPDATE_WIKI_URL("https://github.com/prusa3d/Slic
 // MsgUpdateSlic3r
 
 MsgUpdateSlic3r::MsgUpdateSlic3r(const Semver &ver_current, const Semver &ver_online) :
-	MsgDialog(nullptr, _(L("Update available")), wxString::Format(_(L("New version of % is available")), SLIC3R_APP_NAME)),
+	MsgDialog(nullptr, _(L("Update available")), wxString::Format(_(L("New version of %s is available")), SLIC3R_APP_NAME)),
 	ver_current(ver_current),
 	ver_online(ver_online)
 {