Fix Gizmo preview with hollowed mesh

src/libslic3r/SLAPrintSteps.cpp

@@ -169,7 +169,8 @@ void SLAPrint::Steps::drill_holes(SLAPrintObject &po)
     sla::hollow_mesh(hollowed_mesh, *po.m_hollowing_data->interior);
 
     TriangleMesh &mesh_view = po.m_hollowing_data->hollow_mesh_with_holes_trimmed;
-    sla::remove_inside_triangles(mesh_view, *po.m_hollowing_data->interior);
+    mesh_view = po.transformed_mesh();
+    sla::hollow_mesh(mesh_view, *po.m_hollowing_data->interior, sla::hfRemoveInsideTriangles);
 
     if (! needs_drilling) {
         BOOST_LOG_TRIVIAL(info) << "Drilling skipped (no holes).";

src/slic3r/GUI/Gizmos/GLGizmosCommon.cpp

@@ -200,12 +200,20 @@ void HollowedMesh::on_update()
         if (print_object->is_step_done(slaposDrillHoles) && print_object->has_mesh(slaposDrillHoles)) {
             size_t timestamp = print_object->step_state_with_timestamp(slaposDrillHoles).timestamp;
             if (timestamp > m_old_hollowing_timestamp) {
-                const TriangleMesh& backend_mesh = print_object->get_mesh_to_print();
+                const TriangleMesh& backend_mesh = print_object->get_mesh_to_slice();
                 if (! backend_mesh.empty()) {
                     m_hollowed_mesh_transformed.reset(new TriangleMesh(backend_mesh));
                     Transform3d trafo_inv = canvas->sla_print()->sla_trafo(*mo).inverse();
                     m_hollowed_mesh_transformed->transform(trafo_inv);
                     m_old_hollowing_timestamp = timestamp;
+
+                    const TriangleMesh &interior = print_object->hollowed_interior_mesh();
+                    if (!interior.empty()) {
+                        m_hollowed_interior_transformed = std::make_unique<TriangleMesh>(interior);
+                        m_hollowed_interior_transformed->repaired = false;
+                        m_hollowed_interior_transformed->repair(true);
+                        m_hollowed_interior_transformed->transform(trafo_inv);
+                    }
                 }
                 else
                     m_hollowed_mesh_transformed.reset(nullptr);
@@ -230,6 +238,10 @@ const TriangleMesh* HollowedMesh::get_hollowed_mesh() const
     return m_hollowed_mesh_transformed.get();
 }
 
+const TriangleMesh* HollowedMesh::get_hollowed_interior() const
+{
+    return m_hollowed_interior_transformed.get();
+}
 
 
 
@@ -306,6 +318,10 @@ void ObjectClipper::on_update()
             m_clippers.back()->set_mesh(*mesh);
         }
         m_old_meshes = meshes;
+
+        if (has_hollowed)
+            m_clippers.front()->set_negative_mesh(*get_pool()->hollowed_mesh()->get_hollowed_interior());
+
         m_active_inst_bb_radius =
             mo->instance_bounding_box(get_pool()->selection_info()->get_active_instance()).radius();
         //if (has_hollowed && m_clp_ratio != 0.)

src/slic3r/GUI/Gizmos/GLGizmosCommon.hpp

@@ -199,6 +199,7 @@ public:
 #endif // NDEBUG
 
     const TriangleMesh* get_hollowed_mesh() const;
+    const TriangleMesh* get_hollowed_interior() const;
 
 protected:
     void on_update() override;
@@ -206,6 +207,7 @@ protected:
 
 private:
     std::unique_ptr<TriangleMesh> m_hollowed_mesh_transformed;
+    std::unique_ptr<TriangleMesh> m_hollowed_interior_transformed;
     size_t m_old_hollowing_timestamp = 0;
     int m_print_object_idx = -1;
     int m_print_objects_count = 0;

src/slic3r/GUI/MeshUtils.cpp

@@ -2,6 +2,7 @@
 
 #include "libslic3r/Tesselate.hpp"
 #include "libslic3r/TriangleMesh.hpp"
+#include "libslic3r/ClipperUtils.hpp"
 
 #include "slic3r/GUI/Camera.hpp"
 
@@ -31,6 +32,15 @@ void MeshClipper::set_mesh(const TriangleMesh& mesh)
     }
 }
 
+void MeshClipper::set_negative_mesh(const TriangleMesh& mesh)
+{
+    if (m_negative_mesh != &mesh) {
+        m_negative_mesh = &mesh;
+        m_triangles_valid = false;
+        m_triangles2d.resize(0);
+    }
+}
+
 
 
 void MeshClipper::set_transformation(const Geometry::Transformation& trafo)
@@ -74,6 +84,15 @@ void MeshClipper::recalculate_triangles()
     std::vector<ExPolygons> list_of_expolys;
     m_tms->set_up_direction(up.cast<float>());
     m_tms->slice(std::vector<float>{height_mesh}, SlicingMode::Regular, 0.f, &list_of_expolys, [](){});
+
+    if (m_negative_mesh && !m_negative_mesh->empty()) {
+        TriangleMeshSlicer negative_tms{m_negative_mesh};
+        negative_tms.set_up_direction(up.cast<float>());
+
+        std::vector<ExPolygons> neg_polys;
+        negative_tms.slice(std::vector<float>{height_mesh}, SlicingMode::Regular, 0.f, &neg_polys, [](){});
+        list_of_expolys.front() = diff_ex(list_of_expolys.front(), neg_polys.front());
+    }
     m_triangles2d = triangulate_expolygons_2f(list_of_expolys[0], m_trafo.get_matrix().matrix().determinant() < 0.);
 
     // Rotate the cut into world coords:

src/slic3r/GUI/MeshUtils.hpp

@@ -78,6 +78,8 @@ public:
     // must make sure that it stays valid.
     void set_mesh(const TriangleMesh& mesh);
 
+    void set_negative_mesh(const TriangleMesh &mesh);
+
     // Inform the MeshClipper about the transformation that transforms the mesh
     // into world coordinates.
     void set_transformation(const Geometry::Transformation& trafo);
@@ -91,6 +93,7 @@ private:
 
     Geometry::Transformation m_trafo;
     const TriangleMesh* m_mesh = nullptr;
+    const TriangleMesh* m_negative_mesh = nullptr;
     ClippingPlane m_plane;
     std::vector<Vec2f> m_triangles2d;
     GLIndexedVertexArray m_vertex_array;