reload_scene method of 3D class moved to c++

xs/src/libslic3r/Utils.hpp

@@ -97,6 +97,7 @@ public:
     void call(int i, int j) const;
     void call(const std::vector<int>& ints) const;
     void call(double x, double y) const;
+    void call(bool b) const;
 //    void call();
 //    void call(int i);
 //    void call(int i, int j);

xs/src/libslic3r/utils.cpp

@@ -282,6 +282,11 @@ void PerlCallback::call(double x, double y) const
     FREETMPS;
     LEAVE;
 }
+
+void PerlCallback::call(bool b) const
+{
+    call(b ? 1 : 0);
+}
 //##############################################################################################################
 
 #ifdef WIN32

xs/src/slic3r/GUI/3DScene.cpp

@@ -1822,6 +1822,16 @@ void _3DScene::select_volume(wxGLCanvas* canvas, unsigned int id)
     s_canvas_mgr.select_volume(canvas, id);
 }
 
+void _3DScene::update_volumes_selection(wxGLCanvas* canvas, const std::vector<int>& selections)
+{
+    s_canvas_mgr.update_volumes_selection(canvas, selections);
+}
+
+void _3DScene::set_objects_selections(wxGLCanvas* canvas, const std::vector<int>& selections)
+{
+    s_canvas_mgr.set_objects_selections(canvas, selections);
+}
+
 void _3DScene::set_config(wxGLCanvas* canvas, DynamicPrintConfig* config)
 {
     s_canvas_mgr.set_config(canvas, config);
@@ -1892,6 +1902,11 @@ bool _3DScene::is_shader_enabled(wxGLCanvas* canvas)
     return s_canvas_mgr.is_shader_enabled(canvas);
 }
 
