Shared data for SLA gizmos have been removed from GLGizmoBase

This commit introduces no functional changes, only code-shuffling

src/slic3r/GUI/Gizmos/GLGizmosManager.cpp

@@ -6,6 +6,8 @@
 #include "slic3r/GUI/GUI_ObjectManipulation.hpp"
 #include "slic3r/GUI/PresetBundle.hpp"
 #include "slic3r/Utils/UndoRedo.hpp"
+#include "libslic3r/SLAPrint.hpp"
+#include "slic3r/GUI/MeshUtils.hpp"
 
 #include <GL/glew.h>
 #include <wx/glcanvas.h>
@@ -83,16 +85,18 @@ bool GLGizmosManager::init()
             return false;
     }
 
-    m_common_gizmos_data.reset(new CommonGizmosData());
-
     // Order of gizmos in the vector must match order in EType!
     m_gizmos.emplace_back(new GLGizmoMove3D(m_parent, "move.svg", 0));
     m_gizmos.emplace_back(new GLGizmoScale3D(m_parent, "scale.svg", 1));
     m_gizmos.emplace_back(new GLGizmoRotate3D(m_parent, "rotate.svg", 2));
     m_gizmos.emplace_back(new GLGizmoFlatten(m_parent, "place.svg", 3));
     m_gizmos.emplace_back(new GLGizmoCut(m_parent, "cut.svg", 4));
-    m_gizmos.emplace_back(new GLGizmoHollow(m_parent, "hollow.svg", 5, m_common_gizmos_data.get()));
-    m_gizmos.emplace_back(new GLGizmoSlaSupports(m_parent, "sla_supports.svg", 6, m_common_gizmos_data.get()));
+    m_gizmos.emplace_back(new GLGizmoHollow(m_parent, "hollow.svg", 5));
+    m_gizmos.emplace_back(new GLGizmoSlaSupports(m_parent, "sla_supports.svg", 6));
+
+    m_common_gizmos_data.reset(new CommonGizmosData());
+    dynamic_cast<GLGizmoHollow*>(m_gizmos[Hollow].get())->set_common_data_ptr(m_common_gizmos_data.get());
+    dynamic_cast<GLGizmoSlaSupports*>(m_gizmos[SlaSupports].get())->set_common_data_ptr(m_common_gizmos_data.get());
 
     for (auto& gizmo : m_gizmos) {
         if (! gizmo->init()) {
@@ -1051,5 +1055,126 @@ bool GLGizmosManager::grabber_contains_mouse() const
     return (curr != nullptr) ? (curr->get_hover_id() != -1) : false;
 }
 
+
+
+CommonGizmosData::CommonGizmosData()
+{
+    m_clipping_plane.reset(new ClippingPlane(Vec3d::Zero(), 0.));
+}
+
+
+
+bool CommonGizmosData::update_from_backend(GLCanvas3D& canvas, ModelObject* model_object)
+{
+    recent_update = false;
+    bool object_changed = false;
+
+    if (m_model_object != model_object
+    || (model_object && m_model_object_id != model_object->id())) {
+        m_model_object = model_object;
+        m_print_object_idx = -1;
+        m_mesh_raycaster.reset();
+        m_object_clipper.reset();
+        m_supports_clipper.reset();
+        m_old_mesh = nullptr;
+        m_mesh = nullptr;
+        m_backend_mesh_transformed.clear();
+
+        object_changed = true;
+        recent_update = true;
+    }
+
+    if (m_model_object) {
+        int active_inst = canvas.get_selection().get_instance_idx();
+        if (m_active_instance != active_inst) {
+            m_active_instance = active_inst;
+            m_active_instance_bb_radius = m_model_object->instance_bounding_box(m_active_instance).radius();
+            recent_update = true;
+        }
+    }
+
+
+    if (! m_model_object || ! canvas.get_selection().is_from_single_instance())
+        return false;
+
+    int old_po_idx = m_print_object_idx;
+
+    // First we need a pointer to the respective SLAPrintObject. The index into objects vector is
+    // cached so we don't have todo it on each render. We only search for the po if needed:
+    if (m_print_object_idx < 0 || (int)canvas.sla_print()->objects().size() != m_print_objects_count) {
+        m_print_objects_count = canvas.sla_print()->objects().size();
+        m_print_object_idx = -1;
+        for (const SLAPrintObject* po : canvas.sla_print()->objects()) {
+            ++m_print_object_idx;
+            if (po->model_object()->id() == m_model_object->id())
+                break;
+        }
+    }
+
+    bool mesh_exchanged = false;
+    m_mesh = nullptr;
+    // Load either the model_object mesh, or one provided by the backend
+    // This mesh does not account for the possible Z up SLA offset.
+    // The backend mesh needs to be transformed and because a pointer to it is
+    // saved, a copy is stored as a member (FIXME)
+    if (m_print_object_idx >=0) {
+        const SLAPrintObject* po = canvas.sla_print()->objects()[m_print_object_idx];
+        if (po->is_step_done(slaposDrillHoles)) {
+            m_backend_mesh_transformed = po->get_mesh_to_print();
+            m_backend_mesh_transformed.transform(canvas.sla_print()->sla_trafo(*m_model_object).inverse());
+            m_mesh = &m_backend_mesh_transformed;
+            m_has_drilled_mesh = true;
+            mesh_exchanged = true;
+        }
+    }
+
+    if (! m_mesh) {
+        m_mesh = &m_model_object->volumes.front()->mesh();
+        m_backend_mesh_transformed.clear();
+        m_has_drilled_mesh = false;
+    }
+
+    m_model_object_id = m_model_object->id();
+
+    if (m_mesh != m_old_mesh) {
+        // Update clipping plane position.
+        float new_clp_pos = m_clipping_plane_distance;
+        if (object_changed) {
+            new_clp_pos = 0.f;
+            m_clipping_plane_was_moved = false;
+        } else {
+            // After we got a drilled mesh, move the cp to 25% (if not used already)
+            if (m_clipping_plane_distance == 0.f && mesh_exchanged && m_has_drilled_mesh) {
+                new_clp_pos = 0.25f;
+                m_clipping_plane_was_moved = false; // so it uses current camera direction
+            }
+        }
+        m_clipping_plane_distance = new_clp_pos;
+        m_clipping_plane_distance_stash = new_clp_pos;
+
+        m_schedule_aabb_calculation = true;
+        recent_update = true;
+        return true;
+    }
+    if (! recent_update)
+        recent_update = m_print_object_idx < 0 && old_po_idx >= 0;
+
+    return recent_update;
+}
+
+
+void CommonGizmosData::build_AABB_if_needed()
+{
+    if (! m_schedule_aabb_calculation)
+        return;
+
+    wxBusyCursor wait;
+    m_mesh_raycaster.reset(new MeshRaycaster(*m_mesh));
+    m_object_clipper.reset();
+    m_supports_clipper.reset();
+    m_old_mesh = m_mesh;
+    m_schedule_aabb_calculation = false;
+}
+
 } // namespace GUI
 } // namespace Slic3r