1st installment of ModelInstance 3D scale components

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

@@ -201,7 +201,11 @@ GLVolume::GLVolume(float r, float g, float b, float a)
 #else
     , m_rotation(0.0)
 #endif // ENABLE_MODELINSTANCE_3D_ROTATION
+#if ENABLE_MODELINSTANCE_3D_SCALE
+    , m_scaling_factor(Vec3d::Ones())
+#else
     , m_scaling_factor(1.0)
+#endif // ENABLE_MODELINSTANCE_3D_SCALE
     , m_world_matrix(Transform3f::Identity())
     , m_world_matrix_dirty(true)
     , m_transformed_bounding_box_dirty(true)
@@ -309,6 +313,18 @@ void GLVolume::set_offset(const Vec3d& offset)
     }
 }
 
+#if ENABLE_MODELINSTANCE_3D_SCALE
+void GLVolume::set_scaling_factor(const Vec3d& scaling_factor)
+{
+    if (m_scaling_factor != scaling_factor)
+    {
+        m_scaling_factor = scaling_factor;
+        m_world_matrix_dirty = true;
+        m_transformed_bounding_box_dirty = true;
+        m_transformed_convex_hull_bounding_box_dirty = true;
+    }
+}
+#else
 void GLVolume::set_scaling_factor(double factor)
 {
     if (m_scaling_factor != factor)
@@ -319,6 +335,7 @@ void GLVolume::set_scaling_factor(double factor)
         m_transformed_convex_hull_bounding_box_dirty = true;
     }
 }
+#endif // ENABLE_MODELINSTANCE_3D_SCALE
 
 void GLVolume::set_convex_hull(const TriangleMesh& convex_hull)
 {
@@ -356,7 +373,11 @@ const Transform3f& GLVolume::world_matrix() const
 #else
         m_world_matrix.rotate(Eigen::AngleAxisf((float)m_rotation, Vec3f::UnitZ()));
 #endif // ENABLE_MODELINSTANCE_3D_ROTATION
+#if ENABLE_MODELINSTANCE_3D_SCALE
+        m_world_matrix.scale(m_scaling_factor.cast<float>());
+#else
         m_world_matrix.scale((float)m_scaling_factor);
+#endif // ENABLE_MODELINSTANCE_3D_SCALE
         m_world_matrix_dirty = false;
     }
     return m_world_matrix;
@@ -438,7 +459,11 @@ void GLVolume::render() const
 #else
     ::glRotated(m_rotation * 180.0 / (double)PI, 0.0, 0.0, 1.0);
 #endif // ENABLE_MODELINSTANCE_3D_ROTATION
+#if ENABLE_MODELINSTANCE_3D_SCALE
+    ::glScaled(m_scaling_factor(0), m_scaling_factor(1), m_scaling_factor(2));
+#else
     ::glScaled(m_scaling_factor, m_scaling_factor, m_scaling_factor);
+#endif // ENABLE_MODELINSTANCE_3D_SCALE
     if (this->indexed_vertex_array.indexed())
         this->indexed_vertex_array.render(this->tverts_range, this->qverts_range);
     else
@@ -570,7 +595,11 @@ void GLVolume::render_VBOs(int color_id, int detection_id, int worldmatrix_id) c
 #else
     ::glRotated(m_rotation * 180.0 / (double)PI, 0.0, 0.0, 1.0);
 #endif // ENABLE_MODELINSTANCE_3D_ROTATION
+#if ENABLE_MODELINSTANCE_3D_SCALE
+    ::glScaled(m_scaling_factor(0), m_scaling_factor(1), m_scaling_factor(2));
+#else
     ::glScaled(m_scaling_factor, m_scaling_factor, m_scaling_factor);
+#endif // ENABLE_MODELINSTANCE_3D_SCALE
 
     if (n_triangles > 0)
     {
@@ -621,7 +650,11 @@ void GLVolume::render_legacy() const
 #else
     ::glRotated(m_rotation * 180.0 / (double)PI, 0.0, 0.0, 1.0);
 #endif // ENABLE_MODELINSTANCE_3D_ROTATION
+#if ENABLE_MODELINSTANCE_3D_SCALE
+    ::glScaled(m_scaling_factor(0), m_scaling_factor(1), m_scaling_factor(2));
+#else
     ::glScaled(m_scaling_factor, m_scaling_factor, m_scaling_factor);
+#endif // ENABLE_MODELINSTANCE_3D_SCALE
 
     if (n_triangles > 0)
         ::glDrawElements(GL_TRIANGLES, n_triangles, GL_UNSIGNED_INT, indexed_vertex_array.triangle_indices.data() + tverts_range.first);
@@ -749,7 +782,11 @@ std::vector<int> GLVolumeCollection::load_object(
 #else
             v.set_rotation(instance->rotation);
 #endif // ENABLE_MODELINSTANCE_3D_ROTATION
+#if ENABLE_MODELINSTANCE_3D_SCALE
+            v.set_scaling_factor(instance->get_scaling_factor());
+#else
             v.set_scaling_factor(instance->scaling_factor);
+#endif // ENABLE_MODELINSTANCE_3D_SCALE
         }
     }
     