+bool _3DScene::is_reload_delayed(wxGLCanvas* canvas)
+{
+    return s_canvas_mgr.is_reload_delayed(canvas);
+}
+
 void _3DScene::enable_layers_editing(wxGLCanvas* canvas, bool enable)
 {
     s_canvas_mgr.enable_layers_editing(canvas, enable);
@@ -2091,6 +2106,11 @@ std::vector<int> _3DScene::load_object(wxGLCanvas* canvas, const Model* model, i
     return s_canvas_mgr.load_object(canvas, model, obj_idx);
 }
 
+void _3DScene::reload_scene(wxGLCanvas* canvas, bool force)
+{
+    s_canvas_mgr.reload_scene(canvas, force);
+}
+
 void _3DScene::load_print_toolpaths(wxGLCanvas* canvas)
 {
     s_canvas_mgr.load_print_toolpaths(canvas);

xs/src/slic3r/GUI/3DScene.hpp

@@ -562,6 +562,9 @@ public:
     static void reset_volumes(wxGLCanvas* canvas);
     static void deselect_volumes(wxGLCanvas* canvas);
     static void select_volume(wxGLCanvas* canvas, unsigned int id);
+    static void update_volumes_selection(wxGLCanvas* canvas, const std::vector<int>& selections);
+
+    static void set_objects_selections(wxGLCanvas* canvas, const std::vector<int>& selections);
 
     static void set_config(wxGLCanvas* canvas, DynamicPrintConfig* config);
     static void set_print(wxGLCanvas* canvas, Print* print);
@@ -584,6 +587,8 @@ public:
     static bool is_layers_editing_allowed(wxGLCanvas* canvas);
     static bool is_shader_enabled(wxGLCanvas* canvas);
 
+    static bool is_reload_delayed(wxGLCanvas* canvas);
+
     static void enable_layers_editing(wxGLCanvas* canvas, bool enable);
     static void enable_warning_texture(wxGLCanvas* canvas, bool enable);
     static void enable_legend_texture(wxGLCanvas* canvas, bool enable);
@@ -628,6 +633,8 @@ public:
     static std::vector<int> load_object(wxGLCanvas* canvas, const ModelObject* model_object, int obj_idx, std::vector<int> instance_idxs);
     static std::vector<int> load_object(wxGLCanvas* canvas, const Model* model, int obj_idx);
 
+    static void reload_scene(wxGLCanvas* canvas, bool force);
+
     static void load_print_toolpaths(wxGLCanvas* canvas);
     static void load_print_object_toolpaths(wxGLCanvas* canvas, const PrintObject* print_object, const std::vector<std::string>& str_tool_colors);
     static void load_wipe_tower_toolpaths(wxGLCanvas* canvas, const std::vector<std::string>& str_tool_colors);

xs/src/slic3r/GUI/GLCanvas3D.cpp

@@ -2,6 +2,7 @@
 
 #include "../../slic3r/GUI/3DScene.hpp"
 #include "../../slic3r/GUI/GLShader.hpp"
+#include "../../slic3r/GUI/GUI.hpp"
 #include "../../libslic3r/ClipperUtils.hpp"
 #include "../../libslic3r/PrintConfig.hpp"
 #include "../../libslic3r/Print.hpp"
@@ -963,6 +964,7 @@ GLCanvas3D::GLCanvas3D(wxGLCanvas* canvas, wxGLContext* context)
     , m_color_by("volume")
     , m_select_by("object")
     , m_drag_by("instance")
+    , m_reload_delayed(false)
 {
     if (m_canvas != nullptr)
         m_timer = new wxTimer(m_canvas);
@@ -1107,6 +1109,29 @@ void GLCanvas3D::select_volume(unsigned int id)
     }
 }
 
+void GLCanvas3D::update_volumes_selection(const std::vector<int>& selections)
+{
+    if (m_model == nullptr)
+        return;
+
+    for (unsigned int obj_idx = 0; obj_idx < (unsigned int)m_model->objects.size(); ++obj_idx)
+    {
+        if (selections[obj_idx] == 1)
+        {
+            const std::vector<int>& volume_idxs = m_objects_volumes_idxs[obj_idx];
+            for (int v : volume_idxs)
+            {
+                select_volume(v);
+            }
+        }
+    }
+}
+
+void GLCanvas3D::set_objects_selections(const std::vector<int>& selections)
+{
+    m_objects_selections = selections;
+}
+
 void GLCanvas3D::set_config(DynamicPrintConfig* config)
 {
     m_config = config;
@@ -1210,6 +1235,11 @@ bool GLCanvas3D::is_shader_enabled() const
     return m_shader_enabled;
 }
 
+bool GLCanvas3D::is_reload_delayed() const
+{
+    return m_reload_delayed;
+}
+
 void GLCanvas3D::enable_layers_editing(bool enable)
 {
     m_layers_editing.set_enabled(enable);
@@ -1409,6 +1439,81 @@ std::vector<int> GLCanvas3D::load_object(const Model& model, int obj_idx)
     return std::vector<int>();
 }
 
+void GLCanvas3D::reload_scene(bool force)
+{
+    if ((m_canvas == nullptr) || (m_config == nullptr) || (m_model == nullptr) || (m_volumes == nullptr))
+        return;
+
+    reset_volumes();
+    set_bed_shape(dynamic_cast<const ConfigOptionPoints*>(m_config->option("bed_shape"))->values);
+
+    if (!m_canvas->IsShown() && !force)
+    {
+        m_reload_delayed = true;
+        return;
+    }
+
+    m_reload_delayed = false;
+
+    m_objects_volumes_idxs.clear();
+
+    for (unsigned int obj_idx = 0; obj_idx < (unsigned int)m_model->objects.size(); ++obj_idx)
+    {
+        m_objects_volumes_idxs.push_back(load_object(*m_model, obj_idx));
+    }
+
+    update_volumes_selection(m_objects_selections);
+
+    if (m_config->has("nozzle_diameter"))
+    {
+        // Should the wipe tower be visualized ?
+        unsigned int extruders_count = (unsigned int)dynamic_cast<const ConfigOptionFloats*>(m_config->option("nozzle_diameter"))->values.size();
+
+        bool semm = dynamic_cast<const ConfigOptionBool*>(m_config->option("single_extruder_multi_material"))->value;
+        bool wt = dynamic_cast<const ConfigOptionBool*>(m_config->option("wipe_tower"))->value;
+        bool co = dynamic_cast<const ConfigOptionBool*>(m_config->option("complete_objects"))->value;
+
+        if ((extruders_count > 1) && semm && wt && !co)
+        {
+            // Height of a print (Show at least a slab)
+            coordf_t height = std::max(m_model->bounding_box().max.z, 10.0);
+
+            float x = dynamic_cast<const ConfigOptionFloat*>(m_config->option("wipe_tower_x"))->value;
+            float y = dynamic_cast<const ConfigOptionFloat*>(m_config->option("wipe_tower_y"))->value;
+            float w = dynamic_cast<const ConfigOptionFloat*>(m_config->option("wipe_tower_width"))->value;
+            float a = dynamic_cast<const ConfigOptionFloat*>(m_config->option("wipe_tower_rotation_angle"))->value;
+
+            m_volumes->load_wipe_tower_preview(1000, x, y, w, 15.0f * (float)(extruders_count - 1), (float)height, a, m_use_VBOs && m_initialized);
+        }
+    }
+
+    update_volumes_colors_by_extruder();
+
+    // checks for geometry outside the print volume to render it accordingly
+    if (!m_volumes->empty())
+    {
+        bool contained = m_volumes->check_outside_state(m_config);
+        if (!contained)
+        {
+            enable_warning_texture(true);
+            _3DScene::generate_warning_texture(L("Detected object outside print volume"));
+            m_on_enable_action_buttons_callback.call(false);
+        }
+        else
+        {
+            enable_warning_texture(false);
+            m_volumes->reset_outside_state();
+            _3DScene::reset_warning_texture();
+            m_on_enable_action_buttons_callback.call(!m_model->objects.empty());
+        }
+    }
+    else
+    {
+        enable_warning_texture(false);
+        _3DScene::reset_warning_texture();
+    }
+}
+
 void GLCanvas3D::load_print_toolpaths()
 {
     if ((m_print == nullptr) || (m_volumes == nullptr))

xs/src/slic3r/GUI/GLCanvas3D.hpp

@@ -14,6 +14,7 @@ class wxKeyEvent;
 class wxMouseEvent;
 class wxTimerEvent;
 class wxPaintEvent;
+class wxActivateEvent;
 
 namespace Slic3r {
 
@@ -349,6 +350,10 @@ private:
     std::string m_select_by;
     std::string m_drag_by;
 
+    bool m_reload_delayed;
+    std::vector<std::vector<int>> m_objects_volumes_idxs;
+    std::vector<int> m_objects_selections;
+
     GCodePreviewVolumeIndex m_gcode_preview_volume_index;
 
     PerlCallback m_on_viewport_changed_callback;
@@ -381,6 +386,9 @@ public:
     void reset_volumes();
     void deselect_volumes();
     void select_volume(unsigned int id);
+    void update_volumes_selection(const std::vector<int>& selections);
+
+    void set_objects_selections(const std::vector<int>& selections);
 
     void set_config(DynamicPrintConfig* config);
     void set_print(Print* print);
@@ -410,6 +418,8 @@ public:
     bool is_layers_editing_allowed() const;
     bool is_shader_enabled() const;
 
+    bool is_reload_delayed() const;
+
     void enable_layers_editing(bool enable);
     void enable_warning_texture(bool enable);
     void enable_legend_texture(bool enable);
@@ -435,6 +445,8 @@ public:
     std::vector<int> load_object(const ModelObject& model_object, int obj_idx, std::vector<int> instance_idxs);
     std::vector<int> load_object(const Model& model, int obj_idx);
 
+    void reload_scene(bool force);
+
     // Create 3D thick extrusion lines for a skirt and brim.
     // Adds a new Slic3r::GUI::3DScene::Volume to volumes.
     void load_print_toolpaths();

xs/src/slic3r/GUI/GLCanvas3DManager.cpp

@@ -254,6 +254,20 @@ void GLCanvas3DManager::select_volume(wxGLCanvas* canvas, unsigned int id)
         it->second->select_volume(id);
 }
 
+void GLCanvas3DManager::update_volumes_selection(wxGLCanvas* canvas, const std::vector<int>& selections)
+{
+    CanvasesMap::iterator it = _get_canvas(canvas);
+    if (it != m_canvases.end())
+        it->second->update_volumes_selection(selections);
+}
+
+void GLCanvas3DManager::set_objects_selections(wxGLCanvas* canvas, const std::vector<int>& selections)
+{
+    CanvasesMap::iterator it = _get_canvas(canvas);
+    if (it != m_canvases.end())
+        it->second->set_objects_selections(selections);
+}
+
 void GLCanvas3DManager::set_config(wxGLCanvas* canvas, DynamicPrintConfig* config)
 {
     CanvasesMap::iterator it = _get_canvas(canvas);
@@ -348,6 +362,12 @@ bool GLCanvas3DManager::is_shader_enabled(wxGLCanvas* canvas) const
     return (it != m_canvases.end()) ? it->second->is_shader_enabled() : false;
 }
 
+bool GLCanvas3DManager::is_reload_delayed(wxGLCanvas* canvas) const
+{
+    CanvasesMap::const_iterator it = _get_canvas(canvas);
+    return (it != m_canvases.end()) ? it->second->is_reload_delayed() : false;
+}
+
 void GLCanvas3DManager::enable_layers_editing(wxGLCanvas* canvas, bool enable)
 {
     CanvasesMap::iterator it = _get_canvas(canvas);
@@ -481,6 +501,13 @@ std::vector<int> GLCanvas3DManager::load_object(wxGLCanvas* canvas, const Model*
     return (it != m_canvases.end()) ? it->second->load_object(*model, obj_idx) : std::vector<int>();
 }
 
+void GLCanvas3DManager::reload_scene(wxGLCanvas* canvas, bool force)
+{
+    CanvasesMap::iterator it = _get_canvas(canvas);
+    if (it != m_canvases.end())
+        it->second->reload_scene(force);
+}
+
 void GLCanvas3DManager::load_print_toolpaths(wxGLCanvas* canvas)
 {
     CanvasesMap::iterator it = _get_canvas(canvas);

xs/src/slic3r/GUI/GLCanvas3DManager.hpp

@@ -57,6 +57,9 @@ public:
     void reset_volumes(wxGLCanvas* canvas);
     void deselect_volumes(wxGLCanvas* canvas);
     void select_volume(wxGLCanvas* canvas, unsigned int id);
+    void update_volumes_selection(wxGLCanvas* canvas, const std::vector<int>& selections);
+
+    void set_objects_selections(wxGLCanvas* canvas, const std::vector<int>& selections);
 
     void set_config(wxGLCanvas* canvas, DynamicPrintConfig* config);
     void set_print(wxGLCanvas* canvas, Print* print);
@@ -79,6 +82,8 @@ public:
     bool is_layers_editing_allowed(wxGLCanvas* canvas) const;
     bool is_shader_enabled(wxGLCanvas* canvas) const;
 
+    bool is_reload_delayed(wxGLCanvas* canvas) const;
+
     void enable_layers_editing(wxGLCanvas* canvas, bool enable);
     void enable_warning_texture(wxGLCanvas* canvas, bool enable);
     void enable_legend_texture(wxGLCanvas* canvas, bool enable);
@@ -103,6 +108,8 @@ public:
     std::vector<int> load_object(wxGLCanvas* canvas, const ModelObject* model_object, int obj_idx, std::vector<int> instance_idxs);
     std::vector<int> load_object(wxGLCanvas* canvas, const Model* model, int obj_idx);
 
+    void reload_scene(wxGLCanvas* canvas, bool force);
+
     void load_print_toolpaths(wxGLCanvas* canvas);
     void load_print_object_toolpaths(wxGLCanvas* canvas, const PrintObject* print_object, const std::vector<std::string>& tool_colors);
     void load_wipe_tower_toolpaths(wxGLCanvas* canvas, const std::vector<std::string>& str_tool_colors);

xs/xsp/GUI_3DScene.xsp

@@ -225,6 +225,20 @@ select_volume(canvas, id)
     CODE:
         _3DScene::select_volume((wxGLCanvas*)wxPli_sv_2_object(aTHX_ canvas, "Wx::GLCanvas"), id);
 
+void
+update_volumes_selection(canvas, selections)
+        SV               *canvas;
+        std::vector<int> selections;
+    CODE:
+        _3DScene::update_volumes_selection((wxGLCanvas*)wxPli_sv_2_object(aTHX_ canvas, "Wx::GLCanvas"), selections);
+
+void
+set_objects_selections(canvas, selections)
+        SV               *canvas;
+        std::vector<int> selections;
+    CODE:
+        _3DScene::set_objects_selections((wxGLCanvas*)wxPli_sv_2_object(aTHX_ canvas, "Wx::GLCanvas"), selections);
+
 void
 set_config(canvas, config)
         SV                 *canvas;
@@ -327,6 +341,14 @@ is_shader_enabled(canvas)
     OUTPUT:
         RETVAL
 
+bool
+is_reload_delayed(canvas)
+        SV *canvas;
+    CODE:
+        RETVAL = _3DScene::is_reload_delayed((wxGLCanvas*)wxPli_sv_2_object(aTHX_ canvas, "Wx::GLCanvas"));
+    OUTPUT:
+        RETVAL
+
 void
 enable_layers_editing(canvas, enable)
         SV   *canvas;
@@ -621,6 +643,13 @@ load_model(canvas, model, obj_idx)
     OUTPUT:
         RETVAL
 
+void
+reload_scene(canvas, force)
+        SV   *canvas;
+        bool force;
+    CODE:
+        _3DScene::reload_scene((wxGLCanvas*)wxPli_sv_2_object(aTHX_ canvas, "Wx::GLCanvas"), force);
+
 void
 load_print_toolpaths(canvas)
         SV *canvas;