Merge branch 'lm_triangle_selector'

src/libslic3r/CMakeLists.txt

@@ -187,6 +187,8 @@ add_library(libslic3r STATIC
     Utils.hpp
     Time.cpp
     Time.hpp
+    TriangleSelector.cpp
+    TriangleSelector.hpp
     MTUtils.hpp
     VoronoiOffset.cpp
     VoronoiOffset.hpp

src/libslic3r/Format/3mf.cpp

@@ -86,6 +86,7 @@ const char* OBJECTID_ATTR = "objectid";
 const char* TRANSFORM_ATTR = "transform";
 const char* PRINTABLE_ATTR = "printable";
 const char* INSTANCESCOUNT_ATTR = "instances_count";
+const char* CUSTOM_SUPPORTS_ATTR = "slic3rpe:custom_supports";
 
 const char* KEY_ATTR = "key";
 const char* VALUE_ATTR = "value";
@@ -283,6 +284,7 @@ namespace Slic3r {
         {
             std::vector<float> vertices;
             std::vector<unsigned int> triangles;
+            std::vector<std::string> custom_supports;
 
             bool empty()
             {
@@ -293,6 +295,7 @@ namespace Slic3r {
             {
                 vertices.clear();
                 triangles.clear();
+                custom_supports.clear();
             }
         };
 
@@ -1539,6 +1542,8 @@ namespace Slic3r {
         m_curr_object.geometry.triangles.push_back((unsigned int)get_attribute_value_int(attributes, num_attributes, V1_ATTR));
         m_curr_object.geometry.triangles.push_back((unsigned int)get_attribute_value_int(attributes, num_attributes, V2_ATTR));
         m_curr_object.geometry.triangles.push_back((unsigned int)get_attribute_value_int(attributes, num_attributes, V3_ATTR));
+
+        m_curr_object.geometry.custom_supports.push_back(get_attribute_value_string(attributes, num_attributes, CUSTOM_SUPPORTS_ATTR));
         return true;
     }
 
@@ -1872,6 +1877,13 @@ namespace Slic3r {
                 volume->source.transform = Slic3r::Geometry::Transformation(volume_matrix_to_object);
             volume->calculate_convex_hull();
 
+            // recreate custom supports from previously loaded attribute
+            assert(geometry.custom_supports.size() == triangles_count);
+            for (unsigned i=0; i<triangles_count; ++i) {
+                if (! geometry.custom_supports[i].empty())
+                    volume->m_supported_facets.set_triangle_from_string(i, geometry.custom_supports[i]);
+            }
+
             // apply the remaining volume's metadata
             for (const Metadata& metadata : volume_data.metadata)
             {
@@ -2383,6 +2395,11 @@ namespace Slic3r {
                 {
                     stream << "v" << j + 1 << "=\"" << its.indices[i][j] + volume_it->second.first_vertex_id << "\" ";
                 }
+
+                std::string custom_supports_data_string = volume->m_supported_facets.get_triangle_as_string(i);
+                if (! custom_supports_data_string.empty())
+                    stream << CUSTOM_SUPPORTS_ATTR << "=\"" << custom_supports_data_string << "\" ";
+
                 stream << "/>\n";
             }
         }

src/libslic3r/Model.cpp

@@ -2,6 +2,7 @@
 #include "ModelArrange.hpp"
 #include "Geometry.hpp"
 #include "MTUtils.hpp"
+#include "TriangleSelector.hpp"
 
 #include "Format/AMF.hpp"
 #include "Format/OBJ.hpp"
@@ -1830,28 +1831,25 @@ arrangement::ArrangePolygon ModelInstance::get_arrange_polygon() const
 }
 
 
-std::vector<int> FacetsAnnotation::get_facets(FacetSupportType type) const
+indexed_triangle_set FacetsAnnotation::get_facets(const ModelVolume& mv, FacetSupportType type) const
 {
-    std::vector<int> out;
+    TriangleSelector selector(mv.mesh());
-    for (auto& [facet_idx, this_type] : m_data)
+    selector.deserialize(m_data);
-        if (this_type == type)
+    indexed_triangle_set out = selector.get_facets(type);
-            out.push_back(facet_idx);
     return out;
 }
 
 
 
-void FacetsAnnotation::set_facet(int idx, FacetSupportType type)
+bool FacetsAnnotation::set(const TriangleSelector& selector)
 {
-    bool changed = true;
+    std::map<int, std::vector<bool>> sel_map = selector.serialize();
-
+    if (sel_map != m_data) {
-    if (type == FacetSupportType::NONE)
+        m_data = sel_map;
-        changed = m_data.erase(idx) != 0;
-    else
-        m_data[idx] = type;
-
-    if (changed)
         update_timestamp();
+        return true;
+    }
+    return false;
 }
 
 
@@ -1864,6 +1862,64 @@ void FacetsAnnotation::clear()
 
 
 
+// Following function takes data from a triangle and encodes it as string
+// of hexadecimal numbers (one digit per triangle). Used for 3MF export,
+// changing it may break backwards compatibility !!!!!
+std::string FacetsAnnotation::get_triangle_as_string(int triangle_idx) const
+{
+    std::string out;
+
+    auto triangle_it = m_data.find(triangle_idx);
+    if (triangle_it != m_data.end()) {
+        const std::vector<bool>& code = triangle_it->second;
+        int offset = 0;
+        while (offset < int(code.size())) {
+            int next_code = 0;
+            for (int i=3; i>=0; --i) {
+                next_code = next_code << 1;
+                next_code |= int(code[offset + i]);
+            }
+            offset += 4;
+
+            assert(next_code >=0 && next_code <= 15);
+            char digit = next_code < 10 ? next_code + '0' : (next_code-10)+'A';
+            out.insert(out.begin(), digit);
+        }
+    }
+    return out;
+}
+
+
+
+// Recover triangle splitting & state from string of hexadecimal values previously
+// generated by get_triangle_as_string. Used to load from 3MF.
+void FacetsAnnotation::set_triangle_from_string(int triangle_id, const std::string& str)
+{
+    assert(! str.empty());
+    m_data[triangle_id] = std::vector<bool>(); // zero current state or create new
+    std::vector<bool>& code = m_data[triangle_id];
+
+    for (auto it = str.crbegin(); it != str.crend(); ++it) {
+        const char ch = *it;
+        int dec = 0;
+        if (ch >= '0' && ch<='9')
+            dec = int(ch - '0');
+        else if (ch >='A' && ch <= 'F')
+            dec = 10 + int(ch - 'A');
+        else
+            assert(false);
+
+        // Convert to binary and append into code.
+        for (int i=0; i<4; ++i) {
+            code.insert(code.end(), bool(dec & (1 << i)));
+        }
+    }
+
+
+}
+
+
+
 // Test whether the two models contain the same number of ModelObjects with the same set of IDs
 // ordered in the same order. In that case it is not necessary to kill the background processing.
 bool model_object_list_equal(const Model &model_old, const Model &model_new)
@@ -1935,7 +1991,7 @@ bool model_custom_supports_data_changed(const ModelObject& mo, const ModelObject
             return true;
     }
     return false;
-};
+}
 
 extern bool model_has_multi_part_objects(const Model &model)
 {

src/libslic3r/Model.hpp

@@ -39,6 +39,7 @@ class ModelVolume;
 class ModelWipeTower;
 class Print;
 class SLAPrint;
+class TriangleSelector;
 
 namespace UndoRedo {
 	class StackImpl;
@@ -394,6 +395,7 @@ enum class ModelVolumeType : int {
 };
 
 enum class FacetSupportType : int8_t {
+    // Maximum is 3. The value is serialized in TriangleSelector into 2 bits!
     NONE      = 0,
     ENFORCER  = 1,
     BLOCKER   = 2
@@ -403,9 +405,12 @@ class FacetsAnnotation {
 public:
     using ClockType = std::chrono::steady_clock;
 
-    std::vector<int> get_facets(FacetSupportType type) const;
+    const std::map<int, std::vector<bool>>& get_data() const { return m_data; }
-    void set_facet(int idx, FacetSupportType type);
+    bool set(const TriangleSelector& selector);
+    indexed_triangle_set get_facets(const ModelVolume& mv, FacetSupportType type) const;
     void clear();
+    std::string get_triangle_as_string(int i) const;
+    void set_triangle_from_string(int triangle_id, const std::string& str);
 
     ClockType::time_point get_timestamp() const { return timestamp; }
     bool is_same_as(const FacetsAnnotation& other) const {
@@ -418,7 +423,7 @@ public:
     }
 
 private:
-    std::map<int, FacetSupportType> m_data;
+    std::map<int, std::vector<bool>> m_data;
 
     ClockType::time_point timestamp;
     void update_timestamp() {

src/libslic3r/PrintObject.cpp

@@ -2673,14 +2673,14 @@ void PrintObject::project_and_append_custom_supports(
         FacetSupportType type, std::vector<ExPolygons>& expolys) const
 {
     for (const ModelVolume* mv : this->model_object()->volumes) {
-        const std::vector<int> custom_facets = mv->m_supported_facets.get_facets(type);
+        const indexed_triangle_set custom_facets = mv->m_supported_facets.get_facets(*mv, type);
-        if (custom_facets.empty())
+        if (custom_facets.indices.empty())
             continue;
 
-        const TriangleMesh& mesh = mv->mesh();
         const Transform3f& tr1 = mv->get_matrix().cast<float>();
         const Transform3f& tr2 = this->trafo().cast<float>();
         const Transform3f  tr  = tr2 * tr1;
+        const float tr_det_sign = (tr.matrix().determinant() > 0. ? 1.f : -1.f);
 
 
         // The projection will be at most a pentagon. Let's minimize heap
@@ -2705,11 +2705,11 @@ void PrintObject::project_and_append_custom_supports(
         };
 
         // Vector to collect resulting projections from each triangle.
-        std::vector<TriangleProjections> projections_of_triangles(custom_facets.size());
+        std::vector<TriangleProjections> projections_of_triangles(custom_facets.indices.size());
 
         // Iterate over all triangles.
         tbb::parallel_for(
-            tbb::blocked_range<size_t>(0, custom_facets.size()),
+            tbb::blocked_range<size_t>(0, custom_facets.indices.size()),
             [&](const tbb::blocked_range<size_t>& range) {
             for (size_t idx = range.begin(); idx < range.end(); ++ idx) {
 
@@ -2717,10 +2717,11 @@ void PrintObject::project_and_append_custom_supports(
 
             // Transform the triangle into worlds coords.
             for (int i=0; i<3; ++i)
-                facet[i] = tr * mesh.its.vertices[mesh.its.indices[custom_facets[idx]](i)];
+                facet[i] = tr * custom_facets.vertices[custom_facets.indices[idx](i)];
 
-            // Ignore triangles with upward-pointing normal.
+            // Ignore triangles with upward-pointing normal. Don't forget about mirroring.
-            if ((facet[1]-facet[0]).cross(facet[2]-facet[0]).z() > 0.)
+            float z_comp = (facet[1]-facet[0]).cross(facet[2]-facet[0]).z();
+            if (tr_det_sign * z_comp > 0.)
                 continue;
 
             // Sort the three vertices according to z-coordinate.

src/libslic3r/TriangleSelector.cpp

@@ -0,0 +1,689 @@
+#include "TriangleSelector.hpp"
+#include "Model.hpp"
+
+
+namespace Slic3r {
+
+
+
+// sides_to_split==-1 : just restore previous split
+void TriangleSelector::Triangle::set_division(int sides_to_split, int special_side_idx)
+{
+    assert(sides_to_split >=-1 && sides_to_split <= 3);
+    assert(special_side_idx >=-1 && special_side_idx < 3);
+
+    // If splitting one or two sides, second argument must be provided.
+    assert(sides_to_split != 1 || special_side_idx != -1);
+    assert(sides_to_split != 2 || special_side_idx != -1);
+
+    if (sides_to_split != -1) {
+        this->number_of_splits = sides_to_split;
+        if (sides_to_split != 0) {
+            assert(old_number_of_splits == 0);
+            this->special_side_idx = special_side_idx;
+            this->old_number_of_splits = sides_to_split;
+        }
+    }
+    else {
+        assert(old_number_of_splits != 0);
+        this->number_of_splits = old_number_of_splits;
+        // indices of children should still be there.
+    }
+}
+
+
+
+void TriangleSelector::select_patch(const Vec3f& hit, int facet_start,
+                                    const Vec3f& source, const Vec3f& dir,
+                                    float radius, FacetSupportType new_state)
+{
+    assert(facet_start < m_orig_size_indices);
+    assert(is_approx(dir.norm(), 1.f));
+
+    // Save current cursor center, squared radius and camera direction,
+    // so we don't have to pass it around.
+    m_cursor = {hit, source, dir, radius*radius};
+
+    // In case user changed cursor size since last time, update triangle edge limit.
+    if (m_old_cursor_radius != radius) {
+        set_edge_limit(radius / 5.f);
+        m_old_cursor_radius = radius;
+    }
+
+    // Now start with the facet the pointer points to and check all adjacent facets.
+    std::vector<int> facets_to_check{facet_start};
+    std::vector<bool> visited(m_orig_size_indices, false); // keep track of facets we already processed
+    int facet_idx = 0; // index into facets_to_check
+    while (facet_idx < int(facets_to_check.size())) {
+        int facet = facets_to_check[facet_idx];
+        if (! visited[facet]) {
+            if (select_triangle(facet, new_state)) {
+                // add neighboring facets to list to be proccessed later
+                for (int n=0; n<3; ++n) {
+                    if (faces_camera(m_mesh->stl.neighbors_start[facet].neighbor[n]))
+                        facets_to_check.push_back(m_mesh->stl.neighbors_start[facet].neighbor[n]);
+                }
+            }
+        }
+        visited[facet] = true;
+        ++facet_idx;
+    }
+}
+
+
+
+// Selects either the whole triangle (discarding any children it had), or divides
+// the triangle recursively, selecting just subtriangles truly inside the circle.
+// This is done by an actual recursive call. Returns false if the triangle is
+// outside the cursor.
+bool TriangleSelector::select_triangle(int facet_idx, FacetSupportType type, bool recursive_call)
+{
+    assert(facet_idx < int(m_triangles.size()));
+
+    Triangle* tr = &m_triangles[facet_idx];
+    if (! tr->valid)
+        return false;
+
+    int num_of_inside_vertices = vertices_inside(facet_idx);
+
+    if (num_of_inside_vertices == 0
+     && ! is_pointer_in_triangle(facet_idx)
+     && ! is_edge_inside_cursor(facet_idx))
+        return false;
+
+    if (num_of_inside_vertices == 3) {
+        // dump any subdivision and select whole triangle
+        undivide_triangle(facet_idx);
+        tr->set_state(type);
+    } else {
+        // the triangle is partially inside, let's recursively divide it
+        // (if not already) and try selecting its children.
+
+        if (! tr->is_split() && tr->get_state() == type) {
+            // This is leaf triangle that is already of correct type as a whole.
+            // No need to split, all children would end up selected anyway.
+            return true;
+        }
+
+        split_triangle(facet_idx);
+        tr = &m_triangles[facet_idx]; // might have been invalidated
+
+
+        int num_of_children = tr->number_of_split_sides() + 1;
+        if (num_of_children != 1) {
+            for (int i=0; i<num_of_children; ++i) {
+                assert(i < int(tr->children.size()));
+                assert(tr->children[i] < int(m_triangles.size()));
+
+                select_triangle(tr->children[i], type, true);
+                tr = &m_triangles[facet_idx]; // might have been invalidated
+            }
+        }
+    }
+
+    if (! recursive_call) {
+        // In case that all children are leafs and have the same state now,
+        // they may be removed and substituted by the parent triangle.
+        remove_useless_children(facet_idx);
+
+        // Make sure that we did not lose track of invalid triangles.
+        assert(m_invalid_triangles == std::count_if(m_triangles.begin(), m_triangles.end(),
+                   [](const Triangle& tr) { return ! tr.valid; }));
+
+        // Do garbage collection maybe?
+        if (2*m_invalid_triangles > int(m_triangles.size()))
+            garbage_collect();
+    }
+    return true;
+}
+
+
+
+void TriangleSelector::set_facet(int facet_idx, FacetSupportType state)
+{
+    assert(facet_idx < m_orig_size_indices);
+    undivide_triangle(facet_idx);
+    assert(! m_triangles[facet_idx].is_split());
+    m_triangles[facet_idx].set_state(state);
+}
+
+void TriangleSelector::split_triangle(int facet_idx)
+{
+    if (m_triangles[facet_idx].is_split()) {
+        // The triangle is divided already.
+        return;
+    }
+
+    Triangle* tr = &m_triangles[facet_idx];
+
+    FacetSupportType old_type = tr->get_state();
+
+    if (tr->was_split_before() != 0) {
+        // This triangle is not split at the moment, but was at one point
+        // in history. We can just restore it and resurrect its children.
+        tr->set_division(-1);
+        for (int i=0; i<=tr->number_of_split_sides(); ++i) {
+            m_triangles[tr->children[i]].set_state(old_type);
+            m_triangles[tr->children[i]].valid = true;
+            --m_invalid_triangles;
+        }
+        return;
+    }
+
+    // If we got here, we are about to actually split the triangle.
+    const double limit_squared = m_edge_limit_sqr;
+
+    std::array<int, 3>& facet = tr->verts_idxs;
+    const stl_vertex* pts[3] = { &m_vertices[facet[0]].v, &m_vertices[facet[1]].v, &m_vertices[facet[2]].v};
+    double sides[3] = { (*pts[2]-*pts[1]).squaredNorm(),
+                        (*pts[0]-*pts[2]).squaredNorm(),
+                        (*pts[1]-*pts[0]).squaredNorm() };
+
+    std::vector<int> sides_to_split;
+    int side_to_keep = -1;
+    for (int pt_idx = 0; pt_idx<3; ++pt_idx) {
+        if (sides[pt_idx] > limit_squared)
+            sides_to_split.push_back(pt_idx);
+        else
+            side_to_keep = pt_idx;
+    }
+    if (sides_to_split.empty()) {
+        // This shall be unselected.
+        tr->set_division(0);
+        return;
+    }
+
+    // Save how the triangle will be split. Second argument makes sense only for one
+    // or two split sides, otherwise the value is ignored.
+    tr->set_division(sides_to_split.size(),
+        sides_to_split.size() == 2 ? side_to_keep : sides_to_split[0]);
+
+    perform_split(facet_idx, old_type);
+}
+
+
+// Calculate distance of a point from a line.
+bool TriangleSelector::is_point_inside_cursor(const Vec3f& point) const
+{
+    Vec3f diff = m_cursor.center - point;
+    return (diff - diff.dot(m_cursor.dir) * m_cursor.dir).squaredNorm() < m_cursor.radius_sqr;
+}
+
+
+// Is pointer in a triangle?
+bool TriangleSelector::is_pointer_in_triangle(int facet_idx) const
+{
+    auto signed_volume_sign = [](const Vec3f& a, const Vec3f& b,
+                                 const Vec3f& c, const Vec3f& d) -> bool {
+        return ((b-a).cross(c-a)).dot(d-a) > 0.;
+    };
+
+    const Vec3f& p1 = m_vertices[m_triangles[facet_idx].verts_idxs[0]].v;
+    const Vec3f& p2 = m_vertices[m_triangles[facet_idx].verts_idxs[1]].v;
+    const Vec3f& p3 = m_vertices[m_triangles[facet_idx].verts_idxs[2]].v;
+    const Vec3f& q1 = m_cursor.center + m_cursor.dir;
+    const Vec3f  q2 = m_cursor.center - m_cursor.dir;
+
+    if (signed_volume_sign(q1,p1,p2,p3) != signed_volume_sign(q2,p1,p2,p3))  {
+        bool pos = signed_volume_sign(q1,q2,p1,p2);
+        if (signed_volume_sign(q1,q2,p2,p3) == pos && signed_volume_sign(q1,q2,p3,p1) == pos)
+            return true;
+    }
+    return false;
+}
+
+
+
+// Determine whether this facet is potentially visible (still can be obscured).
+bool TriangleSelector::faces_camera(int facet) const
+{
+    assert(facet < m_orig_size_indices);
+    // The normal is cached in mesh->stl, use it.
+    return (m_mesh->stl.facet_start[facet].normal.dot(m_cursor.dir) < 0.);
+}
+
+
+// How many vertices of a triangle are inside the circle?
+int TriangleSelector::vertices_inside(int facet_idx) const
+{
+    int inside = 0;
+    for (size_t i=0; i<3; ++i) {
+        if (is_point_inside_cursor(m_vertices[m_triangles[facet_idx].verts_idxs[i]].v))
+            ++inside;
+    }
+    return inside;
+}
+
+
+// Is edge inside cursor?
+bool TriangleSelector::is_edge_inside_cursor(int facet_idx) const
+{
+    Vec3f pts[3];
+    for (int i=0; i<3; ++i)
+        pts[i] = m_vertices[m_triangles[facet_idx].verts_idxs[i]].v;
+
+    const Vec3f& p = m_cursor.center;
+
+    for (int side = 0; side < 3; ++side) {
+        const Vec3f& a = pts[side];
+        const Vec3f& b = pts[side<2 ? side+1 : 0];
+        Vec3f s = (b-a).normalized();
+        float t = (p-a).dot(s);
+        Vec3f vector = a+t*s - p;
+
+        // vector is 3D vector from center to the intersection. What we want to
+        // measure is length of its projection onto plane perpendicular to dir.
+        float dist_sqr = vector.squaredNorm() - std::pow(vector.dot(m_cursor.dir), 2.f);
+        if (dist_sqr < m_cursor.radius_sqr && t>=0.f && t<=(b-a).norm())
+            return true;
+    }
+    return false;
+}
+
+
+
+// Recursively remove all subtriangles.
+void TriangleSelector::undivide_triangle(int facet_idx)
+{
+    assert(facet_idx < int(m_triangles.size()));
+    Triangle& tr = m_triangles[facet_idx];
+
+    if (tr.is_split()) {
+        for (int i=0; i<=tr.number_of_split_sides(); ++i) {
+            undivide_triangle(tr.children[i]);
+            m_triangles[tr.children[i]].valid = false;
+            ++m_invalid_triangles;
+        }
+        tr.set_division(0); // not split
+    }
+}
+
+
+void TriangleSelector::remove_useless_children(int facet_idx)
+{
+    // Check that all children are leafs of the same type. If not, try to
+    // make them (recursive call). Remove them if sucessful.
+
+    assert(facet_idx < int(m_triangles.size()) && m_triangles[facet_idx].valid);
+    Triangle& tr = m_triangles[facet_idx];
+
+    if (! tr.is_split()) {
+        // This is a leaf, there nothing to do. This can happen during the
+        // first (non-recursive call). Shouldn't otherwise.
+        return;
+    }
+
+    // Call this for all non-leaf children.
+    for (int child_idx=0; child_idx<=tr.number_of_split_sides(); ++child_idx) {
+        assert(child_idx < int(m_triangles.size()) && m_triangles[child_idx].valid);
+        if (m_triangles[tr.children[child_idx]].is_split())
+            remove_useless_children(tr.children[child_idx]);
+    }
+
+
+    // Return if a child is not leaf or two children differ in type.
+    FacetSupportType first_child_type = FacetSupportType::NONE;
+    for (int child_idx=0; child_idx<=tr.number_of_split_sides(); ++child_idx) {
+        if (m_triangles[tr.children[child_idx]].is_split())
+            return;
+        if (child_idx == 0)
+            first_child_type = m_triangles[tr.children[0]].get_state();
+        else if (m_triangles[tr.children[child_idx]].get_state() != first_child_type)
+            return;
+    }
+
+    // If we got here, the children can be removed.
+    undivide_triangle(facet_idx);
+    tr.set_state(first_child_type);
+}
+
+
+
+void TriangleSelector::garbage_collect()
+{
+    // First make a map from old to new triangle indices.
+    int new_idx = m_orig_size_indices;
+    std::vector<int> new_triangle_indices(m_triangles.size(), -1);
+    for (int i = m_orig_size_indices; i<int(m_triangles.size()); ++i) {
+        if (m_triangles[i].valid) {
+            new_triangle_indices[i] = new_idx;
+            ++new_idx;
+        } else {
+            // Decrement reference counter for the vertices.
+            for (int j=0; j<3; ++j)
+                --m_vertices[m_triangles[i].verts_idxs[j]].ref_cnt;
+        }
+    }
+
+    // Now we know which vertices are not referenced anymore. Make a map
+    // from old idxs to new ones, like we did for triangles.
+    new_idx = m_orig_size_vertices;
+    std::vector<int> new_vertices_indices(m_vertices.size(), -1);
+    for (int i=m_orig_size_vertices; i<int(m_vertices.size()); ++i) {
+        assert(m_vertices[i].ref_cnt >= 0);
+        if (m_vertices[i].ref_cnt != 0) {
+            new_vertices_indices[i] = new_idx;
+            ++new_idx;
+        }
+    }
+
+    // We can remove all invalid triangles and vertices that are no longer referenced.
+    m_triangles.erase(std::remove_if(m_triangles.begin()+m_orig_size_indices, m_triangles.end(),
+                          [](const Triangle& tr) { return ! tr.valid; }),
+                      m_triangles.end());
+    m_vertices.erase(std::remove_if(m_vertices.begin()+m_orig_size_vertices, m_vertices.end(),
+                          [](const Vertex& vert) { return vert.ref_cnt == 0; }),
+                      m_vertices.end());
+
+    // Now go through all remaining triangles and update changed indices.
+    for (Triangle& tr : m_triangles) {
+        assert(tr.valid);
+
+        if (tr.is_split()) {
+            // There are children. Update their indices.
+            for (int j=0; j<=tr.number_of_split_sides(); ++j) {
+                assert(new_triangle_indices[tr.children[j]] != -1);
+                tr.children[j] = new_triangle_indices[tr.children[j]];
+            }
+        }
+
+        // Update indices into m_vertices. The original vertices are never
+        // touched and need not be reindexed.
+        for (int& idx : tr.verts_idxs) {
+            if (idx >= m_orig_size_vertices) {
+                assert(new_vertices_indices[idx] != -1);
+                idx = new_vertices_indices[idx];
+            }
+        }
+
+        // If this triangle was split before, forget it.
+        // Children referenced in the cache are dead by now.
+        tr.forget_history();
+    }
+
+    m_invalid_triangles = 0;
+}
+
+TriangleSelector::TriangleSelector(const TriangleMesh& mesh)
+    : m_mesh{&mesh}
+{
+    reset();
+}
+
+
+void TriangleSelector::reset()
+{
+    if (! m_orig_size_indices != 0) // unless this is run from constructor
+        garbage_collect();
+    m_vertices.clear();
+    m_triangles.clear();
+    for (const stl_vertex& vert : m_mesh->its.vertices)
+        m_vertices.emplace_back(vert);
+    for (const stl_triangle_vertex_indices& ind : m_mesh->its.indices)
+        push_triangle(ind[0], ind[1], ind[2]);
+    m_orig_size_vertices = m_vertices.size();
+    m_orig_size_indices = m_triangles.size();
+    m_invalid_triangles = 0;
+}
+
+
+
+
+
+void TriangleSelector::set_edge_limit(float edge_limit)
+{
+    float new_limit_sqr = std::pow(edge_limit, 2.f);
+
+    if (new_limit_sqr != m_edge_limit_sqr) {
+        m_edge_limit_sqr = new_limit_sqr;
+
+        // The way how triangles split may be different now, forget
+        // all cached splits.
+        garbage_collect();
+    }
+}
+
+
+
+void TriangleSelector::push_triangle(int a, int b, int c)
+{
+    for (int i : {a, b, c}) {
+        assert(i >= 0 && i < int(m_vertices.size()));
+        ++m_vertices[i].ref_cnt;
+    }
+    m_triangles.emplace_back(a, b, c);
+}
+
+
+void TriangleSelector::perform_split(int facet_idx, FacetSupportType old_state)
+{
+    Triangle* tr = &m_triangles[facet_idx];
+
+    assert(tr->is_split());
+
+    // Read info about how to split this triangle.
+    int sides_to_split = tr->number_of_split_sides();
+
+    // indices of triangle vertices
+    std::vector<int> verts_idxs;
+    int idx = tr->special_side();
+    for (int j=0; j<3; ++j) {
+        verts_idxs.push_back(tr->verts_idxs[idx++]);
+        if (idx == 3)
+            idx = 0;
+    }
+
+    if (sides_to_split == 1) {
+        m_vertices.emplace_back((m_vertices[verts_idxs[1]].v + m_vertices[verts_idxs[2]].v)/2.);
+        verts_idxs.insert(verts_idxs.begin()+2, m_vertices.size() - 1);
+
+        push_triangle(verts_idxs[0], verts_idxs[1], verts_idxs[2]);
+        push_triangle(verts_idxs[2], verts_idxs[3], verts_idxs[0]);
+    }
+
+    if (sides_to_split == 2) {
+        m_vertices.emplace_back((m_vertices[verts_idxs[0]].v + m_vertices[verts_idxs[1]].v)/2.);
+        verts_idxs.insert(verts_idxs.begin()+1, m_vertices.size() - 1);
+
+        m_vertices.emplace_back((m_vertices[verts_idxs[0]].v + m_vertices[verts_idxs[3]].v)/2.);
+        verts_idxs.insert(verts_idxs.begin()+4, m_vertices.size() - 1);
+
+        push_triangle(verts_idxs[0], verts_idxs[1], verts_idxs[4]);
+        push_triangle(verts_idxs[1], verts_idxs[2], verts_idxs[4]);
+        push_triangle(verts_idxs[2], verts_idxs[3], verts_idxs[4]);
+    }
+
+    if (sides_to_split == 3) {
+        m_vertices.emplace_back((m_vertices[verts_idxs[0]].v + m_vertices[verts_idxs[1]].v)/2.);
+        verts_idxs.insert(verts_idxs.begin()+1, m_vertices.size() - 1);
+        m_vertices.emplace_back((m_vertices[verts_idxs[2]].v + m_vertices[verts_idxs[3]].v)/2.);
+        verts_idxs.insert(verts_idxs.begin()+3, m_vertices.size() - 1);
+        m_vertices.emplace_back((m_vertices[verts_idxs[4]].v + m_vertices[verts_idxs[0]].v)/2.);
+        verts_idxs.insert(verts_idxs.begin()+5, m_vertices.size() - 1);
+
+        push_triangle(verts_idxs[0], verts_idxs[1], verts_idxs[5]);
+        push_triangle(verts_idxs[1], verts_idxs[2], verts_idxs[3]);
+        push_triangle(verts_idxs[3], verts_idxs[4], verts_idxs[5]);
+        push_triangle(verts_idxs[1], verts_idxs[3], verts_idxs[5]);
+    }
+
+    tr = &m_triangles[facet_idx]; // may have been invalidated
+
+    // And save the children. All children should start in the same state as the triangle we just split.
+    assert(sides_to_split <= 3);
+    for (int i=0; i<=sides_to_split; ++i) {
+        tr->children[i] = m_triangles.size()-1-i;
+        m_triangles[tr->children[i]].set_state(old_state);
+    }
+}
+
+
+
+indexed_triangle_set TriangleSelector::get_facets(FacetSupportType state) const
+{
+    indexed_triangle_set out;
+    for (const Triangle& tr : m_triangles) {
+        if (tr.valid && ! tr.is_split() && tr.get_state() == state) {
+            stl_triangle_vertex_indices indices;
+            for (int i=0; i<3; ++i) {
+                out.vertices.emplace_back(m_vertices[tr.verts_idxs[i]].v);
+                indices[i] = out.vertices.size() - 1;
+            }
+            out.indices.emplace_back(indices);
+        }
+    }
+    return out;
+}
+
+
+
+std::map<int, std::vector<bool>> TriangleSelector::serialize() const
+{
+    // Each original triangle of the mesh is assigned a number encoding its state
+    // or how it is split. Each triangle is encoded by 4 bits (xxyy):
+    // leaf triangle: xx = FacetSupportType, yy = 0
+    // non-leaf:      xx = special side, yy = number of split sides
+    // These are bitwise appended and formed into one 64-bit integer.
+
+    // The function returns a map from original triangle indices to
+    // stream of bits encoding state and offsprings.
+
+    std::map<int, std::vector<bool>> out;
+    for (int i=0; i<m_orig_size_indices; ++i) {
+        const Triangle& tr = m_triangles[i];
+
+        if (! tr.is_split() && tr.get_state() == FacetSupportType::NONE)
+            continue; // no need to save anything, unsplit and unselected is default
+
+        std::vector<bool> data; // complete encoding of this mesh triangle
+        int stored_triangles = 0; // how many have been already encoded
+
+        std::function<void(int)> serialize_recursive;
+        serialize_recursive = [this, &serialize_recursive, &stored_triangles, &data](int facet_idx) {
+            const Triangle& tr = m_triangles[facet_idx];
+
+            // Always save number of split sides. It is zero for unsplit triangles.
+            int split_sides = tr.number_of_split_sides();
+            assert(split_sides >= 0 && split_sides <= 3);
+
+            //data |= (split_sides << (stored_triangles * 4));
+            data.push_back(split_sides & 0b01);
+            data.push_back(split_sides & 0b10);
+
+            if (tr.is_split()) {
+                // If this triangle is split, save which side is split (in case
+                // of one split) or kept (in case of two splits). The value will
+                // be ignored for 3-side split.
+                assert(split_sides > 0);
+                assert(tr.special_side() >= 0 && tr.special_side() <= 3);
+                data.push_back(tr.special_side() & 0b01);
+                data.push_back(tr.special_side() & 0b10);
+                ++stored_triangles;
+                // Now save all children.
+                for (int child_idx=0; child_idx<=split_sides; ++child_idx)
+                    serialize_recursive(tr.children[child_idx]);
+            } else {
+                // In case this is leaf, we better save information about its state.
+                assert(int(tr.get_state()) <= 3);
+                data.push_back(int(tr.get_state()) & 0b01);
+                data.push_back(int(tr.get_state()) & 0b10);
+                ++stored_triangles;
+            }
+        };
+
+        serialize_recursive(i);
+        out[i] = data;
+    }
+
+    return out;
+}
+
+void TriangleSelector::deserialize(const std::map<int, std::vector<bool>> data)
+{
+    reset(); // dump any current state
+    for (const auto& [triangle_id, code] : data) {
+        assert(triangle_id < int(m_triangles.size()));
+        assert(! code.empty());
+        int processed_triangles = 0;
+        struct ProcessingInfo {
+            int facet_id = 0;
+            int processed_children = 0;
+            int total_children = 0;
+        };
+
+        // Vector to store all parents that have offsprings.
+        std::vector<ProcessingInfo> parents;
+
+        while (true) {
+            // Read next triangle info.
+            int next_code = 0;
+            for (int i=3; i>=0; --i) {
+                next_code = next_code << 1;
+                next_code |= int(code[4 * processed_triangles + i]);
+            }
+            ++processed_triangles;
+
+            int num_of_split_sides = (next_code & 0b11);
+            int num_of_children = num_of_split_sides != 0 ? num_of_split_sides + 1 : 0;
+            bool is_split = num_of_children != 0;
+            FacetSupportType state = FacetSupportType(next_code >> 2);
+            int special_side = (next_code >> 2);
+
+            // Take care of the first iteration separately, so handling of the others is simpler.
+            if (parents.empty()) {
+                if (! is_split) {
+                    // root is not split. just set the state and that's it.
+                    m_triangles[triangle_id].set_state(state);
+                    break;
+                } else {
+                    // root is split, add it into list of parents and split it.
+                    // then go to the next.
+                    parents.push_back({triangle_id, 0, num_of_children});
+                    m_triangles[triangle_id].set_division(num_of_children-1, special_side);
+                    perform_split(triangle_id, FacetSupportType::NONE);
+                    continue;
+                }
+            }
+
+            // This is not the first iteration. This triangle is a child of last seen parent.
+            assert(! parents.empty());
+            assert(parents.back().processed_children < parents.back().total_children);
+
+            if (is_split) {
+                // split the triangle and save it as parent of the next ones.
+                const ProcessingInfo& last = parents.back();
+                int this_idx = m_triangles[last.facet_id].children[last.processed_children];
+                m_triangles[this_idx].set_division(num_of_children-1, special_side);
+                perform_split(this_idx, FacetSupportType::NONE);
+                parents.push_back({this_idx, 0, num_of_children});
+            } else {
+                // this triangle belongs to last split one
+                m_triangles[m_triangles[parents.back().facet_id].children[parents.back().processed_children]].set_state(state);
+                ++parents.back().processed_children;
+            }
+
+
+            // If all children of the past parent triangle are claimed, move to grandparent.
+            while (parents.back().processed_children == parents.back().total_children) {
+                parents.pop_back();
+
+                if (parents.empty())
+                    break;
+
+                // And increment the grandparent children counter, because
+                // we have just finished that branch and got back here.
+                ++parents.back().processed_children;
+            }
+
+            // In case we popped back the root, we should be done.
+            if (parents.empty())
+                break;
+        }
+
+    }
+}
+
+
+
+
+} // namespace Slic3r

src/libslic3r/TriangleSelector.hpp

@@ -0,0 +1,155 @@
+#ifndef libslic3r_TriangleSelector_hpp_
+#define libslic3r_TriangleSelector_hpp_
+
+// #define PRUSASLICER_TRIANGLE_SELECTOR_DEBUG
+
+
+#include "Point.hpp"
+#include "TriangleMesh.hpp"
+
+namespace Slic3r {
+
+enum class FacetSupportType : int8_t;
+
+
+
+// Following class holds information about selected triangles. It also has power
+// to recursively subdivide the triangles and make the selection finer.
+class TriangleSelector {
+public:
+    void set_edge_limit(float edge_limit);
+
+    // Create new object on a TriangleMesh. The referenced mesh must
+    // stay valid, a ptr to it is saved and used.
+    explicit TriangleSelector(const TriangleMesh& mesh);
+
+    // Select all triangles fully inside the circle, subdivide where needed.
+    void select_patch(const Vec3f& hit,    // point where to start
+                      int facet_start,     // facet that point belongs to
+                      const Vec3f& source, // camera position (mesh coords)
+                      const Vec3f& dir,    // direction of the ray (mesh coords)
+                      float radius,        // radius of the cursor
+                      FacetSupportType new_state);   // enforcer or blocker?
+
+    // Get facets currently in the given state.
+    indexed_triangle_set get_facets(FacetSupportType state) const;
+
+    // Set facet of the mesh to a given state. Only works for original triangles.
+    void set_facet(int facet_idx, FacetSupportType state);
+
+    // Clear everything and make the tree empty.
+    void reset();
+
+    // Remove all unnecessary data.
+    void garbage_collect();
+
+    // Store the division trees in compact form (a long stream of
+    // bits for each triangle of the original mesh).
+    std::map<int, std::vector<bool>> serialize() const;
+
+    // Load serialized data. Assumes that correct mesh is loaded.
+    void deserialize(const std::map<int, std::vector<bool>> data);
+
+
+protected:
+    // Triangle and info about how it's split.
+    class Triangle {
+    public:
+        // Use TriangleSelector::push_triangle to create a new triangle.
+        // It increments/decrements reference counter on vertices.
+        Triangle(int a, int b, int c)
+            : verts_idxs{a, b, c},
+              state{FacetSupportType(0)},
+              number_of_splits{0},
+              special_side_idx{0},
+              old_number_of_splits{0}
+        {}
+        // Indices into m_vertices.
+        std::array<int, 3> verts_idxs;
+
+        // Is this triangle valid or marked to be removed?
+        bool valid{true};
+
+        // Children triangles.
+        std::array<int, 4> children;
+
+        // Set the division type.
+        void set_division(int sides_to_split, int special_side_idx = -1);
+
+        // Get/set current state.
+        void set_state(FacetSupportType type) { assert(! is_split()); state = type; }
+        FacetSupportType get_state() const { assert(! is_split()); return state; }
+
+        // Get info on how it's split.
+        bool is_split() const { return number_of_split_sides() != 0; }
+        int number_of_split_sides() const { return number_of_splits; }
+        int special_side() const  { assert(is_split()); return special_side_idx; }
+        bool was_split_before() const { return old_number_of_splits != 0; }
+        void forget_history() { old_number_of_splits = 0; }
+
+    private:
+        int number_of_splits;
+        int special_side_idx;
+        FacetSupportType state;
+
+        // How many children were spawned during last split?
+        // Is not reset on remerging the triangle.
+        int old_number_of_splits;
+    };
+
+    struct Vertex {
+        explicit Vertex(const stl_vertex& vert)
+            : v{vert},
+              ref_cnt{0}
+        {}
+        stl_vertex v;
+        int ref_cnt;
+    };
+
+    // Lists of vertices and triangles, both original and new
+    std::vector<Vertex> m_vertices;
+    std::vector<Triangle> m_triangles;
+    const TriangleMesh* m_mesh;
+
+    // Number of invalid triangles (to trigger garbage collection).
+    int m_invalid_triangles;
+
+    // Limiting length of triangle side (squared).
+    float m_edge_limit_sqr = 1.f;
+
+    // Number of original vertices and triangles.
+    int m_orig_size_vertices = 0;
+    int m_orig_size_indices = 0;
+
+    // Cache for cursor position, radius and direction.
+    struct Cursor {
+        Vec3f center;
+        Vec3f source;
+        Vec3f dir;
+        float radius_sqr;
+    };
+
+    Cursor m_cursor;
+    float m_old_cursor_radius;
+
+    // Private functions:
+    bool select_triangle(int facet_idx, FacetSupportType type,
+                         bool recursive_call = false);
+    bool is_point_inside_cursor(const Vec3f& point) const;
+    int  vertices_inside(int facet_idx) const;
+    bool faces_camera(int facet) const;
+    void undivide_triangle(int facet_idx);
+    void split_triangle(int facet_idx);
+    void remove_useless_children(int facet_idx); // No hidden meaning. Triangles are meant.
+    bool is_pointer_in_triangle(int facet_idx) const;
+    bool is_edge_inside_cursor(int facet_idx) const;
+    void push_triangle(int a, int b, int c);
+    void perform_split(int facet_idx, FacetSupportType old_state);
+};
+
+
+
+
+} // namespace Slic3r
+
+#endif // libslic3r_TriangleSelector_hpp_

src/slic3r/GUI/Gizmos/GLGizmoFdmSupports.cpp

@@ -16,7 +16,6 @@
 namespace Slic3r {
 namespace GUI {
 
-static constexpr size_t MaxVertexBuffers = 50;
 
 GLGizmoFdmSupports::GLGizmoFdmSupports(GLCanvas3D& parent, const std::string& icon_filename, unsigned int sprite_id)
     : GLGizmoBase(parent, icon_filename, sprite_id)
@@ -49,7 +48,7 @@ bool GLGizmoFdmSupports::on_init()
     m_desc["block"]            = _L("Block supports");
     m_desc["remove_caption"]   = _L("Shift + Left mouse button") + ": ";
     m_desc["remove"]           = _L("Remove selection");
-    m_desc["remove_all"]       = _L("Remove all");
+    m_desc["remove_all"]       = _L("Remove all selection");
 
     return true;
 }
@@ -96,6 +95,7 @@ void GLGizmoFdmSupports::on_render() const
     glsafe(::glEnable(GL_DEPTH_TEST));
 
     render_triangles(selection);
+
     m_c->object_clipper()->render_cut();
     render_cursor_circle();
 
@@ -145,14 +145,9 @@ void GLGizmoFdmSupports::render_triangles(const Selection& selection) const
         glsafe(::glPushMatrix());
         glsafe(::glMultMatrixd(trafo_matrix.data()));
 
-        // Now render both enforcers and blockers.
+        if (! m_setting_angle)
-        for (int i=0; i<2; ++i) {
+            m_triangle_selectors[mesh_id]->render(m_imgui);
-            glsafe(::glColor4f(i ? 1.f : 0.2f, 0.2f, i ? 0.2f : 1.0f, 0.5f));
+
-            for (const GLIndexedVertexArray& iva : m_ivas[mesh_id][i]) {
-                if (iva.has_VBOs())
-                    iva.render();
-            }
-        }
         glsafe(::glPopMatrix());
         if (is_left_handed)
             glsafe(::glFrontFace(GL_CCW));
@@ -209,15 +204,18 @@ void GLGizmoFdmSupports::render_cursor_circle() const
 
 void GLGizmoFdmSupports::update_model_object() const
 {
+    bool updated = false;
     ModelObject* mo = m_c->selection_info()->model_object();
     int idx = -1;
     for (ModelVolume* mv : mo->volumes) {
-        ++idx;
         if (! mv->is_model_part())
             continue;
-        for (int i=0; i<int(m_selected_facets[idx].size()); ++i)
+        ++idx;
-            mv->m_supported_facets.set_facet(i, m_selected_facets[idx][i]);
+        updated |= mv->m_supported_facets.set(*m_triangle_selectors[idx].get());
     }
+
+    if (updated)
+        m_parent.post_event(SimpleEvent(EVT_GLCANVAS_SCHEDULE_BACKGROUND_PROCESS));
 }
 
 
@@ -226,19 +224,7 @@ void GLGizmoFdmSupports::update_from_model_object()
     wxBusyCursor wait;
 
     const ModelObject* mo = m_c->selection_info()->model_object();
-    size_t num_of_volumes = 0;
+    m_triangle_selectors.clear();
-    for (const ModelVolume* mv : mo->volumes)
-        if (mv->is_model_part())
-            ++num_of_volumes;
-    m_selected_facets.resize(num_of_volumes);
-
-    m_ivas.clear();
-    m_ivas.resize(num_of_volumes);
-    for (size_t i=0; i<num_of_volumes; ++i) {
-        m_ivas[i][0].reserve(MaxVertexBuffers);
-        m_ivas[i][1].reserve(MaxVertexBuffers);
-    }
-
 
     int volume_id = -1;
     for (const ModelVolume* mv : mo->volumes) {
@@ -250,16 +236,8 @@ void GLGizmoFdmSupports::update_from_model_object()
         // This mesh does not account for the possible Z up SLA offset.
         const TriangleMesh* mesh = &mv->mesh();
 
-        m_selected_facets[volume_id].assign(mesh->its.indices.size(), FacetSupportType::NONE);
+        m_triangle_selectors.emplace_back(std::make_unique<TriangleSelectorGUI>(*mesh));
-
+        m_triangle_selectors.back()->deserialize(mv->m_supported_facets.get_data());
-        // Load current state from ModelVolume.
-        for (FacetSupportType type : {FacetSupportType::ENFORCER, FacetSupportType::BLOCKER}) {
-            const std::vector<int>& list = mv->m_supported_facets.get_facets(type);
-            for (int i : list)
-                m_selected_facets[volume_id][i] = type;
-        }
-        update_vertex_buffers(mesh, volume_id, FacetSupportType::ENFORCER);
-        update_vertex_buffers(mesh, volume_id, FacetSupportType::BLOCKER);
     }
 }
 
@@ -315,6 +293,9 @@ bool GLGizmoFdmSupports::gizmo_event(SLAGizmoEventType action, const Vec2d& mous
      || action == SLAGizmoEventType::RightDown
     || (action == SLAGizmoEventType::Dragging && m_button_down != Button::None)) {
 
+        if (m_triangle_selectors.empty())
+            return false;
+
         FacetSupportType new_state = FacetSupportType::NONE;
         if (! shift_down) {
             if (action == SLAGizmoEventType::Dragging)
@@ -403,103 +384,35 @@ bool GLGizmoFdmSupports::gizmo_event(SLAGizmoEventType action, const Vec2d& mous
                 || dragging_while_painting;
         }
 
-        // Now propagate the hits
+        // Find respective mesh id.
+        // FIXME We need a separate TriangleSelector for each volume mesh.
         mesh_id = -1;
-        const TriangleMesh* mesh = nullptr;
+        //const TriangleMesh* mesh = nullptr;
         for (const ModelVolume* mv : mo->volumes) {
             if (! mv->is_model_part())
                 continue;
             ++mesh_id;
             if (mesh_id == closest_hit_mesh_id) {
-                mesh = &mv->mesh();
+                //mesh = &mv->mesh();
                 break;
             }
         }
 
-        bool update_both = false;
-
         const Transform3d& trafo_matrix = trafo_matrices[mesh_id];
 
         // Calculate how far can a point be from the line (in mesh coords).
         // FIXME: The scaling of the mesh can be non-uniform.
         const Vec3d sf = Geometry::Transformation(trafo_matrix).get_scaling_factor();
         const float avg_scaling = (sf(0) + sf(1) + sf(2))/3.;
-        const float limit = pow(m_cursor_radius/avg_scaling , 2.f);
+        const float limit = m_cursor_radius/avg_scaling;
-
-        const std::pair<Vec3f, size_t>& hit_and_facet = { closest_hit, closest_facet };
 
         // Calculate direction from camera to the hit (in mesh coords):
-        Vec3f dir = ((trafo_matrix.inverse() * camera.get_position()).cast<float>() - hit_and_facet.first).normalized();
+        Vec3f camera_pos = (trafo_matrix.inverse() * camera.get_position()).cast<float>();
+        Vec3f dir = (closest_hit - camera_pos).normalized();
 
-        // A lambda to calculate distance from the centerline:
+        assert(mesh_id < int(m_triangle_selectors.size()));
-        auto squared_distance_from_line = [&hit_and_facet, &dir](const Vec3f& point) -> float {
+        m_triangle_selectors[mesh_id]->select_patch(closest_hit, closest_facet, camera_pos,
-            Vec3f diff = hit_and_facet.first - point;
+                                          dir, limit, new_state);
-            return (diff - diff.dot(dir) * dir).squaredNorm();
-        };
-
-        // A lambda to determine whether this facet is potentionally visible (still can be obscured)
-        auto faces_camera = [&dir, &mesh](const size_t& facet) -> bool {
-            return (mesh->stl.facet_start[facet].normal.dot(dir) > 0.);
-        };
-        // Now start with the facet the pointer points to and check all adjacent facets.
-        std::vector<size_t> facets_to_select{hit_and_facet.second};
-        std::vector<bool> visited(m_selected_facets[mesh_id].size(), false); // keep track of facets we already processed
-        size_t facet_idx = 0; // index into facets_to_select
-        while (facet_idx < facets_to_select.size()) {
-            size_t facet = facets_to_select[facet_idx];
-            if (! visited[facet]) {
-                // check all three vertices and in case they're close enough,
-                // add neighboring facets to be proccessed later
-                for (size_t i=0; i<3; ++i) {
-                    float dist = squared_distance_from_line(
-                                mesh->its.vertices[mesh->its.indices[facet](i)]);
-                    if (dist < limit) {
-                        for (int n=0; n<3; ++n) {
-                            if (faces_camera(mesh->stl.neighbors_start[facet].neighbor[n]))
-                                facets_to_select.push_back(mesh->stl.neighbors_start[facet].neighbor[n]);
-                        }
-                    }
-                }
-                visited[facet] = true;
-            }
-            ++facet_idx;
-        }
-
-        std::vector<size_t> new_facets;
-        new_facets.reserve(facets_to_select.size());
-
-        // Now just select all facets that passed and remember which
-        // ones have really changed state.
-        for (size_t next_facet : facets_to_select) {
-            FacetSupportType& facet = m_selected_facets[mesh_id][next_facet];
-
-            if (facet != new_state) {
-                if (facet != FacetSupportType::NONE) {
-                    // this triangle is currently in the other VBA.
-                    // Both VBAs need to be refreshed.
-                    update_both = true;
-                }
-                facet = new_state;
-                new_facets.push_back(next_facet);
-            }
-        }
-
-        if (! new_facets.empty()) {
-            if (new_state != FacetSupportType::NONE) {
-                // append triangles into the respective VBA
-                update_vertex_buffers(mesh, mesh_id, new_state, &new_facets);
-                if (update_both) {
-                    auto other = new_state == FacetSupportType::ENFORCER
-                            ? FacetSupportType::BLOCKER
-                            : FacetSupportType::ENFORCER;
-                    update_vertex_buffers(mesh, mesh_id, other); // regenerate the other VBA
-                }
-            }
-            else {
-                update_vertex_buffers(mesh, mesh_id, FacetSupportType::ENFORCER);
-                update_vertex_buffers(mesh, mesh_id, FacetSupportType::BLOCKER);
-            }
-        }
 
         return true;
     }
@@ -524,58 +437,8 @@ bool GLGizmoFdmSupports::gizmo_event(SLAGizmoEventType action, const Vec2d& mous
 }
 
 
-void GLGizmoFdmSupports::update_vertex_buffers(const TriangleMesh* mesh,
-                                               int mesh_id,
-                                               FacetSupportType type,
-                                               const std::vector<size_t>* new_facets)
-{
-    std::vector<GLIndexedVertexArray>& ivas = m_ivas[mesh_id][type == FacetSupportType::ENFORCER ? 0 : 1];
 
-    // lambda to push facet into vertex buffer
+void GLGizmoFdmSupports::select_facets_by_angle(float threshold_deg, bool block)
-    auto push_facet = [this, &mesh, &mesh_id](size_t idx, GLIndexedVertexArray& iva) {
-        for (int i=0; i<3; ++i)
-            iva.push_geometry(
-                mesh->its.vertices[mesh->its.indices[idx](i)].cast<double>(),
-                m_c->raycaster()->raycasters()[mesh_id]->get_triangle_normal(idx).cast<double>()
-            );
-        size_t num = iva.triangle_indices_size;
-        iva.push_triangle(num, num+1, num+2);
-    };
-
-
-    if (ivas.size() == MaxVertexBuffers || ! new_facets) {
-        // If there are too many or they should be regenerated, make one large
-        // GLVertexBufferArray.
-        ivas.clear(); // destructors release geometry
-        ivas.push_back(GLIndexedVertexArray());
-
-        bool pushed = false;
-        for (size_t facet_idx=0; facet_idx<m_selected_facets[mesh_id].size(); ++facet_idx) {
-            if (m_selected_facets[mesh_id][facet_idx] == type) {
-                push_facet(facet_idx, ivas.back());
-                pushed = true;
-            }
-        }
-        if (pushed)
-            ivas.back().finalize_geometry(true);
-        else
-            ivas.pop_back();
-    } else {
-        // we are only appending - let's make new vertex array and let the old ones live
-        ivas.push_back(GLIndexedVertexArray());
-        for (size_t facet_idx : *new_facets)
-            push_facet(facet_idx, ivas.back());
-
-        if (! new_facets->empty())
-            ivas.back().finalize_geometry(true);
-        else
-            ivas.pop_back();
-    }
-
-}
-
-
-void GLGizmoFdmSupports::select_facets_by_angle(float threshold_deg, bool overwrite, bool block)
 {
     float threshold = (M_PI/180.)*threshold_deg;
     const Selection& selection = m_parent.get_selection();
@@ -599,13 +462,12 @@ void GLGizmoFdmSupports::select_facets_by_angle(float threshold_deg, bool overwr
         int idx = -1;
         for (const stl_facet& facet : mv->mesh().stl.facet_start) {
             ++idx;
-            if (facet.normal.dot(down) > dot_limit && (overwrite || m_selected_facets[mesh_id][idx] == FacetSupportType::NONE))
+            if (facet.normal.dot(down) > dot_limit)
-                m_selected_facets[mesh_id][idx] = block
+                m_triangle_selectors[mesh_id]->set_facet(idx,
+                                                         block
                                                          ? FacetSupportType::BLOCKER
-                        : FacetSupportType::ENFORCER;
+                                                         : FacetSupportType::ENFORCER);
         }
-        update_vertex_buffers(&mv->mesh(), mesh_id, FacetSupportType::ENFORCER);
-        update_vertex_buffers(&mv->mesh(), mesh_id, FacetSupportType::BLOCKER);
     }
 
     activate_internal_undo_redo_stack(true);
@@ -670,19 +532,18 @@ void GLGizmoFdmSupports::on_render_input_window(float x, float y, float bottom_l
         ImGui::SameLine();
 
         if (m_imgui->button(m_desc.at("remove_all"))) {
+            Plater::TakeSnapshot(wxGetApp().plater(), wxString(_L("Reset selection")));
             ModelObject* mo = m_c->selection_info()->model_object();
             int idx = -1;
             for (ModelVolume* mv : mo->volumes) {
-                ++idx;
                 if (mv->is_model_part()) {
-                    m_selected_facets[idx].assign(m_selected_facets[idx].size(), FacetSupportType::NONE);
+                    ++idx;
-                    mv->m_supported_facets.clear();
+                    m_triangle_selectors[idx]->reset();
-                    update_vertex_buffers(&mv->mesh(), idx, FacetSupportType::ENFORCER);
+                }
-                    update_vertex_buffers(&mv->mesh(), idx, FacetSupportType::BLOCKER);
+            }
+            update_model_object();
             m_parent.set_as_dirty();
         }
-            }
-        }
 
         const float max_tooltip_width = ImGui::GetFontSize() * 20.0f;
 
@@ -737,12 +598,11 @@ void GLGizmoFdmSupports::on_render_input_window(float x, float y, float bottom_l
         ImGui::SameLine();
         if (m_imgui->slider_float("", &m_angle_threshold_deg, 0.f, 90.f, "%.f"))
             m_parent.set_slope_range({90.f - m_angle_threshold_deg, 90.f - m_angle_threshold_deg});
-        m_imgui->checkbox(wxString("Overwrite already selected facets"), m_overwrite_selected);
         if (m_imgui->button("Enforce"))
-            select_facets_by_angle(m_angle_threshold_deg, m_overwrite_selected, false);
+            select_facets_by_angle(m_angle_threshold_deg, false);
         ImGui::SameLine();
         if (m_imgui->button("Block"))
-            select_facets_by_angle(m_angle_threshold_deg, m_overwrite_selected, true);
+            select_facets_by_angle(m_angle_threshold_deg, true);
         ImGui::SameLine();
         if (m_imgui->button("Cancel"))
             m_setting_angle = false;
@@ -788,9 +648,7 @@ CommonGizmosDataID GLGizmoFdmSupports::on_get_requirements() const
                 int(CommonGizmosDataID::SelectionInfo)
               | int(CommonGizmosDataID::InstancesHider)
               | int(CommonGizmosDataID::Raycaster)
-              | int(CommonGizmosDataID::HollowedMesh)
+              | int(CommonGizmosDataID::ObjectClipper));
-              | int(CommonGizmosDataID::ObjectClipper)
-              | int(CommonGizmosDataID::SupportsClipper));
 }
 
 
@@ -814,8 +672,8 @@ void GLGizmoFdmSupports::on_set_state()
         }
         activate_internal_undo_redo_stack(false);
         m_old_mo_id = -1;
-        m_ivas.clear();
+        //m_iva.release_geometry();
-        m_selected_facets.clear();
+        m_triangle_selectors.clear();
     }
     m_old_state = m_state;
 }
@@ -853,6 +711,151 @@ void GLGizmoFdmSupports::on_save(cereal::BinaryOutputArchive&) const
 }
 
 
+void TriangleSelectorGUI::render(ImGuiWrapper* imgui)
+{
+    int enf_cnt = 0;
+    int blc_cnt = 0;
+
+    m_iva_enforcers.release_geometry();
+    m_iva_blockers.release_geometry();
+
+    for (const Triangle& tr : m_triangles) {
+        if (! tr.valid || tr.is_split() || tr.get_state() == FacetSupportType::NONE)
+            continue;
+
+        GLIndexedVertexArray& va = tr.get_state() == FacetSupportType::ENFORCER
+                                   ? m_iva_enforcers
+                                   : m_iva_blockers;
+        int& cnt = tr.get_state() == FacetSupportType::ENFORCER
+                ? enf_cnt
+                : blc_cnt;
+
+        for (int i=0; i<3; ++i)
+            va.push_geometry(double(m_vertices[tr.verts_idxs[i]].v[0]),
+                             double(m_vertices[tr.verts_idxs[i]].v[1]),
+                             double(m_vertices[tr.verts_idxs[i]].v[2]),
+                             0., 0., 1.);
+        va.push_triangle(cnt,
+                         cnt+1,
+                         cnt+2);
+        cnt += 3;
+    }
+
+    m_iva_enforcers.finalize_geometry(true);
+    m_iva_blockers.finalize_geometry(true);
+
+    if (m_iva_enforcers.has_VBOs()) {
+        ::glColor4f(0.f, 0.f, 1.f, 0.2f);
+        m_iva_enforcers.render();
+    }
+
+
+    if (m_iva_blockers.has_VBOs()) {
+        ::glColor4f(1.f, 0.f, 0.f, 0.2f);
+        m_iva_blockers.render();
+    }
+
+
+#ifdef PRUSASLICER_TRIANGLE_SELECTOR_DEBUG
+    if (imgui)
+        render_debug(imgui);
+    else
+        assert(false); // If you want debug output, pass ptr to ImGuiWrapper.
+#endif
+}
+
+
+
+#ifdef PRUSASLICER_TRIANGLE_SELECTOR_DEBUG
+void TriangleSelectorGUI::render_debug(ImGuiWrapper* imgui)
+{
+    imgui->begin(std::string("TriangleSelector dialog (DEV ONLY)"),
+                 ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoCollapse);
+    static float edge_limit = 1.f;
+    imgui->text("Edge limit (mm): ");
+    imgui->slider_float("", &edge_limit, 0.1f, 8.f);
+    set_edge_limit(edge_limit);
+    imgui->checkbox("Show split triangles: ", m_show_triangles);
+    imgui->checkbox("Show invalid triangles: ", m_show_invalid);
+
+    int valid_triangles = m_triangles.size() - m_invalid_triangles;
+    imgui->text("Valid triangles: " + std::to_string(valid_triangles) +
+                  "/" + std::to_string(m_triangles.size()));
+    imgui->text("Vertices: " + std::to_string(m_vertices.size()));
+    if (imgui->button("Force garbage collection"))
+        garbage_collect();
+
+    if (imgui->button("Serialize - deserialize")) {
+        auto map = serialize();
+        deserialize(map);
+    }
+
+    imgui->end();
+
+    if (! m_show_triangles)
+        return;
+
+    enum vtype {
+        ORIGINAL = 0,
+        SPLIT,
+        INVALID
+    };
+
+    for (auto& va : m_varrays)
+        va.release_geometry();
+
+    std::array<int, 3> cnts;
+
+    ::glScalef(1.01f, 1.01f, 1.01f);
+
+    for (int tr_id=0; tr_id<int(m_triangles.size()); ++tr_id) {
+        const Triangle& tr = m_triangles[tr_id];
+        GLIndexedVertexArray* va = nullptr;
+        int* cnt = nullptr;
+        if (tr_id < m_orig_size_indices) {
+            va = &m_varrays[ORIGINAL];
+            cnt = &cnts[ORIGINAL];
+        }
+        else if (tr.valid) {
+            va = &m_varrays[SPLIT];
+            cnt = &cnts[SPLIT];
+        }
+        else {
+            if (! m_show_invalid)
+                continue;
+            va = &m_varrays[INVALID];
+            cnt = &cnts[INVALID];
+        }
+
+        for (int i=0; i<3; ++i)
+            va->push_geometry(double(m_vertices[tr.verts_idxs[i]].v[0]),
+                              double(m_vertices[tr.verts_idxs[i]].v[1]),
+                              double(m_vertices[tr.verts_idxs[i]].v[2]),
+                              0., 0., 1.);
+        va->push_triangle(*cnt,
+                          *cnt+1,
+                          *cnt+2);
+        *cnt += 3;
+    }
+
+    ::glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
+    for (vtype i : {ORIGINAL, SPLIT, INVALID}) {
+        GLIndexedVertexArray& va = m_varrays[i];
+        va.finalize_geometry(true);
+        if (va.has_VBOs()) {
+            switch (i) {
+            case ORIGINAL : ::glColor3f(0.f, 0.f, 1.f); break;
+            case SPLIT    : ::glColor3f(1.f, 0.f, 0.f); break;
+            case INVALID  : ::glColor3f(1.f, 1.f, 0.f); break;
+            }
+            va.render();
+        }
+    }
+    ::glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
+}
+#endif
+
+
 
 } // namespace GUI
 } // namespace Slic3r

src/slic3r/GUI/Gizmos/GLGizmoFdmSupports.hpp

@@ -6,10 +6,13 @@
 #include "slic3r/GUI/3DScene.hpp"
 
 #include "libslic3r/ObjectID.hpp"
+#include "libslic3r/TriangleSelector.hpp"
 
 #include <cereal/types/vector.hpp>
 
 
+
+
 namespace Slic3r {
 
 enum class FacetSupportType : int8_t;
@@ -19,6 +22,31 @@ namespace GUI {
 enum class SLAGizmoEventType : unsigned char;
 class ClippingPlane;
 
+
+
+class TriangleSelectorGUI : public TriangleSelector {
+public:
+    explicit TriangleSelectorGUI(const TriangleMesh& mesh)
+        : TriangleSelector(mesh) {}
+
+    // Render current selection. Transformation matrices are supposed
+    // to be already set.
+    void render(ImGuiWrapper* imgui = nullptr);
+
+#ifdef PRUSASLICER_TRIANGLE_SELECTOR_DEBUG
+    void render_debug(ImGuiWrapper* imgui);
+    bool m_show_triangles{false};
+    bool m_show_invalid{false};
+#endif
+
+private:
+    GLIndexedVertexArray m_iva_enforcers;
+    GLIndexedVertexArray m_iva_blockers;
+    std::array<GLIndexedVertexArray, 3> m_varrays;
+};
+
+
+
 class GLGizmoFdmSupports : public GLGizmoBase
 {
 private:
@@ -28,24 +56,12 @@ private:
     GLUquadricObj* m_quadric;
 
     float m_cursor_radius = 2.f;
-    static constexpr float CursorRadiusMin  = 0.f;
+    static constexpr float CursorRadiusMin  = 0.4f; // cannot be zero
     static constexpr float CursorRadiusMax  = 8.f;
     static constexpr float CursorRadiusStep = 0.2f;
 
-    // For each model-part volume, store a list of statuses of
+    // For each model-part volume, store status and division of the triangles.
-    // individual facets (one of the enum values above).
+    std::vector<std::unique_ptr<TriangleSelectorGUI>> m_triangle_selectors;
-    std::vector<std::vector<FacetSupportType>> m_selected_facets;
-
-    // Vertex buffer arrays for each model-part volume. There is a vector of
-    // arrays so that adding triangles can be done without regenerating all
-    // other triangles. Enforcers and blockers are of course separate.
-    std::vector<std::array<std::vector<GLIndexedVertexArray>, 2>> m_ivas;
-
-    void update_vertex_buffers(const TriangleMesh* mesh,
-                               int mesh_id,
-                               FacetSupportType type, // enforcers / blockers
-                               const std::vector<size_t>* new_facets = nullptr); // nullptr -> regenerate all
-
 
 public:
     GLGizmoFdmSupports(GLCanvas3D& parent, const std::string& icon_filename, unsigned int sprite_id);
@@ -66,8 +82,7 @@ private:
     void update_from_model_object();
     void activate_internal_undo_redo_stack(bool activate);
 
-    void select_facets_by_angle(float threshold, bool overwrite, bool block);
+    void select_facets_by_angle(float threshold, bool block);
-    bool m_overwrite_selected = false;
     float m_angle_threshold_deg = 45.f;
 
     bool is_mesh_point_clipped(const Vec3d& point) const;