@@ -2112,7 +2149,16 @@ void _3DScene::register_on_enable_action_buttons_callback(wxGLCanvas* canvas, vo
 
 void _3DScene::register_on_gizmo_scale_uniformly_callback(wxGLCanvas* canvas, void* callback)
 {
+#if !ENABLE_MODELINSTANCE_3D_SCALE
     s_canvas_mgr.register_on_gizmo_scale_uniformly_callback(canvas, callback);
+#endif // !ENABLE_MODELINSTANCE_3D_SCALE
+}
+
+void _3DScene::register_on_gizmo_scale_3D_callback(wxGLCanvas* canvas, void* callback)
+{
+#if ENABLE_MODELINSTANCE_3D_SCALE
+    s_canvas_mgr.register_on_gizmo_scale_3D_callback(canvas, callback);
+#endif // ENABLE_MODELINSTANCE_3D_SCALE
 }
 
 void _3DScene::register_on_gizmo_rotate_callback(wxGLCanvas* canvas, void* callback)
@@ -2145,7 +2191,16 @@ void _3DScene::register_on_gizmo_flatten_3D_callback(wxGLCanvas* canvas, void* c
 
 void _3DScene::register_on_update_geometry_info_callback(wxGLCanvas* canvas, void* callback)
 {
+#if !ENABLE_MODELINSTANCE_3D_SCALE
     s_canvas_mgr.register_on_update_geometry_info_callback(canvas, callback);
+#endif // !ENABLE_MODELINSTANCE_3D_SCALE
+}
+
+void _3DScene::register_on_update_geometry_3D_info_callback(wxGLCanvas* canvas, void* callback)
+{
+#if ENABLE_MODELINSTANCE_3D_SCALE
+    s_canvas_mgr.register_on_update_geometry_3D_info_callback(canvas, callback);
+#endif // ENABLE_MODELINSTANCE_3D_SCALE
 }
 
 void _3DScene::register_action_add_callback(wxGLCanvas* canvas, void* callback)

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

@@ -263,8 +263,13 @@ private:
     // Rotation around Z axis of the volume to be rendered.
     double                m_rotation;
 #endif // ENABLE_MODELINSTANCE_3D_ROTATION
+#if ENABLE_MODELINSTANCE_3D_SCALE
+    // Scale factor along the three axes of the volume to be rendered.
+    Vec3d                 m_scaling_factor;
+#else
     // Scale factor of the volume to be rendered.
     double                m_scaling_factor;
+#endif // ENABLE_MODELINSTANCE_3D_SCALE
     // World matrix of the volume to be rendered.
     mutable Transform3f   m_world_matrix;
     // Whether or not is needed to recalculate the world matrix.
@@ -343,7 +348,11 @@ public:
     const Vec3d& get_offset() const;
     void set_offset(const Vec3d& offset);
 
+#if ENABLE_MODELINSTANCE_3D_SCALE
+    void set_scaling_factor(const Vec3d& scaling_factor);
+#else
     void set_scaling_factor(double factor);
+#endif // ENABLE_MODELINSTANCE_3D_SCALE
 
     void set_convex_hull(const TriangleMesh& convex_hull);
 
@@ -567,11 +576,13 @@ public:
     static void register_on_wipe_tower_moved_callback(wxGLCanvas* canvas, void* callback);
     static void register_on_enable_action_buttons_callback(wxGLCanvas* canvas, void* callback);
     static void register_on_gizmo_scale_uniformly_callback(wxGLCanvas* canvas, void* callback);
+    static void register_on_gizmo_scale_3D_callback(wxGLCanvas* canvas, void* callback);
     static void register_on_gizmo_rotate_callback(wxGLCanvas* canvas, void* callback);
     static void register_on_gizmo_rotate_3D_callback(wxGLCanvas* canvas, void* callback);
     static void register_on_gizmo_flatten_callback(wxGLCanvas* canvas, void* callback);
     static void register_on_gizmo_flatten_3D_callback(wxGLCanvas* canvas, void* callback);
     static void register_on_update_geometry_info_callback(wxGLCanvas* canvas, void* callback);
+    static void register_on_update_geometry_3D_info_callback(wxGLCanvas* canvas, void* callback);
 
     static void register_action_add_callback(wxGLCanvas* canvas, void* callback);
     static void register_action_delete_callback(wxGLCanvas* canvas, void* callback);

xs/src/slic3r/GUI/GLCanvas3D.cpp

@@ -1159,6 +1159,7 @@ bool GLCanvas3D::Gizmos::init(GLCanvas3D& parent)
     if (!gizmo->init())
         return false;
 
+#if !ENABLE_MODELINSTANCE_3D_SCALE
     // temporary disable x grabbers
     gizmo->disable_grabber(0);
     gizmo->disable_grabber(1);
@@ -1168,6 +1169,7 @@ bool GLCanvas3D::Gizmos::init(GLCanvas3D& parent)
     // temporary disable z grabbers
     gizmo->disable_grabber(4);
     gizmo->disable_grabber(5);
+#endif // !ENABLE_MODELINSTANCE_3D_SCALE
 
     m_gizmos.insert(GizmosMap::value_type(Scale, gizmo));
 
@@ -1419,6 +1421,26 @@ void GLCanvas3D::Gizmos::set_position(const Vec3d& position)
         reinterpret_cast<GLGizmoMove3D*>(it->second)->set_position(position);
 }
 
+#if ENABLE_MODELINSTANCE_3D_SCALE
+Vec3d GLCanvas3D::Gizmos::get_scale() const
+{
+    if (!m_enabled)
+        return Vec3d::Ones();
+
+    GizmosMap::const_iterator it = m_gizmos.find(Scale);
+    return (it != m_gizmos.end()) ? reinterpret_cast<GLGizmoScale3D*>(it->second)->get_scale() : Vec3d::Ones();
+}
+
+void GLCanvas3D::Gizmos::set_scale(const Vec3d& scale)
+{
+    if (!m_enabled)
+        return;
+
+    GizmosMap::const_iterator it = m_gizmos.find(Scale);
+    if (it != m_gizmos.end())
+        reinterpret_cast<GLGizmoScale3D*>(it->second)->set_scale(scale);
+}
+#else
 float GLCanvas3D::Gizmos::get_scale() const
 {
     if (!m_enabled)
@@ -1437,6 +1459,7 @@ void GLCanvas3D::Gizmos::set_scale(float scale)
     if (it != m_gizmos.end())
         reinterpret_cast<GLGizmoScale3D*>(it->second)->set_scale(scale);
 }
+#endif // ENABLE_MODELINSTANCE_3D_SCALE
 
 #if ENABLE_MODELINSTANCE_3D_ROTATION
 Vec3d GLCanvas3D::Gizmos::get_rotation() const
@@ -2431,7 +2454,11 @@ void GLCanvas3D::update_gizmos_data()
 #else
                 m_gizmos.set_position(Vec3d(model_instance->offset(0), model_instance->offset(1), 0.0));
 #endif // ENABLE_MODELINSTANCE_3D_OFFSET
+#if ENABLE_MODELINSTANCE_3D_SCALE
+                m_gizmos.set_scale(model_instance->get_scaling_factor());
+#else
                 m_gizmos.set_scale(model_instance->scaling_factor);
+#endif // ENABLE_MODELINSTANCE_3D_SCALE
 #if ENABLE_MODELINSTANCE_3D_ROTATION
                 m_gizmos.set_rotation(model_instance->get_rotation());
 #else
@@ -2444,7 +2471,11 @@ void GLCanvas3D::update_gizmos_data()
     else
     {
         m_gizmos.set_position(Vec3d::Zero());
+#if ENABLE_MODELINSTANCE_3D_SCALE
+        m_gizmos.set_scale(Vec3d::Ones());
+#else
         m_gizmos.set_scale(1.0f);
+#endif // ENABLE_MODELINSTANCE_3D_SCALE
 #if ENABLE_MODELINSTANCE_3D_ROTATION
         m_gizmos.set_rotation(Vec3d::Zero());
 #else
@@ -2806,11 +2837,19 @@ void GLCanvas3D::register_on_enable_action_buttons_callback(void* callback)
         m_on_enable_action_buttons_callback.register_callback(callback);
 }
 
+#if ENABLE_MODELINSTANCE_3D_SCALE
+void GLCanvas3D::register_on_gizmo_scale_3D_callback(void* callback)
+{
+    if (callback != nullptr)
+        m_on_gizmo_scale_3D_callback.register_callback(callback);
+}
+#else
 void GLCanvas3D::register_on_gizmo_scale_uniformly_callback(void* callback)
 {
     if (callback != nullptr)
         m_on_gizmo_scale_uniformly_callback.register_callback(callback);
 }
+#endif // ENABLE_MODELINSTANCE_3D_SCALE
 
 #if ENABLE_MODELINSTANCE_3D_ROTATION
 void GLCanvas3D::register_on_gizmo_rotate_3D_callback(void* callback)
@@ -2838,11 +2877,19 @@ void GLCanvas3D::register_on_gizmo_flatten_callback(void* callback)
 }
 #endif // ENABLE_MODELINSTANCE_3D_ROTATION
 
