diff --git a/src/slic3r/GUI/Gizmos/GLGizmoScale.cpp b/src/slic3r/GUI/Gizmos/GLGizmoScale.cpp
index b97507166..812259a83 100644
--- a/src/slic3r/GUI/Gizmos/GLGizmoScale.cpp
+++ b/src/slic3r/GUI/Gizmos/GLGizmoScale.cpp
@@ -11,13 +11,10 @@ namespace Slic3r {
 namespace GUI {
 
 
-const float GLGizmoScale3D::Offset = 5.0f;
+const double GLGizmoScale3D::Offset = 5.0;
 
 GLGizmoScale3D::GLGizmoScale3D(GLCanvas3D& parent, const std::string& icon_filename, unsigned int sprite_id)
     : GLGizmoBase(parent, icon_filename, sprite_id)
-    , m_scale(Vec3d::Ones())
-    , m_offset(Vec3d::Zero())
-    , m_snap_step(0.05)
 {
 }
 
@@ -25,27 +22,24 @@ std::string GLGizmoScale3D::get_tooltip() const
 {
     const Selection& selection = m_parent.get_selection();
 
-    bool single_instance = selection.is_single_full_instance();
-    bool single_volume = selection.is_single_modifier() || selection.is_single_volume();
-
-    Vec3f scale = 100.0f * Vec3f::Ones();
-    if (single_instance)
-        scale = 100.0f * selection.get_volume(*selection.get_volume_idxs().begin())->get_instance_scaling_factor().cast<float>();
-    else if (single_volume)
-        scale = 100.0f * selection.get_volume(*selection.get_volume_idxs().begin())->get_volume_scaling_factor().cast<float>();
+    Vec3d scale = 100.0 * Vec3d::Ones();
+    if (selection.is_single_full_instance())
+        scale = 100.0 * selection.get_volume(*selection.get_volume_idxs().begin())->get_instance_scaling_factor();
+    else if (selection.is_single_modifier() || selection.is_single_volume())
+        scale = 100.0 * selection.get_volume(*selection.get_volume_idxs().begin())->get_volume_scaling_factor();
 
     if (m_hover_id == 0 || m_hover_id == 1 || m_grabbers[0].dragging || m_grabbers[1].dragging)
-        return "X: " + format(scale(0), 4) + "%";
+        return "X: " + format(scale.x(), 4) + "%";
     else if (m_hover_id == 2 || m_hover_id == 3 || m_grabbers[2].dragging || m_grabbers[3].dragging)
-        return "Y: " + format(scale(1), 4) + "%";
+        return "Y: " + format(scale.y(), 4) + "%";
     else if (m_hover_id == 4 || m_hover_id == 5 || m_grabbers[4].dragging || m_grabbers[5].dragging)
-        return "Z: " + format(scale(2), 4) + "%";
+        return "Z: " + format(scale.z(), 4) + "%";
     else if (m_hover_id == 6 || m_hover_id == 7 || m_hover_id == 8 || m_hover_id == 9 || 
         m_grabbers[6].dragging || m_grabbers[7].dragging || m_grabbers[8].dragging || m_grabbers[9].dragging)
     {
-        std::string tooltip = "X: " + format(scale(0), 4) + "%\n";
-        tooltip += "Y: " + format(scale(1), 4) + "%\n";
-        tooltip += "Z: " + format(scale(2), 4) + "%";
+        std::string tooltip = "X: " + format(scale.x(), 4) + "%\n";
+        tooltip += "Y: " + format(scale.y(), 4) + "%\n";
+        tooltip += "Z: " + format(scale.z(), 4) + "%";
         return tooltip;
     }
     else
@@ -54,20 +48,19 @@ std::string GLGizmoScale3D::get_tooltip() const
 
 bool GLGizmoScale3D::on_init()
 {
-    for (int i = 0; i < 10; ++i)
-    {
+    for (int i = 0; i < 10; ++i) {
         m_grabbers.push_back(Grabber());
     }
 
     double half_pi = 0.5 * (double)PI;
 
     // x axis
-    m_grabbers[0].angles(1) = half_pi;
-    m_grabbers[1].angles(1) = half_pi;
+    m_grabbers[0].angles.y() = half_pi;
+    m_grabbers[1].angles.y() = half_pi;
 
     // y axis
-    m_grabbers[2].angles(0) = half_pi;
-    m_grabbers[3].angles(0) = half_pi;
+    m_grabbers[2].angles.x() = half_pi;
+    m_grabbers[3].angles.x() = half_pi;
 
     m_shortcut_key = WXK_CONTROL_S;
 
@@ -87,29 +80,28 @@ bool GLGizmoScale3D::on_is_activable() const
 
 void GLGizmoScale3D::on_start_dragging()
 {
-    if (m_hover_id != -1)
-    {
+    if (m_hover_id != -1) {
         m_starting.drag_position = m_grabbers[m_hover_id].center;
         m_starting.ctrl_down = wxGetKeyState(WXK_CONTROL);
         m_starting.box = (m_starting.ctrl_down && (m_hover_id < 6)) ? m_box : m_parent.get_selection().get_bounding_box();
 
         const Vec3d& center = m_starting.box.center();
-        m_starting.pivots[0] = m_transform * Vec3d(m_starting.box.max(0), center(1), center(2));
-        m_starting.pivots[1] = m_transform * Vec3d(m_starting.box.min(0), center(1), center(2));
-        m_starting.pivots[2] = m_transform * Vec3d(center(0), m_starting.box.max(1), center(2));
-        m_starting.pivots[3] = m_transform * Vec3d(center(0), m_starting.box.min(1), center(2));
-        m_starting.pivots[4] = m_transform * Vec3d(center(0), center(1), m_starting.box.max(2));
-        m_starting.pivots[5] = m_transform * Vec3d(center(0), center(1), m_starting.box.min(2));
+        m_starting.pivots[0] = m_transform * Vec3d(m_starting.box.max.x(), center.y(), center.z());
+        m_starting.pivots[1] = m_transform * Vec3d(m_starting.box.min.x(), center.y(), center.z());
+        m_starting.pivots[2] = m_transform * Vec3d(center.x(), m_starting.box.max.y(), center.z());
+        m_starting.pivots[3] = m_transform * Vec3d(center.x(), m_starting.box.min.y(), center.z());
+        m_starting.pivots[4] = m_transform * Vec3d(center.x(), center.y(), m_starting.box.max.z());
+        m_starting.pivots[5] = m_transform * Vec3d(center.x(), center.y(), m_starting.box.min.z());
     }
 }
 
 void GLGizmoScale3D::on_update(const UpdateData& data)
 {
-    if ((m_hover_id == 0) || (m_hover_id == 1))
+    if (m_hover_id == 0 || m_hover_id == 1)
         do_scale_along_axis(X, data);
-    else if ((m_hover_id == 2) || (m_hover_id == 3))
+    else if (m_hover_id == 2 || m_hover_id == 3)
         do_scale_along_axis(Y, data);
-    else if ((m_hover_id == 4) || (m_hover_id == 5))
+    else if (m_hover_id == 4 || m_hover_id == 5)
         do_scale_along_axis(Z, data);
     else if (m_hover_id >= 6)
         do_scale_uniform(data);
@@ -119,9 +111,6 @@ void GLGizmoScale3D::on_render()
 {
     const Selection& selection = m_parent.get_selection();
 
-    bool single_instance = selection.is_single_full_instance();
-    bool single_volume = selection.is_single_modifier() || selection.is_single_volume();
-
     glsafe(::glClear(GL_DEPTH_BUFFER_BIT));
     glsafe(::glEnable(GL_DEPTH_TEST));
 
@@ -132,7 +121,7 @@ void GLGizmoScale3D::on_render()
     m_offsets_transform = Transform3d::Identity();
     Vec3d angles = Vec3d::Zero();
 
-    if (single_instance) {
+    if (selection.is_single_full_instance()) {
         // calculate bounding box in instance local reference system
         const Selection::IndicesList& idxs = selection.get_volume_idxs();
         for (unsigned int idx : idxs) {
@@ -149,7 +138,7 @@ void GLGizmoScale3D::on_render()
         offsets_transform = Geometry::assemble_transform(Vec3d::Zero(), angles, Vec3d::Ones(), v->get_instance_mirror());
         m_offsets_transform = offsets_transform;
     }
-    else if (single_volume) {
+    else if (selection.is_single_modifier() || selection.is_single_volume()) {
         const GLVolume* v = selection.get_volume(*selection.get_volume_idxs().begin());
         m_box = v->bounding_box();
         m_transform = v->world_matrix();
@@ -162,35 +151,35 @@ void GLGizmoScale3D::on_render()
         m_box = selection.get_bounding_box();
 
     const Vec3d& center = m_box.center();
-    Vec3d offset_x = offsets_transform * Vec3d((double)Offset, 0.0, 0.0);
-    Vec3d offset_y = offsets_transform * Vec3d(0.0, (double)Offset, 0.0);
-    Vec3d offset_z = offsets_transform * Vec3d(0.0, 0.0, (double)Offset);
+    Vec3d offset_x = offsets_transform * Vec3d(Offset, 0.0, 0.0);
+    Vec3d offset_y = offsets_transform * Vec3d(0.0, Offset, 0.0);
+    Vec3d offset_z = offsets_transform * Vec3d(0.0, 0.0, Offset);
 
     bool ctrl_down = (m_dragging && m_starting.ctrl_down) || (!m_dragging && wxGetKeyState(WXK_CONTROL));
 
     // x axis
-    m_grabbers[0].center = m_transform * Vec3d(m_box.min(0), center(1), center(2)) - offset_x;
-    m_grabbers[0].color = (ctrl_down && (m_hover_id == 1)) ? CONSTRAINED_COLOR : AXES_COLOR[0];
-    m_grabbers[1].center = m_transform * Vec3d(m_box.max(0), center(1), center(2)) + offset_x;
-    m_grabbers[1].color = (ctrl_down && (m_hover_id == 0)) ? CONSTRAINED_COLOR : AXES_COLOR[0];
+    m_grabbers[0].center = m_transform * Vec3d(m_box.min.x(), center.y(), center.z()) - offset_x;
+    m_grabbers[0].color = (ctrl_down && m_hover_id == 1) ? CONSTRAINED_COLOR : AXES_COLOR[0];
+    m_grabbers[1].center = m_transform * Vec3d(m_box.max.x(), center.y(), center.z()) + offset_x;
+    m_grabbers[1].color = (ctrl_down && m_hover_id == 0) ? CONSTRAINED_COLOR : AXES_COLOR[0];
 
     // y axis
-    m_grabbers[2].center = m_transform * Vec3d(center(0), m_box.min(1), center(2)) - offset_y;
-    m_grabbers[2].color = (ctrl_down && (m_hover_id == 3)) ? CONSTRAINED_COLOR : AXES_COLOR[1];
-    m_grabbers[3].center = m_transform * Vec3d(center(0), m_box.max(1), center(2)) + offset_y;
-    m_grabbers[3].color = (ctrl_down && (m_hover_id == 2)) ? CONSTRAINED_COLOR : AXES_COLOR[1];
+    m_grabbers[2].center = m_transform * Vec3d(center.x(), m_box.min.y(), center.z()) - offset_y;
+    m_grabbers[2].color = (ctrl_down && m_hover_id == 3) ? CONSTRAINED_COLOR : AXES_COLOR[1];
+    m_grabbers[3].center = m_transform * Vec3d(center.x(), m_box.max.y(), center.z()) + offset_y;
+    m_grabbers[3].color = (ctrl_down && m_hover_id == 2) ? CONSTRAINED_COLOR : AXES_COLOR[1];
 
     // z axis
-    m_grabbers[4].center = m_transform * Vec3d(center(0), center(1), m_box.min(2)) - offset_z;
-    m_grabbers[4].color = (ctrl_down && (m_hover_id == 5)) ? CONSTRAINED_COLOR : AXES_COLOR[2];
-    m_grabbers[5].center = m_transform * Vec3d(center(0), center(1), m_box.max(2)) + offset_z;
-    m_grabbers[5].color = (ctrl_down && (m_hover_id == 4)) ? CONSTRAINED_COLOR : AXES_COLOR[2];
+    m_grabbers[4].center = m_transform * Vec3d(center.x(), center.y(), m_box.min.z()) - offset_z;
+    m_grabbers[4].color = (ctrl_down && m_hover_id == 5) ? CONSTRAINED_COLOR : AXES_COLOR[2];
+    m_grabbers[5].center = m_transform * Vec3d(center.x(), center.y(), m_box.max.z()) + offset_z;
+    m_grabbers[5].color = (ctrl_down && m_hover_id == 4) ? CONSTRAINED_COLOR : AXES_COLOR[2];
 
     // uniform
-    m_grabbers[6].center = m_transform * Vec3d(m_box.min(0), m_box.min(1), center(2)) - offset_x - offset_y;
-    m_grabbers[7].center = m_transform * Vec3d(m_box.max(0), m_box.min(1), center(2)) + offset_x - offset_y;
-    m_grabbers[8].center = m_transform * Vec3d(m_box.max(0), m_box.max(1), center(2)) + offset_x + offset_y;
-    m_grabbers[9].center = m_transform * Vec3d(m_box.min(0), m_box.max(1), center(2)) - offset_x + offset_y;
+    m_grabbers[6].center = m_transform * Vec3d(m_box.min.x(), m_box.min.y(), center.z()) - offset_x - offset_y;
+    m_grabbers[7].center = m_transform * Vec3d(m_box.max.x(), m_box.min.y(), center.z()) + offset_x - offset_y;
+    m_grabbers[8].center = m_transform * Vec3d(m_box.max.x(), m_box.max.y(), center.z()) + offset_x + offset_y;
+    m_grabbers[9].center = m_transform * Vec3d(m_box.min.x(), m_box.max.y(), center.z()) - offset_x + offset_y;
     for (int i = 6; i < 10; ++i) {
         m_grabbers[i].color = m_highlight_color;
     }
@@ -204,7 +193,7 @@ void GLGizmoScale3D::on_render()
 
     const BoundingBoxf3& selection_box = selection.get_bounding_box();
 
-    float grabber_mean_size = (float)((selection_box.size()(0) + selection_box.size()(1) + selection_box.size()(2)) / 3.0);
+    float grabber_mean_size = (float)((selection_box.size().x() + selection_box.size().y() + selection_box.size().z()) / 3.0);
 
     if (m_hover_id == -1) {
         // draw connections
@@ -303,8 +292,7 @@ void GLGizmoScale3D::on_render_for_picking()
 void GLGizmoScale3D::render_grabbers_connection(unsigned int id_1, unsigned int id_2) const
 {
     unsigned int grabbers_count = (unsigned int)m_grabbers.size();
-    if ((id_1 < grabbers_count) && (id_2 < grabbers_count))
-    {
+    if (id_1 < grabbers_count && id_2 < grabbers_count) {
         ::glBegin(GL_LINES);
         ::glVertex3dv(m_grabbers[id_1].center.data());
         ::glVertex3dv(m_grabbers[id_2].center.data());
@@ -314,12 +302,10 @@ void GLGizmoScale3D::render_grabbers_connection(unsigned int id_1, unsigned int
 
 void GLGizmoScale3D::do_scale_along_axis(Axis axis, const UpdateData& data)
 {
-    double ratio = calc_ratio(data);
-    if (ratio > 0.0)
-    {
+    const double ratio = calc_ratio(data);
+    if (ratio > 0.0) {
         m_scale(axis) = m_starting.scale(axis) * ratio;
-        if (m_starting.ctrl_down)
-        {
+        if (m_starting.ctrl_down) {
             double local_offset = 0.5 * (m_scale(axis) - m_starting.scale(axis)) * m_starting.box.size()(axis);
             if (m_hover_id == 2 * axis)
                 local_offset *= -1.0;
@@ -342,9 +328,8 @@ void GLGizmoScale3D::do_scale_along_axis(Axis axis, const UpdateData& data)
 
 void GLGizmoScale3D::do_scale_uniform(const UpdateData& data)
 {
-    double ratio = calc_ratio(data);
-    if (ratio > 0.0)
-    {
+    const double ratio = calc_ratio(data);
+    if (ratio > 0.0) {
         m_scale = m_starting.scale * ratio;
         m_offset = Vec3d::Zero();
     }
@@ -354,23 +339,22 @@ double GLGizmoScale3D::calc_ratio(const UpdateData& data) const
 {
     double ratio = 0.0;
 
-    Vec3d pivot = (m_starting.ctrl_down && (m_hover_id < 6)) ? m_starting.pivots[m_hover_id] : m_starting.box.center();
+    const Vec3d pivot = (m_starting.ctrl_down && (m_hover_id < 6)) ? m_starting.pivots[m_hover_id] : m_starting.box.center();
 
-    Vec3d starting_vec = m_starting.drag_position - pivot;
-    double len_starting_vec = starting_vec.norm();
-    if (len_starting_vec != 0.0)
-    {
+    const Vec3d starting_vec = m_starting.drag_position - pivot;
+    const double len_starting_vec = starting_vec.norm();
+    if (len_starting_vec != 0.0) {
         Vec3d mouse_dir = data.mouse_ray.unit_vector();
         // finds the intersection of the mouse ray with the plane parallel to the camera viewport and passing throught the starting position
         // use ray-plane intersection see i.e. https://en.wikipedia.org/wiki/Line%E2%80%93plane_intersection algebric form
         // in our case plane normal and ray direction are the same (orthogonal view)
         // when moving to perspective camera the negative z unit axis of the camera needs to be transformed in world space and used as plane normal
-        Vec3d inters = data.mouse_ray.a + (m_starting.drag_position - data.mouse_ray.a).dot(mouse_dir) / mouse_dir.squaredNorm() * mouse_dir;
+        const Vec3d inters = data.mouse_ray.a + (m_starting.drag_position - data.mouse_ray.a).dot(mouse_dir) / mouse_dir.squaredNorm() * mouse_dir;
         // vector from the starting position to the found intersection
-        Vec3d inters_vec = inters - m_starting.drag_position;
+        const Vec3d inters_vec = inters - m_starting.drag_position;
 
         // finds projection of the vector along the staring direction
-        double proj = inters_vec.dot(starting_vec.normalized());
+        const double proj = inters_vec.dot(starting_vec.normalized());
 
         ratio = (len_starting_vec + proj) / len_starting_vec;
     }
diff --git a/src/slic3r/GUI/Gizmos/GLGizmoScale.hpp b/src/slic3r/GUI/Gizmos/GLGizmoScale.hpp
index 35615df4a..46ecd0f83 100644
--- a/src/slic3r/GUI/Gizmos/GLGizmoScale.hpp
+++ b/src/slic3r/GUI/Gizmos/GLGizmoScale.hpp
@@ -11,26 +11,24 @@ namespace GUI {
 
 class GLGizmoScale3D : public GLGizmoBase
 {
-    static const float Offset;
+    static const double Offset;
 
     struct StartingData
     {
-        Vec3d scale;
-        Vec3d drag_position;
+        bool ctrl_down{ false };
+        Vec3d scale{ Vec3d::Ones() };
+        Vec3d drag_position{ Vec3d::Zero() };
         BoundingBoxf3 box;
-        Vec3d pivots[6];
-        bool ctrl_down;
-
-        StartingData() : scale(Vec3d::Ones()), drag_position(Vec3d::Zero()), ctrl_down(false) { for (int i = 0; i < 5; ++i) { pivots[i] = Vec3d::Zero(); } }
+        std::array<Vec3d, 6> pivots{ Vec3d::Zero(), Vec3d::Zero(), Vec3d::Zero(), Vec3d::Zero(), Vec3d::Zero(), Vec3d::Zero() };
     };
 
     mutable BoundingBoxf3 m_box;
     mutable Transform3d m_transform;
     // Transforms grabbers offsets to the proper reference system (world for instances, instance for volumes)
     mutable Transform3d m_offsets_transform;
-    Vec3d m_scale;
-    Vec3d m_offset;
-    double m_snap_step;
+    Vec3d m_scale{ Vec3d::Ones() };
+    Vec3d m_offset{ Vec3d::Zero() };
+    double m_snap_step{ 0.05 };
     StartingData m_starting;
 
 public: