Merge branch 'master' of https://github.com/prusa3d/PrusaSlicer into et_gcode_viewer

src/libslic3r/Format/3mf.cpp

@@ -1114,6 +1114,15 @@ namespace Slic3r {
                                                       float(std::atof(object_data_points[i+6].c_str())),
                                                       float(std::atof(object_data_points[i+7].c_str())));
                 }
+
+                // The holes are saved elevated above the mesh and deeper (bad idea indeed).
+                // This is retained for compatibility.
+                // Place the hole to the mesh and make it shallower to compensate.
+                // The offset is 1 mm above the mesh.
+                for (sla::DrainHole& hole : sla_drain_holes) {
+                    hole.pos += hole.normal.normalized();
+                    hole.height -= 1.f;
+                }
                 
                 if (!sla_drain_holes.empty())
                     m_sla_drain_holes.insert(IdToSlaDrainHolesMap::value_type(object_id, sla_drain_holes));
@@ -2591,7 +2600,18 @@ namespace Slic3r {
         for (const ModelObject* object : model.objects)
         {
             ++count;
-            auto& drain_holes = object->sla_drain_holes;
+            sla::DrainHoles drain_holes = object->sla_drain_holes;
+
+            // The holes were placed 1mm above the mesh in the first implementation.
+            // This was a bad idea and the reference point was changed in 2.3 so
+            // to be on the mesh exactly. The elevated position is still saved
+            // in 3MFs for compatibility reasons.
+            for (sla::DrainHole& hole : drain_holes) {
+                hole.pos -= hole.normal.normalized();
+                hole.height += 1.f;
+            }
+
+
             if (!drain_holes.empty())
             {
                 out += string_printf(fmt, count);

src/libslic3r/Format/3mf.hpp

@@ -35,6 +35,6 @@ namespace Slic3r {
     // The model could be modified during the export process if meshes are not repaired or have no shared vertices
     extern bool store_3mf(const char* path, Model* model, const DynamicPrintConfig* config, bool fullpath_sources, const ThumbnailData* thumbnail_data = nullptr);
 
-}; // namespace Slic3r
+} // namespace Slic3r
 
 #endif /* slic3r_Format_3mf_hpp_ */

src/libslic3r/SLA/Hollowing.hpp

@@ -58,6 +58,8 @@ struct DrainHole
 
 using DrainHoles = std::vector<DrainHole>;
 
+constexpr float HoleStickOutLength = 1.f;
+
 std::unique_ptr<TriangleMesh> generate_interior(const TriangleMesh &mesh,
                                                 const HollowingConfig &  = {},
                                                 const JobController &ctl = {});

src/libslic3r/SLA/ReprojectPointsOnMesh.hpp

@@ -28,15 +28,9 @@ void reproject_support_points(const IndexedMesh &mesh, std::vector<PointType> &p
 inline void reproject_points_and_holes(ModelObject *object)
 {
     bool has_sppoints = !object->sla_support_points.empty();
+    bool has_holes    = !object->sla_drain_holes.empty();
 
-    // Disabling reprojection of holes as they have a significant offset away
-    // from the model body which tolerates minor geometrical changes.
-    //
-    // TODO: uncomment and ensure the right offset of the hole points if
-    // reprojection would still be necessary.
-    // bool has_holes    = !object->sla_drain_holes.empty();
-
-    if (!object || (/*!has_holes &&*/ !has_sppoints)) return;
+    if (!object || (!has_holes && !has_sppoints)) return;
 
     TriangleMesh rmsh = object->raw_mesh();
     rmsh.require_shared_vertices();
@@ -45,8 +39,8 @@ inline void reproject_points_and_holes(ModelObject *object)
     if (has_sppoints)
         reproject_support_points(emesh, object->sla_support_points);
 
-//    if (has_holes)
-//        reproject_support_points(emesh, object->sla_drain_holes);
+    if (has_holes)
+        reproject_support_points(emesh, object->sla_drain_holes);
 }
 
 }}

src/libslic3r/SLAPrint.cpp

@@ -1181,6 +1181,12 @@ sla::DrainHoles SLAPrintObject::transformed_drainhole_points() const
         hl.normal = Vec3f(hl.normal(0)/(sc(0)*sc(0)),
                           hl.normal(1)/(sc(1)*sc(1)),
                           hl.normal(2)/(sc(2)*sc(2)));
+
+        // Now shift the hole a bit above the object and make it deeper to
+        // compensate for it. This is to avoid problems when the hole is placed
+        // on (nearly) flat surface.
+        hl.pos -= hl.normal.normalized() * sla::HoleStickOutLength;
+        hl.height += sla::HoleStickOutLength;
     }
 
     return pts;