+#if ENABLE_MODELINSTANCE_3D_SCALE
+void GLCanvas3D::register_on_update_geometry_3D_info_callback(void* callback)
+{
+    if (callback != nullptr)
+        m_on_update_geometry_3D_info_callback.register_callback(callback);
+}
+#else
 void GLCanvas3D::register_on_update_geometry_info_callback(void* callback)
 {
     if (callback != nullptr)
         m_on_update_geometry_info_callback.register_callback(callback);
 }
+#endif // ENABLE_MODELINSTANCE_3D_SCALE
 
 void GLCanvas3D::register_action_add_callback(void* callback)
 {
@@ -3123,7 +3170,12 @@ void GLCanvas3D::on_mouse(wxMouseEvent& evt)
         {
         case Gizmos::Scale:
         {
+#if ENABLE_MODELINSTANCE_3D_SCALE
+            const Vec3d& scale = m_gizmos.get_scale();
+            m_on_gizmo_scale_3D_callback.call(scale(0), scale(1), scale(2));
+#else
             m_on_gizmo_scale_uniformly_callback.call((double)m_gizmos.get_scale());
+#endif // ENABLE_MODELINSTANCE_3D_SCALE
             update_scale_values();
             m_dirty = true;
             break;
@@ -3371,6 +3423,15 @@ void GLCanvas3D::on_mouse(wxMouseEvent& evt)
         }
         case Gizmos::Scale:
         {
+#if ENABLE_MODELINSTANCE_3D_SCALE
+            // Apply new temporary scale factors
+            const Vec3d& scale = m_gizmos.get_scale();
+            for (GLVolume* v : volumes)
+            {
+                v->set_scaling_factor(scale);
+            }
+            update_scale_values(scale);
+#else
             // Apply new temporary scale factor
             float scale_factor = m_gizmos.get_scale();
             for (GLVolume* v : volumes)
@@ -3378,13 +3439,14 @@ void GLCanvas3D::on_mouse(wxMouseEvent& evt)
                 v->set_scaling_factor((double)scale_factor);
             }
             update_scale_values((double)scale_factor);
+#endif // ENABLE_MODELINSTANCE_3D_SCALE
             break;
         }
         case Gizmos::Rotate:
         {
 #if ENABLE_MODELINSTANCE_3D_ROTATION
             // Apply new temporary rotation
-            Vec3d rotation = m_gizmos.get_rotation();
+            const Vec3d& rotation = m_gizmos.get_rotation();
             for (GLVolume* v : volumes)
             {
                 v->set_rotation(rotation);
@@ -3413,7 +3475,12 @@ void GLCanvas3D::on_mouse(wxMouseEvent& evt)
                 bb.merge(volume->transformed_bounding_box());
             }
             const Vec3d& size = bb.size();
+#if ENABLE_MODELINSTANCE_3D_SCALE
+            const Vec3d& scale = m_gizmos.get_scale();
+            m_on_update_geometry_3D_info_callback.call(size(0), size(1), size(2), scale(0), scale(1), scale(2));
+#else
             m_on_update_geometry_info_callback.call(size(0), size(1), size(2), m_gizmos.get_scale());
+#endif // ENABLE_MODELINSTANCE_3D_SCALE
         }
 
         m_dirty = true;
@@ -3539,7 +3606,12 @@ void GLCanvas3D::on_mouse(wxMouseEvent& evt)
             }
             case Gizmos::Scale:
             {
+#if ENABLE_MODELINSTANCE_3D_SCALE
+                const Vec3d& scale = m_gizmos.get_scale();
+                m_on_gizmo_scale_3D_callback.call(scale(0), scale(1), scale(2));
+#else
                 m_on_gizmo_scale_uniformly_callback.call((double)m_gizmos.get_scale());
+#endif // ENABLE_MODELINSTANCE_3D_SCALE
                 break;
             }
             case Gizmos::Rotate:
@@ -3995,7 +4067,11 @@ void GLCanvas3D::_deregister_callbacks()
     m_on_instance_moved_callback.deregister_callback();
     m_on_wipe_tower_moved_callback.deregister_callback();
     m_on_enable_action_buttons_callback.deregister_callback();
+#if ENABLE_MODELINSTANCE_3D_SCALE
+    m_on_gizmo_scale_3D_callback.deregister_callback();
+#else
     m_on_gizmo_scale_uniformly_callback.deregister_callback();
+#endif // ENABLE_MODELINSTANCE_3D_SCALE
 #if ENABLE_MODELINSTANCE_3D_ROTATION
     m_on_gizmo_rotate_3D_callback.deregister_callback();
     m_on_gizmo_flatten_3D_callback.deregister_callback();
@@ -4003,7 +4079,11 @@ void GLCanvas3D::_deregister_callbacks()
     m_on_gizmo_rotate_callback.deregister_callback();
     m_on_gizmo_flatten_callback.deregister_callback();
 #endif // ENABLE_MODELINSTANCE_3D_ROTATION
+#if ENABLE_MODELINSTANCE_3D_SCALE
+    m_on_update_geometry_3D_info_callback.deregister_callback();
+#else
     m_on_update_geometry_info_callback.deregister_callback();
+#endif // ENABLE_MODELINSTANCE_3D_SCALE
 
     m_action_add_callback.deregister_callback();
     m_action_delete_callback.deregister_callback();

xs/src/slic3r/GUI/GLCanvas3D.hpp

@@ -384,8 +384,13 @@ class GLCanvas3D
         Vec3d get_position() const;
         void set_position(const Vec3d& position);
 
+#if ENABLE_MODELINSTANCE_3D_SCALE
+        Vec3d get_scale() const;
+        void set_scale(const Vec3d& scale);
+#else
         float get_scale() const;
         void set_scale(float scale);
+#endif // ENABLE_MODELINSTANCE_3D_SCALE
 
 #if ENABLE_MODELINSTANCE_3D_ROTATION
         Vec3d get_rotation() const;
@@ -515,7 +520,11 @@ class GLCanvas3D
     PerlCallback m_on_instance_moved_callback;
     PerlCallback m_on_wipe_tower_moved_callback;
     PerlCallback m_on_enable_action_buttons_callback;
+#if ENABLE_MODELINSTANCE_3D_SCALE
+    PerlCallback m_on_gizmo_scale_3D_callback;
+#else
     PerlCallback m_on_gizmo_scale_uniformly_callback;
+#endif // ENABLE_MODELINSTANCE_3D_SCALE
 #if ENABLE_MODELINSTANCE_3D_ROTATION
     PerlCallback m_on_gizmo_rotate_3D_callback;
     PerlCallback m_on_gizmo_flatten_3D_callback;
@@ -523,7 +532,11 @@ class GLCanvas3D
     PerlCallback m_on_gizmo_rotate_callback;
     PerlCallback m_on_gizmo_flatten_callback;
 #endif // ENABLE_MODELINSTANCE_3D_ROTATION
+#if ENABLE_MODELINSTANCE_3D_SCALE
+    PerlCallback m_on_update_geometry_3D_info_callback;
+#else
     PerlCallback m_on_update_geometry_info_callback;
+#endif // ENABLE_MODELINSTANCE_3D_SCALE
 
     PerlCallback m_action_add_callback;
     PerlCallback m_action_delete_callback;
@@ -645,7 +658,11 @@ public:
     void register_on_instance_moved_callback(void* callback);
     void register_on_wipe_tower_moved_callback(void* callback);
     void register_on_enable_action_buttons_callback(void* callback);
+#if ENABLE_MODELINSTANCE_3D_SCALE
+    void register_on_gizmo_scale_3D_callback(void* callback);
+#else
     void register_on_gizmo_scale_uniformly_callback(void* callback);
+#endif // ENABLE_MODELINSTANCE_3D_SCALE
 #if ENABLE_MODELINSTANCE_3D_ROTATION
     void register_on_gizmo_rotate_3D_callback(void* callback);
     void register_on_gizmo_flatten_3D_callback(void* callback);
@@ -653,7 +670,11 @@ public:
     void register_on_gizmo_rotate_callback(void* callback);
     void register_on_gizmo_flatten_callback(void* callback);
 #endif // ENABLE_MODELINSTANCE_3D_ROTATION
+#if ENABLE_MODELINSTANCE_3D_SCALE
+    void register_on_update_geometry_3D_info_callback(void* callback);
+#else
     void register_on_update_geometry_info_callback(void* callback);
+#endif // ENABLE_MODELINSTANCE_3D_SCALE
 
     void register_action_add_callback(void* callback);
     void register_action_delete_callback(void* callback);

xs/src/slic3r/GUI/GLCanvas3DManager.cpp

@@ -692,12 +692,21 @@ void GLCanvas3DManager::register_on_enable_action_buttons_callback(wxGLCanvas* c
         it->second->register_on_enable_action_buttons_callback(callback);
 }
 
+#if ENABLE_MODELINSTANCE_3D_SCALE
+void GLCanvas3DManager::register_on_gizmo_scale_3D_callback(wxGLCanvas* canvas, void* callback)
+{
+    CanvasesMap::iterator it = _get_canvas(canvas);
+    if (it != m_canvases.end())
+        it->second->register_on_gizmo_scale_3D_callback(callback);
+}
+#else
 void GLCanvas3DManager::register_on_gizmo_scale_uniformly_callback(wxGLCanvas* canvas, void* callback)
 {
     CanvasesMap::iterator it = _get_canvas(canvas);
     if (it != m_canvases.end())
         it->second->register_on_gizmo_scale_uniformly_callback(callback);
 }
+#endif // ENABLE_MODELINSTANCE_3D_SCALE
 
 #if ENABLE_MODELINSTANCE_3D_ROTATION
 void GLCanvas3DManager::register_on_gizmo_rotate_3D_callback(wxGLCanvas* canvas, void* callback)
@@ -729,12 +738,21 @@ void GLCanvas3DManager::register_on_gizmo_flatten_callback(wxGLCanvas* canvas, v
 }
 #endif // ENABLE_MODELINSTANCE_3D_ROTATION
 
+#if ENABLE_MODELINSTANCE_3D_SCALE
+void GLCanvas3DManager::register_on_update_geometry_3D_info_callback(wxGLCanvas* canvas, void* callback)
+{
+    CanvasesMap::iterator it = _get_canvas(canvas);
+    if (it != m_canvases.end())
+        it->second->register_on_update_geometry_3D_info_callback(callback);
+}
+#else
 void GLCanvas3DManager::register_on_update_geometry_info_callback(wxGLCanvas* canvas, void* callback)
 {
     CanvasesMap::iterator it = _get_canvas(canvas);
     if (it != m_canvases.end())
         it->second->register_on_update_geometry_info_callback(callback);
 }
+#endif // ENABLE_MODELINSTANCE_3D_SCALE
 
 void GLCanvas3DManager::register_action_add_callback(wxGLCanvas* canvas, void* callback)
 {

xs/src/slic3r/GUI/GLCanvas3DManager.hpp

@@ -162,7 +162,11 @@ public:
     void register_on_instance_moved_callback(wxGLCanvas* canvas, void* callback);
     void register_on_wipe_tower_moved_callback(wxGLCanvas* canvas, void* callback);
     void register_on_enable_action_buttons_callback(wxGLCanvas* canvas, void* callback);
+#if ENABLE_MODELINSTANCE_3D_SCALE
+    void register_on_gizmo_scale_3D_callback(wxGLCanvas* canvas, void* callback);
+#else
     void register_on_gizmo_scale_uniformly_callback(wxGLCanvas* canvas, void* callback);
+#endif // ENABLE_MODELINSTANCE_3D_SCALE
 #if ENABLE_MODELINSTANCE_3D_ROTATION
     void register_on_gizmo_rotate_3D_callback(wxGLCanvas* canvas, void* callback);
     void register_on_gizmo_flatten_3D_callback(wxGLCanvas* canvas, void* callback);
@@ -170,7 +174,11 @@ public:
     void register_on_gizmo_rotate_callback(wxGLCanvas* canvas, void* callback);
     void register_on_gizmo_flatten_callback(wxGLCanvas* canvas, void* callback);
 #endif // ENABLE_MODELINSTANCE_3D_ROTATION
+#if ENABLE_MODELINSTANCE_3D_SCALE
+    void register_on_update_geometry_3D_info_callback(wxGLCanvas* canvas, void* callback);
+#else
     void register_on_update_geometry_info_callback(wxGLCanvas* canvas, void* callback);
+#endif // ENABLE_MODELINSTANCE_3D_SCALE
 
     void register_action_add_callback(wxGLCanvas* canvas, void* callback);
     void register_action_delete_callback(wxGLCanvas* canvas, void* callback);

xs/src/slic3r/GUI/GLGizmo.cpp

@@ -987,8 +987,11 @@ void GLGizmoScale3D::do_scale_y(const Linef3& mouse_ray)
     double ratio = calc_ratio(2, mouse_ray, m_starting_box.center());
 
     if (ratio > 0.0)
-        m_scale(0) = m_starting_scale(1) * ratio; // << this is temporary
-//        m_scale(1) = m_starting_scale(1) * ratio;
+#if ENABLE_MODELINSTANCE_3D_SCALE
+        m_scale(1) = m_starting_scale(1) * ratio;
+#else
+        m_scale(0) = m_starting_scale(1) * ratio;
+#endif // ENABLE_MODELINSTANCE_3D_SCALE
 }
 
 void GLGizmoScale3D::do_scale_z(const Linef3& mouse_ray)
@@ -996,8 +999,11 @@ void GLGizmoScale3D::do_scale_z(const Linef3& mouse_ray)
     double ratio = calc_ratio(1, mouse_ray, m_starting_box.center());
 
     if (ratio > 0.0)
+#if ENABLE_MODELINSTANCE_3D_SCALE
+        m_scale(2) = m_starting_scale(2) * ratio;
+#else
         m_scale(0) = m_starting_scale(2) * ratio; // << this is temporary
