3DScene::Resize() method moved to c++

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

@@ -1742,6 +1742,36 @@ void _3DScene::remove_all_canvases()
     s_canvas_mgr.remove_all();
 }
 
+void _3DScene::resize(wxGLCanvas* canvas, unsigned int w, unsigned int h)
+{
+    s_canvas_mgr.resize(canvas, w, h);
+}
+
+bool _3DScene::is_shown_on_screen(wxGLCanvas* canvas)
+{
+    return s_canvas_mgr.is_shown_on_screen(canvas);
+}
+
+GLVolumeCollection* _3DScene::get_volumes(wxGLCanvas* canvas)
+{
+    return s_canvas_mgr.get_volumes(canvas);
+}
+
+void _3DScene::set_volumes(wxGLCanvas* canvas, GLVolumeCollection* volumes)
+{
+    s_canvas_mgr.set_volumes(canvas, volumes);
+}
+
+void _3DScene::set_bed_shape(wxGLCanvas* canvas, const Pointfs& shape)
+{
+    return s_canvas_mgr.set_bed_shape(canvas, shape);
+}
+
+BoundingBoxf3 _3DScene::get_max_bounding_box(wxGLCanvas* canvas)
+{
+    return s_canvas_mgr.get_max_bounding_box(canvas);
+}
+
 bool _3DScene::is_dirty(wxGLCanvas* canvas)
 {
     return s_canvas_mgr.is_dirty(canvas);
@@ -1752,11 +1782,6 @@ void _3DScene::set_dirty(wxGLCanvas* canvas, bool dirty)
     s_canvas_mgr.set_dirty(canvas, dirty);
 }
 
-bool _3DScene::is_shown_on_screen(wxGLCanvas* canvas)
-{
-    return s_canvas_mgr.is_shown_on_screen(canvas);
-}
-
 unsigned int _3DScene::get_camera_type(wxGLCanvas* canvas)
 {
     return s_canvas_mgr.get_camera_type(canvas);

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

@@ -542,11 +542,20 @@ public:
     static bool remove_canvas(wxGLCanvas* canvas);
     static void remove_all_canvases();
 
-    static bool is_dirty(wxGLCanvas* canvas);
-    static void set_dirty(wxGLCanvas* canvas, bool dirty);
+    static void resize(wxGLCanvas* canvas, unsigned int w, unsigned int h);
 
     static bool is_shown_on_screen(wxGLCanvas* canvas);
 
+    static GLVolumeCollection* get_volumes(wxGLCanvas* canvas);
+    static void set_volumes(wxGLCanvas* canvas, GLVolumeCollection* volumes);
+
+    static void set_bed_shape(wxGLCanvas* canvas, const Pointfs& shape);
+
+    static BoundingBoxf3 get_max_bounding_box(wxGLCanvas* canvas);
+
+    static bool is_dirty(wxGLCanvas* canvas);
+    static void set_dirty(wxGLCanvas* canvas, bool dirty);
+
     static unsigned int get_camera_type(wxGLCanvas* canvas);
     static void set_camera_type(wxGLCanvas* canvas, unsigned int type);
     static std::string get_camera_type_as_string(wxGLCanvas* canvas);

xs/src/slic3r/GUI/GLCanvas3D.cpp

@@ -1,5 +1,7 @@
 #include "GLCanvas3D.hpp"
 
+#include "../../slic3r/GUI/3DScene.hpp"
+
 #include <wx/glcanvas.h>
 
 #include <iostream>
@@ -100,10 +102,37 @@ void GLCanvas3D::Camera::set_target(const Pointf3& target)
     m_target = target;
 }
 
+const Pointfs& GLCanvas3D::Bed::get_shape() const
+{
+    return m_shape;
+}
+
+void GLCanvas3D::Bed::set_shape(const Pointfs& shape)
+{
+    m_shape = shape;
+    _calc_bounding_box();
+}
+
+const BoundingBoxf3& GLCanvas3D::Bed::get_bounding_box() const
+{
+    return m_bounding_box;
+}
+
+void GLCanvas3D::Bed::_calc_bounding_box()
+{
+    m_bounding_box = BoundingBoxf3();
+    for (const Pointf& p : m_shape)
+    {
+        m_bounding_box.merge(Pointf3(p.x, p.y, 0.0));
+    }
+}
+
 GLCanvas3D::GLCanvas3D(wxGLCanvas* canvas, wxGLContext* context)
     : m_canvas(canvas)
     , m_context(context)
