3DScene mouse variables moved to c++

lib/Slic3r/GUI/3DScene.pm

@@ -37,14 +37,12 @@ use Slic3r::Geometry qw(PI);
 __PACKAGE__->mk_accessors( qw(_quat init
                               enable_moving
                               on_viewport_changed
-                              on_hover
                               on_select
                               on_double_click
                               on_right_click
                               on_move
                               on_model_update
                               volumes
-                              _mouse_pos
                               _hover_volume_idx
 
                               _drag_volume_idx
@@ -54,8 +52,6 @@ __PACKAGE__->mk_accessors( qw(_quat init
                               _dragged
 
                               _layer_height_edited
-
-                              _mouse_dragging
                                                             
                               ) );
 #__PACKAGE__->mk_accessors( qw(_quat _dirty init
@@ -192,8 +188,8 @@ sub new {
 #    $self->_warning_enabled(0);
 #    $self->use_plain_shader(0);
 #    $self->_apply_zoom_to_volumes_filter(0);
+#    $self->_mouse_dragging(0);
 #==============================================================================================================================
-    $self->_mouse_dragging(0);
 
     # Collection of GLVolume objects
     $self->volumes(Slic3r::GUI::_3DScene::GLVolume::Collection->new);
@@ -287,7 +283,7 @@ sub new {
         $self->mark_volumes_for_layer_height;
     };
     
-    Slic3r::GUI::_3DScene::register_on_mark_volumes_for_layer_height($self, $on_mark_volumes_for_layer_height);
+    Slic3r::GUI::_3DScene::register_on_mark_volumes_for_layer_height_callback($self, $on_mark_volumes_for_layer_height);
 #==============================================================================================================================
     
     return $self;
@@ -473,7 +469,10 @@ sub mouse_event {
     my $pos = Slic3r::Pointf->new($e->GetPositionXY);
     my $object_idx_selected = $self->{layer_height_edit_last_object_id} = ($self->layer_editing_enabled && $self->{print}) ? $self->_first_selected_object_id_for_variable_layer_height_editing : -1;
 
-    $self->_mouse_dragging($e->Dragging);
+#==============================================================================================================================
+    Slic3r::GUI::_3DScene::set_mouse_dragging($self, $e->Dragging);
+#    $self->_mouse_dragging($e->Dragging);
+#==============================================================================================================================
     
     if ($e->Entering && (&Wx::wxMSW || $^O eq 'linux')) {
         # wxMSW needs focus in order to catch mouse wheel events
@@ -662,7 +661,10 @@ sub mouse_event {
         $self->_drag_start_xy(undef);
         $self->_dragged(undef);
     } elsif ($e->Moving) {
-        $self->_mouse_pos($pos);
+#==============================================================================================================================
+        Slic3r::GUI::_3DScene::set_mouse_position($self, $pos);
+#        $self->_mouse_pos($pos);
+#==============================================================================================================================
         # Only refresh if picking is enabled, in that case the objects may get highlighted if the mouse cursor
         # hovers over.
 #==============================================================================================================================
@@ -1474,10 +1476,12 @@ sub Render {
     glLightfv_p(GL_LIGHT1, GL_POSITION, 1, 0, 1, 0);
 
 #==============================================================================================================================
-    if (Slic3r::GUI::_3DScene::is_picking_enabled($self) && !$self->_mouse_dragging) {
+    if (Slic3r::GUI::_3DScene::is_picking_enabled($self) && !Slic3r::GUI::_3DScene::is_mouse_dragging($self)) {
+        my $pos = Slic3r::GUI::_3DScene::get_mouse_position($self);
+        if ($pos) {
 #    if ($self->enable_picking && !$self->_mouse_dragging) {
+#        if (my $pos = $self->_mouse_pos) {
 #==============================================================================================================================
-        if (my $pos = $self->_mouse_pos) {
             # Render the object for picking.
             # FIXME This cannot possibly work in a multi-sampled context as the color gets mangled by the anti-aliasing.
             # Better to use software ray-casting on a bounding-box hierarchy.
@@ -1504,7 +1508,9 @@ sub Render {
                     $_->set_hover(1) for grep { $_->select_group_id == $group_id } @{$self->volumes};
                 }
                 
-                $self->on_hover->($volume_idx) if $self->on_hover;
+#==============================================================================================================================
+#                $self->on_hover->($volume_idx) if $self->on_hover;
+#==============================================================================================================================
             }
             glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
         }

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

@@ -1915,7 +1915,8 @@ Pointf3 _3DScene::get_camera_target(wxGLCanvas* canvas)
 
 void _3DScene::set_camera_target(wxGLCanvas* canvas, const Pointf3* target)
 {
-    s_canvas_mgr.set_camera_target(canvas, target);
+    if (target != nullptr)
+        s_canvas_mgr.set_camera_target(canvas, *target);
 }
  
 bool _3DScene::is_layers_editing_enabled(wxGLCanvas* canvas)
@@ -1953,6 +1954,27 @@ void _3DScene::enable_shader(wxGLCanvas* canvas, bool enable)
     s_canvas_mgr.enable_shader(canvas, enable);
 }
 
+bool _3DScene::is_mouse_dragging(wxGLCanvas* canvas)
+{
+    return s_canvas_mgr.is_mouse_dragging(canvas);
+}
+
+void _3DScene::set_mouse_dragging(wxGLCanvas* canvas, bool dragging)
+{
+    s_canvas_mgr.set_mouse_dragging(canvas, dragging);
+}
+
+Pointf _3DScene::get_mouse_position(wxGLCanvas* canvas)
+{
+    return s_canvas_mgr.get_mouse_position(canvas);
+}
+
+void _3DScene::set_mouse_position(wxGLCanvas* canvas, const Pointf* position)
+{
+    if (position != nullptr)
+        s_canvas_mgr.set_mouse_position(canvas, *position);
+}
+
 void _3DScene::zoom_to_bed(wxGLCanvas* canvas)
 {
     s_canvas_mgr.zoom_to_bed(canvas);
@@ -2028,9 +2050,9 @@ void _3DScene::register_on_viewport_changed_callback(wxGLCanvas* canvas, void* c
     s_canvas_mgr.register_on_viewport_changed_callback(canvas, callback);
 }
 
-void _3DScene::register_on_mark_volumes_for_layer_height(wxGLCanvas* canvas, void* callback)
+void _3DScene::register_on_mark_volumes_for_layer_height_callback(wxGLCanvas* canvas, void* callback)
 {
-    s_canvas_mgr.register_on_mark_volumes_for_layer_height(canvas, callback);
+    s_canvas_mgr.register_on_mark_volumes_for_layer_height_callback(canvas, callback);
 }
 
 //void _3DScene::_glew_init()

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

@@ -603,6 +603,12 @@ public:
     static void enable_picking(wxGLCanvas* canvas, bool enable);
     static void enable_shader(wxGLCanvas* canvas, bool enable);
 
+    static bool is_mouse_dragging(wxGLCanvas* canvas);
+    static void set_mouse_dragging(wxGLCanvas* canvas, bool dragging);
+
+    static Pointf get_mouse_position(wxGLCanvas* canvas);
+    static void set_mouse_position(wxGLCanvas* canvas, const Pointf* position);
+
     static void zoom_to_bed(wxGLCanvas* canvas);
     static void zoom_to_volumes(wxGLCanvas* canvas);
     static void select_view(wxGLCanvas* canvas, const std::string& direction);
@@ -622,7 +628,7 @@ public:
     static void render_texture(wxGLCanvas* canvas, unsigned int tex_id, float left, float right, float bottom, float top);
 
     static void register_on_viewport_changed_callback(wxGLCanvas* canvas, void* callback);
-    static void register_on_mark_volumes_for_layer_height(wxGLCanvas* canvas, void* callback);
+    static void register_on_mark_volumes_for_layer_height_callback(wxGLCanvas* canvas, void* callback);
 
 //    static void _glew_init();
 //##################################################################################################################

xs/src/slic3r/GUI/GLCanvas3D.cpp

@@ -474,6 +474,31 @@ void GLCanvas3D::Shader::stop() const
         m_shader->disable();
 }
 
+GLCanvas3D::Mouse::Mouse()
+    : m_dragging(false)
+{
+}
+
+bool GLCanvas3D::Mouse::is_dragging() const
+{
+    return m_dragging;
+}
+
+void GLCanvas3D::Mouse::set_dragging(bool dragging)
+{
+    m_dragging = dragging;
+}
+
+const Pointf& GLCanvas3D::Mouse::get_position() const
+{
+    return m_position;
+}
+
+void GLCanvas3D::Mouse::set_position(const Pointf& position)
+{
+    m_position = position;
+}
+
 GLCanvas3D::GLCanvas3D(wxGLCanvas* canvas, wxGLContext* context)
     : m_canvas(canvas)
     , m_context(context)
@@ -804,6 +829,26 @@ void GLCanvas3D::enable_shader(bool enable)
     m_shader.set_enabled(enable);
 }
 
+bool GLCanvas3D::is_mouse_dragging() const
+{
+    return m_mouse.is_dragging();
+}
+
+void GLCanvas3D::set_mouse_dragging(bool dragging)
+{
+    m_mouse.set_dragging(dragging);
+}
+
+const Pointf& GLCanvas3D::get_mouse_position() const
+{
+    return m_mouse.get_position();
+}
+
+void GLCanvas3D::set_mouse_position(const Pointf& position)
+{
+    m_mouse.set_position(position);
+}
+
 void GLCanvas3D::zoom_to_bed()
 {
     _zoom_to_bounding_box(bed_bounding_box());
@@ -960,7 +1005,7 @@ void GLCanvas3D::render_objects(bool useVBOs)
     {
         if (is_picking_enabled())
         {
-            m_on_mark_volumes_for_layer_height.call();
+            m_on_mark_volumes_for_layer_height_callback.call();
 
             if (m_config != nullptr)
             {
@@ -1093,10 +1138,10 @@ void GLCanvas3D::register_on_viewport_changed_callback(void* callback)
         m_on_viewport_changed_callback.register_callback(callback);
 }
 
-void GLCanvas3D::register_on_mark_volumes_for_layer_height(void* callback)
+void GLCanvas3D::register_on_mark_volumes_for_layer_height_callback(void* callback)
 {
     if (callback != nullptr)
-        m_on_mark_volumes_for_layer_height.register_callback(callback);
+        m_on_mark_volumes_for_layer_height_callback.register_callback(callback);
 }
 
 void GLCanvas3D::on_size(wxSizeEvent& evt)
@@ -1273,7 +1318,7 @@ float GLCanvas3D::_get_zoom_to_bounding_box_factor(const BoundingBoxf3& bbox) co
 void GLCanvas3D::_deregister_callbacks()
 {
     m_on_viewport_changed_callback.deregister_callback();
-    m_on_mark_volumes_for_layer_height.deregister_callback();
+    m_on_mark_volumes_for_layer_height_callback.deregister_callback();
 }
 
 } // namespace GUI

xs/src/slic3r/GUI/GLCanvas3D.hpp

@@ -161,6 +161,21 @@ public:
         void stop() const;
     };
 
+    class Mouse
+    {
+        bool m_dragging;
+        Pointf m_position;
+
+    public:
+        Mouse();
+
+        bool is_dragging() const;
+        void set_dragging(bool dragging);
+
+        const Pointf& get_position() const;
+        void set_position(const Pointf& position);
+    };
+
 private:
     wxGLCanvas* m_canvas;
     wxGLContext* m_context;
@@ -170,6 +185,7 @@ private:
     CuttingPlane m_cutting_plane;
     LayersEditing m_layers_editing;
     Shader m_shader;
+    Mouse m_mouse;
 
     GLVolumeCollection* m_volumes;
     DynamicPrintConfig* m_config;
@@ -181,7 +197,7 @@ private:
     bool m_picking_enabled;
 
     PerlCallback m_on_viewport_changed_callback;
-    PerlCallback m_on_mark_volumes_for_layer_height;
+    PerlCallback m_on_mark_volumes_for_layer_height_callback;
 
 public:
     GLCanvas3D(wxGLCanvas* canvas, wxGLContext* context);
@@ -253,6 +269,12 @@ public:
     void enable_picking(bool enable);
     void enable_shader(bool enable);
 
+    bool is_mouse_dragging() const;
+    void set_mouse_dragging(bool dragging);
+
+    const Pointf& get_mouse_position() const;
+    void set_mouse_position(const Pointf& position);
+
     void zoom_to_bed();
     void zoom_to_volumes();
     void select_view(const std::string& direction);
@@ -272,7 +294,7 @@ public:
     void render_texture(unsigned int tex_id, float left, float right, float bottom, float top) const;
 
     void register_on_viewport_changed_callback(void* callback);
-    void register_on_mark_volumes_for_layer_height(void* callback);
+    void register_on_mark_volumes_for_layer_height_callback(void* callback);
 
     void on_size(wxSizeEvent& evt);
     void on_idle(wxIdleEvent& evt);

xs/src/slic3r/GUI/GLCanvas3DManager.cpp

@@ -358,14 +358,11 @@ Pointf3 GLCanvas3DManager::get_camera_target(wxGLCanvas* canvas) const
     return (it != m_canvases.end()) ? it->second->get_camera_target() : Pointf3(0.0, 0.0, 0.0);
 }
 
-void GLCanvas3DManager::set_camera_target(wxGLCanvas* canvas, const Pointf3* target)
+void GLCanvas3DManager::set_camera_target(wxGLCanvas* canvas, const Pointf3& target)
 {
-    if (target == nullptr)
-        return;
-
     CanvasesMap::iterator it = _get_canvas(canvas);
     if (it != m_canvases.end())
-        it->second->set_camera_target(*target);
+        it->second->set_camera_target(target);
 }
 
 bool GLCanvas3DManager::is_layers_editing_enabled(wxGLCanvas* canvas) const
@@ -414,6 +411,32 @@ void GLCanvas3DManager::enable_shader(wxGLCanvas* canvas, bool enable)
         it->second->enable_shader(enable);
 }
 
+bool GLCanvas3DManager::is_mouse_dragging(wxGLCanvas* canvas) const
+{
+    CanvasesMap::const_iterator it = _get_canvas(canvas);
+    return (it != m_canvases.end()) ? it->second->is_mouse_dragging() : false;
+}
+
+void GLCanvas3DManager::set_mouse_dragging(wxGLCanvas* canvas, bool dragging)
+{
+    CanvasesMap::iterator it = _get_canvas(canvas);
+    if (it != m_canvases.end())
+        it->second->set_mouse_dragging(dragging);
+}
+
+Pointf GLCanvas3DManager::get_mouse_position(wxGLCanvas* canvas) const
+{
+    CanvasesMap::const_iterator it = _get_canvas(canvas);
+    return (it != m_canvases.end()) ? it->second->get_mouse_position() : Pointf();
+}
+
+void GLCanvas3DManager::set_mouse_position(wxGLCanvas* canvas, const Pointf& position)
+{
+    CanvasesMap::iterator it = _get_canvas(canvas);
+    if (it != m_canvases.end())
+        it->second->set_mouse_position(position);
+}
+
 void GLCanvas3DManager::zoom_to_bed(wxGLCanvas* canvas)
 {
     CanvasesMap::iterator it = _get_canvas(canvas);
@@ -518,11 +541,11 @@ void GLCanvas3DManager::register_on_viewport_changed_callback(wxGLCanvas* canvas
         it->second->register_on_viewport_changed_callback(callback);
 }
 
-void GLCanvas3DManager::register_on_mark_volumes_for_layer_height(wxGLCanvas* canvas, void* callback)
+void GLCanvas3DManager::register_on_mark_volumes_for_layer_height_callback(wxGLCanvas* canvas, void* callback)
 {
     CanvasesMap::iterator it = _get_canvas(canvas);
     if (it != m_canvases.end())
-        it->second->register_on_mark_volumes_for_layer_height(callback);
+        it->second->register_on_mark_volumes_for_layer_height_callback(callback);
 }
 
 GLCanvas3DManager::CanvasesMap::iterator GLCanvas3DManager::_get_canvas(wxGLCanvas* canvas)

xs/src/slic3r/GUI/GLCanvas3DManager.hpp

@@ -100,7 +100,7 @@ public:
     void set_camera_distance(wxGLCanvas* canvas, float distance);
 
     Pointf3 get_camera_target(wxGLCanvas* canvas) const;
-    void set_camera_target(wxGLCanvas* canvas, const Pointf3* target);
+    void set_camera_target(wxGLCanvas* canvas, const Pointf3& target);
 
     bool is_layers_editing_enabled(wxGLCanvas* canvas) const;
     bool is_picking_enabled(wxGLCanvas* canvas) const;
@@ -111,6 +111,12 @@ public:
     void enable_picking(wxGLCanvas* canvas, bool enable);
     void enable_shader(wxGLCanvas* canvas, bool enable);
 
+    bool is_mouse_dragging(wxGLCanvas* canvas) const;
+    void set_mouse_dragging(wxGLCanvas* canvas, bool dragging);
+
+    Pointf get_mouse_position(wxGLCanvas* canvas) const;
+    void set_mouse_position(wxGLCanvas* canvas, const Pointf& position);
+
     void zoom_to_bed(wxGLCanvas* canvas);
     void zoom_to_volumes(wxGLCanvas* canvas);
     void select_view(wxGLCanvas* canvas, const std::string& direction);
@@ -130,7 +136,7 @@ public:
     void render_texture(wxGLCanvas* canvas, unsigned int tex_id, float left, float right, float bottom, float top) const;
 
     void register_on_viewport_changed_callback(wxGLCanvas* canvas, void* callback);
-    void register_on_mark_volumes_for_layer_height(wxGLCanvas* canvas, void* callback);
+    void register_on_mark_volumes_for_layer_height_callback(wxGLCanvas* canvas, void* callback);
 
 private:
     CanvasesMap::iterator _get_canvas(wxGLCanvas* canvas);

xs/xsp/GUI_3DScene.xsp

@@ -483,6 +483,36 @@ enable_shader(canvas, enable)
     CODE:
         _3DScene::enable_shader((wxGLCanvas*)wxPli_sv_2_object(aTHX_ canvas, "Wx::GLCanvas"), enable);
 
+bool
+is_mouse_dragging(canvas)
+        SV *canvas;
+    CODE:
+        RETVAL = _3DScene::is_mouse_dragging((wxGLCanvas*)wxPli_sv_2_object(aTHX_ canvas, "Wx::GLCanvas"));
+    OUTPUT:
+        RETVAL
+
+void
+set_mouse_dragging(canvas, dragging)
+        SV   *canvas;
+        bool dragging;
+    CODE:
+        _3DScene::set_mouse_dragging((wxGLCanvas*)wxPli_sv_2_object(aTHX_ canvas, "Wx::GLCanvas"), dragging);
+
+Clone<Pointf>
+get_mouse_position(canvas)
+        SV *canvas;
+    CODE:
+        RETVAL = _3DScene::get_mouse_position((wxGLCanvas*)wxPli_sv_2_object(aTHX_ canvas, "Wx::GLCanvas"));
+    OUTPUT:
+        RETVAL
+
+void
+set_mouse_position(canvas, position)
+        SV     *canvas;
+        Pointf *position;
+    CODE:
+        _3DScene::set_mouse_position((wxGLCanvas*)wxPli_sv_2_object(aTHX_ canvas, "Wx::GLCanvas"), position);
+
 void
 zoom_to_bed(canvas)
         SV *canvas;
@@ -585,11 +615,11 @@ register_on_viewport_changed_callback(canvas, callback)
         _3DScene::register_on_viewport_changed_callback((wxGLCanvas*)wxPli_sv_2_object(aTHX_ canvas, "Wx::GLCanvas"), (void*)callback);
     
 void
-register_on_mark_volumes_for_layer_height(canvas, callback)
+register_on_mark_volumes_for_layer_height_callback(canvas, callback)
         SV *canvas;
         SV *callback;
     CODE:
-        _3DScene::register_on_mark_volumes_for_layer_height((wxGLCanvas*)wxPli_sv_2_object(aTHX_ canvas, "Wx::GLCanvas"), (void*)callback);
+        _3DScene::register_on_mark_volumes_for_layer_height_callback((wxGLCanvas*)wxPli_sv_2_object(aTHX_ canvas, "Wx::GLCanvas"), (void*)callback);