-//        m_scale(2) = m_starting_scale(2) * ratio;
+#endif // ENABLE_MODELINSTANCE_3D_SCALE
 }
 
 void GLGizmoScale3D::do_scale_uniform(const Linef3& mouse_ray)
@@ -1276,7 +1282,11 @@ void GLGizmoFlatten::on_render(const BoundingBoxf3& box) const
             ::glRotated(inst.rotation(2) * 180.0 / (double)PI, 0.0, 0.0, 1.0);
             ::glRotated(inst.rotation(1) * 180.0 / (double)PI, 0.0, 1.0, 0.0);
             ::glRotated(inst.rotation(0) * 180.0 / (double)PI, 1.0, 0.0, 0.0);
+#if ENABLE_MODELINSTANCE_3D_SCALE
+            ::glScaled(inst.scaling_factor(0), inst.scaling_factor(1), inst.scaling_factor(2));
+#else
             ::glScaled(inst.scaling_factor, inst.scaling_factor, inst.scaling_factor);
+#endif // ENABLE_MODELINSTANCE_3D_SCALE
 #else
             ::glTranslated(offset(0), offset(1), offset(2));
 #endif // ENABLE_MODELINSTANCE_3D_ROTATION
@@ -1317,7 +1327,11 @@ void GLGizmoFlatten::on_render_for_picking(const BoundingBoxf3& box) const
             ::glRotated(inst.rotation(2) * 180.0 / (double)PI, 0.0, 0.0, 1.0);
             ::glRotated(inst.rotation(1) * 180.0 / (double)PI, 0.0, 1.0, 0.0);
             ::glRotated(inst.rotation(0) * 180.0 / (double)PI, 1.0, 0.0, 0.0);
+#if ENABLE_MODELINSTANCE_3D_SCALE
+            ::glScaled(inst.scaling_factor(0), inst.scaling_factor(1), inst.scaling_factor(2));
+#else
             ::glScaled(inst.scaling_factor, inst.scaling_factor, inst.scaling_factor);
+#endif // ENABLE_MODELINSTANCE_3D_SCALE
 #else
             ::glTranslated(offset(0), offset(1), offset(2));
 #endif // ENABLE_MODELINSTANCE_3D_ROTATION
@@ -1347,7 +1361,11 @@ void GLGizmoFlatten::set_flattening_data(const ModelObject* model_object)
         for (const auto* instance : m_model_object->instances)
 #if ENABLE_MODELINSTANCE_3D_OFFSET
 #if ENABLE_MODELINSTANCE_3D_ROTATION
+#if ENABLE_MODELINSTANCE_3D_SCALE
+            m_instances.emplace_back(instance->get_offset(), instance->get_rotation(), instance->get_scaling_factor());
+#else
             m_instances.emplace_back(instance->get_offset(), instance->get_rotation(), instance->scaling_factor);
+#endif // ENABLE_MODELINSTANCE_3D_SCALE
 #else
             m_instances_positions.emplace_back(instance->get_offset());
 #endif // ENABLE_MODELINSTANCE_3D_ROTATION