+    , m_volumes(nullptr)
     , m_dirty(true)
+    , m_apply_zoom_to_volumes_filter(false)
 {
 }
 
@@ -113,6 +142,94 @@ void GLCanvas3D::set_current()
         m_canvas->SetCurrent(*m_context);
 }
 
+bool GLCanvas3D::is_shown_on_screen() const
+{
+    return (m_canvas != nullptr) ? m_canvas->IsShownOnScreen() : false;
+}
+
+void GLCanvas3D::resize(unsigned int w, unsigned int h)
+{
+    if (m_context == nullptr)
+        return;
+    
+    set_current();
+    ::glViewport(0, 0, w, h);
+
+    ::glMatrixMode(GL_PROJECTION);
+    ::glLoadIdentity();
+
+    BoundingBoxf3 bbox = max_bounding_box();
+
+    switch (get_camera_type())
+    {
+    case Camera::CT_Ortho:
+        {
+            float w2 = w;
+            float h2 = h;
+            float two_zoom = 2.0f * get_camera_zoom();
+            if (two_zoom != 0.0f)
+            {
+                float inv_two_zoom = 1.0f / two_zoom;
+                w2 *= inv_two_zoom;
+                h2 *= inv_two_zoom;
+            }
+
+            // FIXME: calculate a tighter value for depth will improve z-fighting
+            Pointf3 bb_size = bbox.size();
+            float depth = 5.0f * (float)std::max(bb_size.x, std::max(bb_size.y, bb_size.z));
+            ::glOrtho(-w2, w2, -h2, h2, -depth, depth);
+
+            break;
+        }
+    case Camera::CT_Perspective:
+        {
+            float bbox_r = (float)bbox.radius();
+            float fov = PI * 45.0f / 180.0f;
+            float fov_tan = tan(0.5f * fov);
+            float cam_distance = 0.5f * bbox_r / fov_tan;
+            set_camera_distance(cam_distance);
+
+            float nr = cam_distance - bbox_r * 1.1f;
+            float fr = cam_distance + bbox_r * 1.1f;
+            if (nr < 1.0f)
+                nr = 1.0f;
+
+            if (fr < nr + 1.0f)
+                fr = nr + 1.0f;
+
+            float h2 = fov_tan * nr;
+            float w2 = h2 * w / h;
+            ::glFrustum(-w2, w2, -h2, h2, nr, fr);
+
+            break;
+        }
+    default:
+        {
+            throw std::runtime_error("Invalid camera type.");
+            break;
+        }
+    }
+
+    ::glMatrixMode(GL_MODELVIEW);
+
+    set_dirty(false);
+}
+
+GLVolumeCollection* GLCanvas3D::get_volumes()
+{
+    return m_volumes;
+}
+
+void GLCanvas3D::set_volumes(GLVolumeCollection* volumes)
+{
+    m_volumes = volumes;
+}
+
+void GLCanvas3D::set_bed_shape(const Pointfs& shape)
+{
+    m_bed.set_shape(shape);
+}
+
 bool GLCanvas3D::is_dirty() const
 {
     return m_dirty;
@@ -123,11 +240,6 @@ void GLCanvas3D::set_dirty(bool dirty)
     m_dirty = dirty;
 }
 
-bool GLCanvas3D::is_shown_on_screen() const
-{
-    return (m_canvas != nullptr) ? m_canvas->IsShownOnScreen() : false;
-}
-
 GLCanvas3D::Camera::EType GLCanvas3D::get_camera_type() const
 {
     return m_camera.get_type();
@@ -200,5 +312,48 @@ void GLCanvas3D::on_size(wxSizeEvent& evt)
     set_dirty(true);
 }
 
+BoundingBoxf3 GLCanvas3D::bed_bounding_box() const
+{
+    return m_bed.get_bounding_box();
+}
+
+BoundingBoxf3 GLCanvas3D::volumes_bounding_box() const
+{
+    BoundingBoxf3 bb;
+    if (m_volumes != nullptr)
+    {
+        for (const GLVolume* volume : m_volumes->volumes)
+        {
+            if (!m_apply_zoom_to_volumes_filter || ((volume != nullptr) && volume->zoom_to_volumes))
+                bb.merge(volume->transformed_bounding_box());
+        }
+    }
+    return bb;
+}
+
+BoundingBoxf3 GLCanvas3D::max_bounding_box() const
+{
+    BoundingBoxf3 bb = bed_bounding_box();
+    bb.merge(volumes_bounding_box());
+    return bb;
+}
+
+void GLCanvas3D::_zoom_to_bed()
+{
+    _zoom_to_bounding_box(bed_bounding_box());
+}
+
+void GLCanvas3D::_zoom_to_volumes()
+{
+    m_apply_zoom_to_volumes_filter = true;
+    _zoom_to_bounding_box(volumes_bounding_box());
+    m_apply_zoom_to_volumes_filter = false;
+}
+
+void GLCanvas3D::_zoom_to_bounding_box(const BoundingBoxf3& bbox)
+{
+    // >>>>>>>>>>>>>>>>>>>> TODO <<<<<<<<<<<<<<<<<<<<<<<<
+}
+
 } // namespace GUI
 } // namespace Slic3r

