3DScene layers editing parameters moved to c++

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

@@ -2025,11 +2025,56 @@ void _3DScene::set_layers_editing_band_width(wxGLCanvas* canvas, float band_widt
     s_canvas_mgr.set_layers_editing_band_width(canvas, band_width);
 }
 
+float _3DScene::get_layers_editing_strength(wxGLCanvas* canvas)
+{
+    return s_canvas_mgr.get_layers_editing_strength(canvas);
+}
+
+void _3DScene::set_layers_editing_strength(wxGLCanvas* canvas, float strength)
+{
+    s_canvas_mgr.set_layers_editing_strength(canvas, strength);
+}
+
+int _3DScene::get_layers_editing_last_object_id(wxGLCanvas* canvas)
+{
+    return s_canvas_mgr.get_layers_editing_last_object_id(canvas);
+}
+
+void _3DScene::set_layers_editing_last_object_id(wxGLCanvas* canvas, int id)
+{
+    s_canvas_mgr.set_layers_editing_last_object_id(canvas, id);
+}
+
+float _3DScene::get_layers_editing_last_z(wxGLCanvas* canvas)
+{
+    return s_canvas_mgr.get_layers_editing_last_z(canvas);
+}
+
+void _3DScene::set_layers_editing_last_z(wxGLCanvas* canvas, float z)
+{
+    s_canvas_mgr.set_layers_editing_last_z(canvas, z);
+}
+
+unsigned int _3DScene::get_layers_editing_last_action(wxGLCanvas* canvas)
+{
+    return s_canvas_mgr.get_layers_editing_last_action(canvas);
+}
+
+void _3DScene::set_layers_editing_last_action(wxGLCanvas* canvas, unsigned int action)
+{
+    s_canvas_mgr.set_layers_editing_last_action(canvas, action);
+}
+
 GLShader* _3DScene::get_layers_editing_shader(wxGLCanvas* canvas)
 {
     return s_canvas_mgr.get_layers_editing_shader(canvas);
 }
 
+float _3DScene::get_layers_editing_cursor_z_relative(wxGLCanvas* canvas)
+{
+    return s_canvas_mgr.get_layers_editing_cursor_z_relative(canvas);
+}
+
 void _3DScene::zoom_to_bed(wxGLCanvas* canvas)
 {
     s_canvas_mgr.zoom_to_bed(canvas);

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

@@ -622,8 +622,22 @@ public:
     static float get_layers_editing_band_width(wxGLCanvas* canvas);
     static void set_layers_editing_band_width(wxGLCanvas* canvas, float band_width);
 
+    static float get_layers_editing_strength(wxGLCanvas* canvas);
+    static void set_layers_editing_strength(wxGLCanvas* canvas, float strength);
+
+    static int get_layers_editing_last_object_id(wxGLCanvas* canvas);
+    static void set_layers_editing_last_object_id(wxGLCanvas* canvas, int id);
+
+    static float get_layers_editing_last_z(wxGLCanvas* canvas);
+    static void set_layers_editing_last_z(wxGLCanvas* canvas, float z);
+
+    static unsigned int get_layers_editing_last_action(wxGLCanvas* canvas);
+    static void set_layers_editing_last_action(wxGLCanvas* canvas, unsigned int action);
+
     static GLShader* get_layers_editing_shader(wxGLCanvas* canvas);
 
+    static float get_layers_editing_cursor_z_relative(wxGLCanvas* canvas);
+
     static void zoom_to_bed(wxGLCanvas* canvas);
     static void zoom_to_volumes(wxGLCanvas* canvas);
     static void select_view(wxGLCanvas* canvas, const std::string& direction);

xs/src/slic3r/GUI/GLCanvas3D.cpp

@@ -593,6 +593,10 @@ GLCanvas3D::LayersEditing::LayersEditing()
     , m_enabled(false)
     , m_z_texture_id(0)
     , m_band_width(2.0f)
+    , m_strength(0.005f)
+    , m_last_object_id(-1)
+    , m_last_z(0.0f)
+    , m_last_action(0)
 {
 }
 
@@ -669,6 +673,46 @@ void GLCanvas3D::LayersEditing::set_band_width(float band_width)
     m_band_width = band_width;
 }
 