@@ -1576,11 +1594,20 @@ bool GLGizmoFlatten::is_plane_update_necessary() const
 #if ENABLE_MODELINSTANCE_3D_ROTATION
 Vec3d GLGizmoFlatten::get_flattening_rotation() const
 {
+#if ENABLE_MODELINSTANCE_3D_SCALE
+    // calculates the rotations in model space, taking in account the scaling factors
+    Eigen::Matrix<double, 3, 3, Eigen::DontAlign> m = m_model_object->instances.front()->world_matrix(true, true).matrix().block(0, 0, 3, 3).inverse().transpose();
+    Eigen::Quaterniond q;
+    Vec3d angles = q.setFromTwoVectors(m * m_normal, -Vec3d::UnitZ()).toRotationMatrix().eulerAngles(2, 1, 0);
+    m_normal = Vec3d::Zero();
+    return Vec3d(angles(2), angles(1), angles(0));
+#else
     // calculates the rotations in model space
     Eigen::Quaterniond q;
     Vec3d angles = q.setFromTwoVectors(m_normal, -Vec3d::UnitZ()).toRotationMatrix().eulerAngles(2, 1, 0);
     m_normal = Vec3d::Zero();
     return Vec3d(angles(2), angles(1), angles(0));
+#endif // ENABLE_MODELINSTANCE_3D_SCALE
 }
 #else
 Vec3d GLGizmoFlatten::get_flattening_normal() const {

xs/src/slic3r/GUI/GLGizmo.hpp

@@ -275,6 +275,10 @@ class GLGizmoScale3D : public GLGizmoBase
 public:
     explicit GLGizmoScale3D(GLCanvas3D& parent);
 
+#if ENABLE_MODELINSTANCE_3D_SCALE
+    const Vec3d& get_scale() const { return m_scale; }
+    void set_scale(const Vec3d& scale) { m_starting_scale = scale; }
+#else
     double get_scale_x() const { return m_scale(0); }
     void set_scale_x(double scale) { m_starting_scale(0) = scale; }
 
@@ -285,6 +289,7 @@ public:
     void set_scale_z(double scale) { m_starting_scale(2) = scale; }
 
     void set_scale(double scale) { m_starting_scale = scale * Vec3d::Ones(); }
+#endif // ENABLE_MODELINSTANCE_3D_SCALE
 
 protected:
     virtual bool on_init();
@@ -365,10 +370,16 @@ private:
     struct InstanceData
     {
         Vec3d position;
-        Vec3d rotation; 
+        Vec3d rotation;
+#if ENABLE_MODELINSTANCE_3D_SCALE
+        Vec3d scaling_factor;
+
+        InstanceData(const Vec3d& position, const Vec3d& rotation, const Vec3d& scaling_factor) : position(position), rotation(rotation), scaling_factor(scaling_factor) {}
+#else
         double scaling_factor;
 
         InstanceData(const Vec3d& position, const Vec3d& rotation, double scaling_factor) : position(position), rotation(rotation), scaling_factor(scaling_factor) {}
+#endif // ENABLE_MODELINSTANCE_3D_SCALE
     };
     std::vector<InstanceData> m_instances;
 #else

xs/src/slic3r/GUI/GUI_ObjectParts.cpp

@@ -1750,6 +1750,18 @@ void update_scale_values()
     auto instance = (*m_objects)[m_selected_object_id]->instances.front();
     auto size = (*m_objects)[m_selected_object_id]->instance_bounding_box(0).size();
 
+#if ENABLE_MODELINSTANCE_3D_SCALE
+    if (g_is_percent_scale) {
+        og->set_value("scale_x", int(instance->get_scaling_factor(X) * 100));
+        og->set_value("scale_y", int(instance->get_scaling_factor(Y) * 100));
+        og->set_value("scale_z", int(instance->get_scaling_factor(Z) * 100));
+    }
+    else {
+        og->set_value("scale_x", int(instance->get_scaling_factor(X) * size(0) + 0.5));
+        og->set_value("scale_y", int(instance->get_scaling_factor(Y) * size(1) + 0.5));
+        og->set_value("scale_z", int(instance->get_scaling_factor(Z) * size(2) + 0.5));
+    }
+#else
     if (g_is_percent_scale) {
         auto scale = instance->scaling_factor * 100.0;
         og->set_value("scale_x", int(scale));
@@ -1761,6 +1773,7 @@ void update_scale_values()
         og->set_value("scale_y", int(instance->scaling_factor * size(1) + 0.5));
         og->set_value("scale_z", int(instance->scaling_factor * size(2) + 0.5));
     }
+#endif // ENABLE_MODELINSTANCE_3D_SCALE
 }
 
 void update_position_values()
@@ -1788,6 +1801,24 @@ void update_position_values(const Vec3d& position)
     og->set_value("position_z", int(position(2)));
 }
 
+#if ENABLE_MODELINSTANCE_3D_SCALE
+void update_scale_values(const Vec3d& scaling_factor)
+{
+    auto og = get_optgroup(ogFrequentlyObjectSettings);
+
+    // this is temporary
+    // to be able to update the values as size
+    // we need to store somewhere the original size
+    // or have it passed as parameter
+    if (!g_is_percent_scale)
+        og->set_value("scale_unit", _("%"));
+
+    auto scale = scaling_factor * 100.0;
+    og->set_value("scale_x", int(scale(0)));
+    og->set_value("scale_y", int(scale(1)));
+    og->set_value("scale_z", int(scale(2)));
+}
+#else
 void update_scale_values(double scaling_factor)
 {
     auto og = get_optgroup(ogFrequentlyObjectSettings);
@@ -1804,6 +1835,7 @@ void update_scale_values(double scaling_factor)
     og->set_value("scale_y", int(scale));
     og->set_value("scale_z", int(scale));
 }
+#endif // ENABLE_MODELINSTANCE_3D_SCALE
 
 void update_rotation_values()
 {

xs/src/slic3r/GUI/GUI_ObjectParts.hpp

@@ -119,7 +119,11 @@ void update_position_values();
 void update_position_values(const Vec3d& position);
 // update scale values after scale unit changing or "gizmos"
 void update_scale_values();
+#if ENABLE_MODELINSTANCE_3D_SCALE
+void update_scale_values(const Vec3d& scaling_factor);
+#else
 void update_scale_values(double scaling_factor);
+#endif // ENABLE_MODELINSTANCE_3D_SCALE
 // update rotation values object selection changing
 void update_rotation_values();
 // update rotation value after "gizmos"