xs/src/slic3r/GUI/GLCanvas3D.hpp

@@ -1,13 +1,16 @@
 #ifndef slic3r_GLCanvas3D_hpp_
 #define slic3r_GLCanvas3D_hpp_
 
-#include "../../libslic3r/Point.hpp"
+#include "../../libslic3r/BoundingBox.hpp"
 
 class wxGLCanvas;
 class wxGLContext;
 class wxSizeEvent;
 
 namespace Slic3r {
+
+class GLVolumeCollection;
+
 namespace GUI {
 
 class GLCanvas3D
@@ -55,23 +58,49 @@ public:
         void set_target(const Pointf3& target);
     };
 
+    class Bed
+    {
+        Pointfs m_shape;
+        BoundingBoxf3 m_bounding_box;
+
+    public:
+        const Pointfs& get_shape() const;
+        void set_shape(const Pointfs& shape);
+
+        const BoundingBoxf3& get_bounding_box() const;
+
+    private:
+        void _calc_bounding_box();
+    };
+
 private:
     wxGLCanvas* m_canvas;
     wxGLContext* m_context;
     Camera m_camera;
+    Bed m_bed;
+
+    GLVolumeCollection* m_volumes;
 
     bool m_dirty;
+    bool m_apply_zoom_to_volumes_filter;
 
 public:
     GLCanvas3D(wxGLCanvas* canvas, wxGLContext* context);
 
     void set_current();
 
+    bool is_shown_on_screen() const;
+
+    void resize(unsigned int w, unsigned int h);
+
+    GLVolumeCollection* get_volumes();
+    void set_volumes(GLVolumeCollection* volumes);
+
+    void set_bed_shape(const Pointfs& shape);
+
     bool is_dirty() const;
     void set_dirty(bool dirty);
 
-    bool is_shown_on_screen() const;
-
     Camera::EType get_camera_type() const;
     void set_camera_type(Camera::EType type);
     std::string get_camera_type_as_string() const;
@@ -92,6 +121,15 @@ public:
     void set_camera_target(const Pointf3& target);
 
     void on_size(wxSizeEvent& evt);
+
+    BoundingBoxf3 bed_bounding_box() const;
+    BoundingBoxf3 volumes_bounding_box() const;
+    BoundingBoxf3 max_bounding_box() const;
+
+private:
+    void _zoom_to_bed();
+    void _zoom_to_volumes();
+    void _zoom_to_bounding_box(const BoundingBoxf3& bbox);
 };
 
 } // namespace GUI

xs/src/slic3r/GUI/GLCanvas3DManager.cpp

@@ -146,6 +146,45 @@ bool GLCanvas3DManager::layer_editing_allowed() const
     return m_layer_editing.allowed;
 }
 
+bool GLCanvas3DManager::is_shown_on_screen(wxGLCanvas* canvas) const
+{
+    CanvasesMap::const_iterator it = _get_canvas(canvas);
+    return (it != m_canvases.end()) ? it->second->is_shown_on_screen() : false;
+}
+
+void GLCanvas3DManager::resize(wxGLCanvas* canvas, unsigned int w, unsigned int h)
+{
+    CanvasesMap::iterator it = _get_canvas(canvas);
+    if (it != m_canvases.end())
+        it->second->resize(w, h);
+}
+
+GLVolumeCollection* GLCanvas3DManager::get_volumes(wxGLCanvas* canvas)
+{
+    CanvasesMap::const_iterator it = _get_canvas(canvas);
+    return (it != m_canvases.end()) ? it->second->get_volumes() : nullptr;
+}
+
+void GLCanvas3DManager::set_volumes(wxGLCanvas* canvas, GLVolumeCollection* volumes)
+{
+    CanvasesMap::iterator it = _get_canvas(canvas);
+    if (it != m_canvases.end())
+        it->second->set_volumes(volumes);
+}
+
+void GLCanvas3DManager::set_bed_shape(wxGLCanvas* canvas, const Pointfs& shape)
+{
+    CanvasesMap::iterator it = _get_canvas(canvas);
+    if (it != m_canvases.end())
+        it->second->set_bed_shape(shape);
+}
+
+BoundingBoxf3 GLCanvas3DManager::get_max_bounding_box(wxGLCanvas* canvas)
+{
+    CanvasesMap::const_iterator it = _get_canvas(canvas);
+    return (it != m_canvases.end()) ? it->second->max_bounding_box() : BoundingBoxf3();
+}
+
 bool GLCanvas3DManager::is_dirty(wxGLCanvas* canvas) const
 {
     CanvasesMap::const_iterator it = _get_canvas(canvas);
@@ -159,12 +198,6 @@ void GLCanvas3DManager::set_dirty(wxGLCanvas* canvas, bool dirty)
         it->second->set_dirty(dirty);
 }
 