+float GLCanvas3D::LayersEditing::get_strength() const
+{
+    return m_strength;
+}
+
+void GLCanvas3D::LayersEditing::set_strength(float strength)
+{
+    m_strength = strength;
+}
+
+int GLCanvas3D::LayersEditing::get_last_object_id() const
+{
+    return m_last_object_id;
+}
+
+void GLCanvas3D::LayersEditing::set_last_object_id(int id)
+{
+    m_last_object_id = id;
+}
+
+float GLCanvas3D::LayersEditing::get_last_z() const
+{
+    return m_last_z;
+}
+
+void GLCanvas3D::LayersEditing::set_last_z(float z)
+{
+    m_last_z = z;
+}
+
+unsigned int GLCanvas3D::LayersEditing::get_last_action() const
+{
+    return m_last_action;
+}
+
+void GLCanvas3D::LayersEditing::set_last_action(unsigned int action)
+{
+    m_last_action = action;
+}
+
 void GLCanvas3D::LayersEditing::render(const GLCanvas3D& canvas, const PrintObject& print_object, const GLVolume& volume) const
 {
     if (!m_enabled)
@@ -700,6 +744,22 @@ GLShader* GLCanvas3D::LayersEditing::get_shader()
     return m_shader.get_shader();
 }
 
+float GLCanvas3D::LayersEditing::get_cursor_z_relative(const GLCanvas3D& canvas) const
+{
+    const Point& mouse_pos = canvas.get_local_mouse_position();
+    const Rect& bar_rect = _get_bar_rect_screen(canvas);
+    float x = (float)mouse_pos.x;
+    float y = (float)mouse_pos.y;
+    float t = bar_rect.get_top();
+    float b = bar_rect.get_bottom();
+
+    return ((bar_rect.get_left() <= x) && (x <= bar_rect.get_right()) && (t <= y) && (y <= b)) ?
+        // Inside the bar.
+        (b - y - 1.0f) / (b - t - 1.0f) :
+        // Outside the bar.
+        -1000.0f;
+}
+
 bool GLCanvas3D::LayersEditing::_is_initialized() const
 {
     return m_shader.is_initialized();
@@ -796,7 +856,7 @@ void GLCanvas3D::LayersEditing::_render_active_object_annotations(const GLCanvas
 
     m_shader.set_uniform("z_to_texture_row", (float)volume.layer_height_texture_z_to_row_id());
     m_shader.set_uniform("z_texture_row_to_normalized", 1.0f / (float)volume.layer_height_texture_height());
-    m_shader.set_uniform("z_cursor", max_z * _cursor_z_relative(canvas));
+    m_shader.set_uniform("z_cursor", max_z * get_cursor_z_relative(canvas));
     m_shader.set_uniform("z_cursor_band_width", get_band_width());
 
     GLsizei w = (GLsizei)volume.layer_height_texture_width();
@@ -924,21 +984,6 @@ Rect GLCanvas3D::LayersEditing::_get_reset_rect_viewport(const GLCanvas3D& canva
     return Rect((half_w - VARIABLE_LAYER_THICKNESS_BAR_WIDTH) * inv_zoom, (-half_h + VARIABLE_LAYER_THICKNESS_RESET_BUTTON_HEIGHT) * inv_zoom, half_w * inv_zoom, -half_h * inv_zoom);
 }
 
-float GLCanvas3D::LayersEditing::_cursor_z_relative(const GLCanvas3D& canvas) const
-{
-    const Point& mouse_pos = canvas.get_local_mouse_position();
-    const Rect& bar_rect = _get_bar_rect_screen(canvas);
-    float x = (float)mouse_pos.x;
-    float y = (float)mouse_pos.y;
-    float t = bar_rect.get_top();
-    float b = bar_rect.get_bottom();
-    return ((bar_rect.get_left() <= x) && (x <= bar_rect.get_right()) && (t <= y) && (y <= b)) ?
-        // Inside the bar.
-        (b - y - 1.0f) / (b - t - 1.0f) :
-        // Outside the bar.
-        - 1000.0f;
-}
-
 GLCanvas3D::Mouse::Mouse()
     : m_dragging(false)
 {
@@ -1559,11 +1604,56 @@ void GLCanvas3D::set_layers_editing_band_width(float band_width)
     m_layers_editing.set_band_width(band_width);
 }
 
+float GLCanvas3D::get_layers_editing_strength() const
+{
+    return m_layers_editing.get_strength();
+}
+
+void GLCanvas3D::set_layers_editing_strength(float strength)
+{
+    m_layers_editing.set_strength(strength);
+}
+
+int GLCanvas3D::get_layers_editing_last_object_id() const
+{
+    return m_layers_editing.get_last_object_id();
+}
+
+void GLCanvas3D::set_layers_editing_last_object_id(int id)
+{
+    m_layers_editing.set_last_object_id(id);
+}
+
+float GLCanvas3D::get_layers_editing_last_z() const
+{
+    return m_layers_editing.get_last_z();
+}
+
+void GLCanvas3D::set_layers_editing_last_z(float z)
+{
+    m_layers_editing.set_last_z(z);
+}
+
+unsigned int GLCanvas3D::get_layers_editing_last_action() const
+{
+    return m_layers_editing.get_last_action();
+}
+
+void GLCanvas3D::set_layers_editing_last_action(unsigned int action)
+{
+    m_layers_editing.set_last_action(action);
+}
+
 GLShader* GLCanvas3D::get_layers_editing_shader()
 {
     return m_layers_editing.get_shader();
 }
 
+float GLCanvas3D::get_layers_editing_cursor_z_relative(const GLCanvas3D& canvas) const
+{
+    return m_layers_editing.get_cursor_z_relative(canvas);
+}
+
 void GLCanvas3D::render_bed() const
 {
     m_bed.render();
@@ -1877,7 +1967,7 @@ Point GLCanvas3D::get_local_mouse_position() const
         return Point();
 
     wxPoint mouse_pos = m_canvas->ScreenToClient(wxGetMousePosition());
-    return Point(mouse_pos.x, mouse_pos.x);
+    return Point(mouse_pos.x, mouse_pos.y);
 }
 
 void GLCanvas3D::_zoom_to_bounding_box(const BoundingBoxf3& bbox)

xs/src/slic3r/GUI/GLCanvas3D.hpp

@@ -218,6 +218,10 @@ public:
         mutable GLTextureData m_tooltip_texture;
         mutable GLTextureData m_reset_texture;
         float m_band_width;
+        float m_strength;
+        int m_last_object_id;
+        float m_last_z;
+        unsigned int m_last_action;
 
     public:
         LayersEditing();
@@ -236,10 +240,24 @@ public:
         float get_band_width() const;
         void set_band_width(float band_width);
 
+        float get_strength() const;
+        void set_strength(float strength);
+
+        int get_last_object_id() const;
+        void set_last_object_id(int id);
+
+        float get_last_z() const;
+        void set_last_z(float z);
+
+        unsigned int get_last_action() const;
+        void set_last_action(unsigned int action);
+
         void render(const GLCanvas3D& canvas, const PrintObject& print_object, const GLVolume& volume) const;
 
         GLShader* get_shader();
 
+        float get_cursor_z_relative(const GLCanvas3D& canvas) const;
+
     private:
         bool _is_initialized() const;
         GLTextureData _load_texture_from_file(const std::string& filename) const;
@@ -251,7 +269,6 @@ public:
         Rect _get_reset_rect_screen(const GLCanvas3D& canvas) const;
         Rect _get_bar_rect_viewport(const GLCanvas3D& canvas) const;
         Rect _get_reset_rect_viewport(const GLCanvas3D& canvas) const;
-        float _cursor_z_relative(const GLCanvas3D& canvas) const;
     };
 
     class Mouse
@@ -384,8 +401,22 @@ public:
     float get_layers_editing_band_width() const;
     void set_layers_editing_band_width(float band_width);
 
+    float get_layers_editing_strength() const;
+    void set_layers_editing_strength(float strength);
+
+    int get_layers_editing_last_object_id() const;
+    void set_layers_editing_last_object_id(int id);
+
+    float get_layers_editing_last_z() const;
+    void set_layers_editing_last_z(float z);
+
+    unsigned int get_layers_editing_last_action() const;
+    void set_layers_editing_last_action(unsigned int action);
+
     GLShader* get_layers_editing_shader();
 
+    float get_layers_editing_cursor_z_relative(const GLCanvas3D& canvas) const;
+
     void zoom_to_bed();
     void zoom_to_volumes();
     void select_view(const std::string& direction);

xs/src/slic3r/GUI/GLCanvas3DManager.cpp

@@ -492,12 +492,70 @@ void GLCanvas3DManager::set_layers_editing_band_width(wxGLCanvas* canvas, float
         it->second->set_layers_editing_band_width(band_width);
 }
 
+float GLCanvas3DManager::get_layers_editing_strength(wxGLCanvas* canvas) const
+{
+    CanvasesMap::const_iterator it = _get_canvas(canvas);
+    return (it != m_canvases.end()) ? it->second->get_layers_editing_strength() : 0.0f;
+}
+
+void GLCanvas3DManager::set_layers_editing_strength(wxGLCanvas* canvas, float strength)
+{
+    CanvasesMap::iterator it = _get_canvas(canvas);
+    if (it != m_canvases.end())
+        it->second->set_layers_editing_strength(strength);
+}
+
+int GLCanvas3DManager::get_layers_editing_last_object_id(wxGLCanvas* canvas) const
+{
+    CanvasesMap::const_iterator it = _get_canvas(canvas);
+    return (it != m_canvases.end()) ? it->second->get_layers_editing_last_object_id() : -1;
+}
+
+void GLCanvas3DManager::set_layers_editing_last_object_id(wxGLCanvas* canvas, int id)
+{
+    CanvasesMap::iterator it = _get_canvas(canvas);
+    if (it != m_canvases.end())
+        it->second->set_layers_editing_last_object_id(id);
+}
+
+float GLCanvas3DManager::get_layers_editing_last_z(wxGLCanvas* canvas) const
+{
+    CanvasesMap::const_iterator it = _get_canvas(canvas);
+    return (it != m_canvases.end()) ? it->second->get_layers_editing_last_z() : 0.0f;
+}
+
+void GLCanvas3DManager::set_layers_editing_last_z(wxGLCanvas* canvas, float z)
+{
+    CanvasesMap::iterator it = _get_canvas(canvas);
+    if (it != m_canvases.end())
+        it->second->set_layers_editing_last_z(z);
+}
+
+unsigned int GLCanvas3DManager::get_layers_editing_last_action(wxGLCanvas* canvas) const
+{
+    CanvasesMap::const_iterator it = _get_canvas(canvas);
+    return (it != m_canvases.end()) ? it->second->get_layers_editing_last_action() : 0;
+}
+
+void GLCanvas3DManager::set_layers_editing_last_action(wxGLCanvas* canvas, unsigned int action)
+{
+    CanvasesMap::iterator it = _get_canvas(canvas);
+    if (it != m_canvases.end())
+        it->second->set_layers_editing_last_action(action);
+}
+
 GLShader* GLCanvas3DManager::get_layers_editing_shader(wxGLCanvas* canvas)
 {
     CanvasesMap::const_iterator it = _get_canvas(canvas);
     return (it != m_canvases.end()) ? it->second->get_layers_editing_shader() : nullptr;
 }
 
+float GLCanvas3DManager::get_layers_editing_cursor_z_relative(wxGLCanvas* canvas) const
+{
+    CanvasesMap::const_iterator it = _get_canvas(canvas);
+    return (it != m_canvases.end()) ? it->second->get_layers_editing_cursor_z_relative(*it->second) : 0.0f;
+}
+
 void GLCanvas3DManager::zoom_to_bed(wxGLCanvas* canvas)
 {
     CanvasesMap::iterator it = _get_canvas(canvas);

xs/src/slic3r/GUI/GLCanvas3DManager.hpp

@@ -122,8 +122,22 @@ public:
     float get_layers_editing_band_width(wxGLCanvas* canvas) const;
     void set_layers_editing_band_width(wxGLCanvas* canvas, float band_width);
 
+    float get_layers_editing_strength(wxGLCanvas* canvas) const;
+    void set_layers_editing_strength(wxGLCanvas* canvas, float strength);
+
+    int get_layers_editing_last_object_id(wxGLCanvas* canvas) const;
+    void set_layers_editing_last_object_id(wxGLCanvas* canvas, int id);
+
+    float get_layers_editing_last_z(wxGLCanvas* canvas) const;
+    void set_layers_editing_last_z(wxGLCanvas* canvas, float z);
+
+    unsigned int get_layers_editing_last_action(wxGLCanvas* canvas) const;
+    void set_layers_editing_last_action(wxGLCanvas* canvas, unsigned int action);
+
     GLShader* get_layers_editing_shader(wxGLCanvas* canvas);
 
+    float get_layers_editing_cursor_z_relative(wxGLCanvas* canvas) const;
+
     void zoom_to_bed(wxGLCanvas* canvas);
     void zoom_to_volumes(wxGLCanvas* canvas);
     void select_view(wxGLCanvas* canvas, const std::string& direction);