-bool GLCanvas3DManager::is_shown_on_screen(wxGLCanvas* canvas) const
-{
-    CanvasesMap::const_iterator it = _get_canvas(canvas);
-    return (it != m_canvases.end()) ? it->second->is_shown_on_screen() : false;
-}
-
 unsigned int GLCanvas3DManager::get_camera_type(wxGLCanvas* canvas) const
 {
     CanvasesMap::const_iterator it = _get_canvas(canvas);

xs/src/slic3r/GUI/GLCanvas3DManager.hpp

@@ -52,11 +52,20 @@ public:
     bool use_VBOs() const;
     bool layer_editing_allowed() const;
 
+    bool is_shown_on_screen(wxGLCanvas* canvas) const;
+
+    void resize(wxGLCanvas* canvas, unsigned int w, unsigned int h);
+
+    GLVolumeCollection* get_volumes(wxGLCanvas* canvas);
+    void set_volumes(wxGLCanvas* canvas, GLVolumeCollection* volumes);
+
+    void set_bed_shape(wxGLCanvas* canvas, const Pointfs& shape);
+
+    BoundingBoxf3 get_max_bounding_box(wxGLCanvas* canvas);
+
     bool is_dirty(wxGLCanvas* canvas) const;
     void set_dirty(wxGLCanvas* canvas, bool dirty);
 
-    bool is_shown_on_screen(wxGLCanvas* canvas) const;
-
     unsigned int get_camera_type(wxGLCanvas* canvas) const;
     void set_camera_type(wxGLCanvas* canvas, unsigned int type);
     std::string get_camera_type_as_string(wxGLCanvas* canvas) const;

xs/xsp/GUI_3DScene.xsp

@@ -185,6 +185,44 @@ remove_all_canvases()
     CODE:
         _3DScene::remove_all_canvases();
 
+void
+resize(canvas, w, h)
+        SV           *canvas;
+        unsigned int w;
+        unsigned int h;
+    CODE:
+        _3DScene::resize((wxGLCanvas*)wxPli_sv_2_object(aTHX_ canvas, "Wx::GLCanvas"), w, h);
+        
+GLVolumeCollection*
+get_volumes(canvas)
+        SV *canvas;
+    CODE:
+        RETVAL = _3DScene::get_volumes((wxGLCanvas*)wxPli_sv_2_object(aTHX_ canvas, "Wx::GLCanvas"));
+    OUTPUT:
+        RETVAL
+
+void
+set_volumes(canvas, volumes)
+        SV                 *canvas;
+        GLVolumeCollection *volumes;
+    CODE:
+        _3DScene::set_volumes((wxGLCanvas*)wxPli_sv_2_object(aTHX_ canvas, "Wx::GLCanvas"), volumes);
+        
+void
+set_bed_shape(canvas, shape)
+        SV      *canvas;
+        Pointfs shape;
+    CODE:
+        _3DScene::set_bed_shape((wxGLCanvas*)wxPli_sv_2_object(aTHX_ canvas, "Wx::GLCanvas"), shape);
+        
+Clone<BoundingBoxf3>
+get_max_bounding_box(canvas)
+        SV *canvas;
+    CODE:
+        RETVAL = _3DScene::get_max_bounding_box((wxGLCanvas*)wxPli_sv_2_object(aTHX_ canvas, "Wx::GLCanvas"));
+    OUTPUT:
+        RETVAL
+        
 bool
 is_dirty(canvas)
         SV *canvas;