diff --git a/src/libslic3r/Geometry.cpp b/src/libslic3r/Geometry.cpp
index 6e593af94..115d21693 100644
--- a/src/libslic3r/Geometry.cpp
+++ b/src/libslic3r/Geometry.cpp
@@ -414,7 +414,7 @@ Vec3d extract_euler_angles(const Transform3d& transform)
     return extract_euler_angles(m);
 }
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
 Transform3d Transformation::get_offset_matrix() const
 {
     return assemble_transform(get_offset());
@@ -499,11 +499,11 @@ void Transformation::set_offset(Axis axis, double offset)
         m_dirty = true;
     }
 }
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 
 void Transformation::set_rotation(const Vec3d& rotation)
 {
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     const Vec3d offset = get_offset();
     m_matrix = rotation_transform(rotation) * extract_scale(m_matrix);
     m_matrix.translation() = offset;
@@ -511,7 +511,7 @@ void Transformation::set_rotation(const Vec3d& rotation)
     set_rotation(X, rotation.x());
     set_rotation(Y, rotation.y());
     set_rotation(Z, rotation.z());
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 }
 
 void Transformation::set_rotation(Axis axis, double rotation)
@@ -520,7 +520,7 @@ void Transformation::set_rotation(Axis axis, double rotation)
     if (is_approx(std::abs(rotation), 2.0 * double(PI)))
         rotation = 0.0;
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     auto [curr_rotation, scale] = extract_rotation_scale(m_matrix);
     Vec3d angles = extract_euler_angles(curr_rotation);
     angles[axis] = rotation;
@@ -533,10 +533,10 @@ void Transformation::set_rotation(Axis axis, double rotation)
         m_rotation(axis) = rotation;
         m_dirty = true;
     }
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 }
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
 Vec3d Transformation::get_scaling_factor() const
 {
     const Transform3d scale = extract_scale(m_matrix);
@@ -547,11 +547,11 @@ Transform3d Transformation::get_scaling_factor_matrix() const
 {
     return extract_scale(m_matrix);
 }
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 
 void Transformation::set_scaling_factor(const Vec3d& scaling_factor)
 {
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     assert(scaling_factor.x() > 0.0 && scaling_factor.y() > 0.0 && scaling_factor.z() > 0.0);
 
     const Vec3d offset = get_offset();
@@ -561,12 +561,12 @@ void Transformation::set_scaling_factor(const Vec3d& scaling_factor)
     set_scaling_factor(X, scaling_factor.x());
     set_scaling_factor(Y, scaling_factor.y());
     set_scaling_factor(Z, scaling_factor.z());
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 }
 
 void Transformation::set_scaling_factor(Axis axis, double scaling_factor)
 {
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     assert(scaling_factor > 0.0);
     auto [rotation, scale] = extract_rotation_scale(m_matrix);
     scale(axis, axis) = scaling_factor;
@@ -579,10 +579,10 @@ void Transformation::set_scaling_factor(Axis axis, double scaling_factor)
         m_scaling_factor(axis) = std::abs(scaling_factor);
         m_dirty = true;
     }
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 }
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
 Vec3d Transformation::get_mirror() const
 {
     const Transform3d scale = extract_scale(m_matrix);
@@ -594,11 +594,11 @@ Transform3d Transformation::get_mirror_matrix() const
     const Vec3d scale = get_scaling_factor();
     return scale_transform({ scale.x() / std::abs(scale.x()), scale.y() / std::abs(scale.y()), scale.z() / std::abs(scale.z()) });
 }
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 
 void Transformation::set_mirror(const Vec3d& mirror)
 {
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     Vec3d copy(mirror);
     const Vec3d abs_mirror = copy.cwiseAbs();
     for (int i = 0; i < 3; ++i) {
@@ -619,7 +619,7 @@ void Transformation::set_mirror(const Vec3d& mirror)
     set_mirror(X, mirror.x());
     set_mirror(Y, mirror.y());
     set_mirror(Z, mirror.z());
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 }
 
 void Transformation::set_mirror(Axis axis, double mirror)
@@ -630,7 +630,7 @@ void Transformation::set_mirror(Axis axis, double mirror)
     else if (abs_mirror != 1.0)
         mirror /= abs_mirror;
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     const double curr_scale = get_scaling_factor(axis);
     const double sign = curr_scale * mirror;
     set_scaling_factor(axis, sign < 0.0 ? std::abs(curr_scale) * mirror : curr_scale);
@@ -639,10 +639,10 @@ void Transformation::set_mirror(Axis axis, double mirror)
         m_mirror(axis) = mirror;
         m_dirty = true;
     }
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 }
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
 bool Transformation::has_skew() const
 {
     return contains_skew(m_matrix);
@@ -685,23 +685,23 @@ void Transformation::set_from_transform(const Transform3d& transform)
 //    if (!m_matrix.isApprox(transform))
 //        std::cout << "something went wrong in extracting data from matrix" << std::endl;
 }
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 
 void Transformation::reset()
 {
-#if !ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if !ENABLE_WORLD_COORDINATE
     m_offset = Vec3d::Zero();
     m_rotation = Vec3d::Zero();
     m_scaling_factor = Vec3d::Ones();
     m_mirror = Vec3d::Ones();
-#endif // !ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // !ENABLE_WORLD_COORDINATE
     m_matrix = Transform3d::Identity();
-#if !ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if !ENABLE_WORLD_COORDINATE
     m_dirty = false;
-#endif // !ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // !ENABLE_WORLD_COORDINATE
 }
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
 void Transformation::reset_skew()
 {
     Matrix3d rotation;
@@ -757,14 +757,14 @@ const Transform3d& Transformation::get_matrix(bool dont_translate, bool dont_rot
 
     return m_matrix;
 }
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 
 Transformation Transformation::operator * (const Transformation& other) const
 {
     return Transformation(get_matrix() * other.get_matrix());
 }
 
-#if !ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if !ENABLE_WORLD_COORDINATE
 Transformation Transformation::volume_to_bed_transformation(const Transformation& instance_transformation, const BoundingBoxf3& bbox)
 {
     Transformation out;
@@ -810,8 +810,7 @@ Transformation Transformation::volume_to_bed_transformation(const Transformation
         out.set_scaling_factor(Vec3d(std::abs(scale.x()), std::abs(scale.y()), std::abs(scale.z())));
         out.set_mirror(Vec3d(scale.x() > 0 ? 1. : -1, scale.y() > 0 ? 1. : -1, scale.z() > 0 ? 1. : -1));
     }
-    else
-    {
+    else {
         // General anisotropic scaling, general rotation.
         // Keep the modifier mesh in the instance coordinate system, so the modifier mesh will not be aligned with the world.
         // Scale it to get the required size.
@@ -820,7 +819,7 @@ Transformation Transformation::volume_to_bed_transformation(const Transformation
 
     return out;
 }
-#endif // !ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // !ENABLE_WORLD_COORDINATE
 
 // For parsing a transformation matrix from 3MF / AMF.
 Transform3d transform3d_from_string(const std::string& transform_str)
diff --git a/src/libslic3r/Geometry.hpp b/src/libslic3r/Geometry.hpp
index 725ced361..6ff52016e 100644
--- a/src/libslic3r/Geometry.hpp
+++ b/src/libslic3r/Geometry.hpp
@@ -381,7 +381,7 @@ Vec3d extract_euler_angles(const Transform3d& transform);
 
 class Transformation
 {
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     Transform3d m_matrix{ Transform3d::Identity() };
 #else
     struct Flags
@@ -403,47 +403,43 @@ class Transformation
     mutable Transform3d m_matrix{ Transform3d::Identity() };
     mutable Flags m_flags;
     mutable bool m_dirty{ false };
-#endif // !ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 
 public:
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     Transformation() = default;
-    explicit Transformation(const Transform3d& transform) : m_matrix(transform) {}
-#else
-    Transformation();
-    explicit Transformation(const Transform3d& transform);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+    explicit Transformation(const Transform3d & transform) : m_matrix(transform) {}
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
     Vec3d get_offset() const { return m_matrix.translation(); }
     double get_offset(Axis axis) const { return get_offset()[axis]; }
 
     Transform3d get_offset_matrix() const;
 
-    void set_offset(const Vec3d& offset) { m_matrix.translation() = offset; }
+    void set_offset(const Vec3d & offset) { m_matrix.translation() = offset; }
     void set_offset(Axis axis, double offset) { m_matrix.translation()[axis] = offset; }
-#else
-    const Vec3d& get_offset() const { return m_offset; }
-    double get_offset(Axis axis) const { return m_offset(axis); }
 
-    void set_offset(const Vec3d& offset);
-    void set_offset(Axis axis, double offset);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
-
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
     Vec3d get_rotation() const;
     double get_rotation(Axis axis) const { return get_rotation()[axis]; }
 
     Transform3d get_rotation_matrix() const;
 #else
+    Transformation();
+    explicit Transformation(const Transform3d & transform);
+
+    const Vec3d& get_offset() const { return m_offset; }
+    double get_offset(Axis axis) const { return m_offset(axis); }
+
+    void set_offset(const Vec3d & offset);
+    void set_offset(Axis axis, double offset);
+
     const Vec3d& get_rotation() const { return m_rotation; }
     double get_rotation(Axis axis) const { return m_rotation(axis); }
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 
     void set_rotation(const Vec3d& rotation);
     void set_rotation(Axis axis, double rotation);
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     Vec3d get_scaling_factor() const;
     double get_scaling_factor(Axis axis) const { return get_scaling_factor()[axis]; }
 
@@ -456,12 +452,12 @@ public:
 #else
     const Vec3d& get_scaling_factor() const { return m_scaling_factor; }
     double get_scaling_factor(Axis axis) const { return m_scaling_factor(axis); }
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 
     void set_scaling_factor(const Vec3d& scaling_factor);
     void set_scaling_factor(Axis axis, double scaling_factor);
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     Vec3d get_mirror() const;
     double get_mirror(Axis axis) const { return get_mirror()[axis]; }
 
@@ -477,21 +473,19 @@ public:
     const Vec3d& get_mirror() const { return m_mirror; }
     double get_mirror(Axis axis) const { return m_mirror(axis); }
     bool is_left_handed() const { return m_mirror.x() * m_mirror.y() * m_mirror.z() < 0.; }
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 
     void set_mirror(const Vec3d& mirror);
     void set_mirror(Axis axis, double mirror);
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     bool has_skew() const;
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
-
-#if !ENABLE_TRANSFORMATIONS_BY_MATRICES
+#else
     void set_from_transform(const Transform3d& transform);
-#endif // !ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 
     void reset();
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     void reset_offset() { set_offset(Vec3d::Zero()); }
     void reset_rotation() { set_rotation(Vec3d::Zero()); }
     void reset_scaling_factor() { set_scaling_factor(Vec3d::Ones()); }
@@ -505,20 +499,20 @@ public:
     void set_matrix(const Transform3d& transform) { m_matrix = transform; }
 #else
     const Transform3d& get_matrix(bool dont_translate = false, bool dont_rotate = false, bool dont_scale = false, bool dont_mirror = false) const;
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 
     Transformation operator * (const Transformation& other) const;
 
-#if !ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if !ENABLE_WORLD_COORDINATE
     // Find volume transformation, so that the chained (instance_trafo * volume_trafo) will be as close to identity
     // as possible in least squares norm in regard to the 8 corners of bbox.
     // Bounding box is expected to be centered around zero in all axes.
     static Transformation volume_to_bed_transformation(const Transformation& instance_transformation, const BoundingBoxf3& bbox);
-#endif // !ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // !ENABLE_WORLD_COORDINATE
 
 private:
     friend class cereal::access;
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     template<class Archive> void serialize(Archive& ar) { ar(m_matrix); }
     explicit Transformation(int) {}
     template <class Archive> static void load_and_construct(Archive& ar, cereal::construct<Transformation>& construct)
@@ -536,7 +530,7 @@ private:
         construct(1);
         ar(construct.ptr()->m_offset, construct.ptr()->m_rotation, construct.ptr()->m_scaling_factor, construct.ptr()->m_mirror);
     }
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 };
 
 // For parsing a transformation matrix from 3MF / AMF.
diff --git a/src/libslic3r/Model.cpp b/src/libslic3r/Model.cpp
index f3f31ed4f..1f8083aca 100644
--- a/src/libslic3r/Model.cpp
+++ b/src/libslic3r/Model.cpp
@@ -945,11 +945,11 @@ const BoundingBoxf3& ModelObject::raw_bounding_box() const
         if (this->instances.empty())
             throw Slic3r::InvalidArgument("Can't call raw_bounding_box() with no instances");
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
         const Transform3d inst_matrix = this->instances.front()->get_transformation().get_matrix_no_offset();
 #else
         const Transform3d& inst_matrix = this->instances.front()->get_transformation().get_matrix(true);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
         for (const ModelVolume *v : this->volumes)
             if (v->is_model_part())
                 m_raw_bounding_box.merge(v->mesh().transformed_bounding_box(inst_matrix * v->get_matrix()));
@@ -961,14 +961,14 @@ const BoundingBoxf3& ModelObject::raw_bounding_box() const
 BoundingBoxf3 ModelObject::instance_bounding_box(size_t instance_idx, bool dont_translate) const
 {
     BoundingBoxf3 bb;
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
-    const Transform3d inst_matrix = dont_translate ? 
+#if ENABLE_WORLD_COORDINATE
+    const Transform3d inst_matrix = dont_translate ?
         this->instances[instance_idx]->get_transformation().get_matrix_no_offset() :
         this->instances[instance_idx]->get_transformation().get_matrix();
 
 #else
     const Transform3d& inst_matrix = this->instances[instance_idx]->get_transformation().get_matrix(dont_translate);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
     for (ModelVolume *v : this->volumes) {
         if (v->is_model_part())
             bb.merge(v->mesh().transformed_bounding_box(inst_matrix * v->get_matrix()));
@@ -1379,11 +1379,11 @@ void ModelObject::split(ModelObjectPtrs* new_objects)
             ModelVolume* new_vol = new_object->add_volume(*volume, std::move(mesh));
 
             for (ModelInstance* model_instance : new_object->instances) {
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
                 Vec3d shift = model_instance->get_transformation().get_matrix_no_offset() * new_vol->get_offset();
 #else
                 Vec3d shift = model_instance->get_transformation().get_matrix(true) * new_vol->get_offset();
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
                 model_instance->set_offset(model_instance->get_offset() + shift);
             }
 
@@ -1447,7 +1447,7 @@ void ModelObject::bake_xy_rotation_into_meshes(size_t instance_idx)
 
     // Adjust the meshes.
     // Transformation to be applied to the meshes.
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     Geometry::Transformation reference_trafo_mod = reference_trafo;
     reference_trafo_mod.reset_offset();
     if (uniform_scaling)
@@ -1457,7 +1457,7 @@ void ModelObject::bake_xy_rotation_into_meshes(size_t instance_idx)
     Eigen::Matrix3d mesh_trafo_3x3 = reference_trafo_mod.get_matrix().matrix().block<3, 3>(0, 0);
 #else
     Eigen::Matrix3d mesh_trafo_3x3           = reference_trafo.get_matrix(true, false, uniform_scaling, ! has_mirrorring).matrix().block<3, 3>(0, 0);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
     Transform3d     volume_offset_correction = this->instances[instance_idx]->get_transformation().get_matrix().inverse() * reference_trafo.get_matrix();
     for (ModelVolume *model_volume : this->volumes) {
         const Geometry::Transformation volume_trafo = model_volume->get_transformation();
@@ -1467,7 +1467,7 @@ void ModelObject::bake_xy_rotation_into_meshes(size_t instance_idx)
                                            std::abs(volume_trafo.get_scaling_factor().x() - volume_trafo.get_scaling_factor().z()) < EPSILON;
         double volume_new_scaling_factor = volume_uniform_scaling ? volume_trafo.get_scaling_factor().x() : 1.;
         // Transform the mesh.
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
         Geometry::Transformation volume_trafo_mod = volume_trafo;
         volume_trafo_mod.reset_offset();
         if (volume_uniform_scaling)
@@ -1477,7 +1477,7 @@ void ModelObject::bake_xy_rotation_into_meshes(size_t instance_idx)
         Eigen::Matrix3d volume_trafo_3x3 = volume_trafo_mod.get_matrix().matrix().block<3, 3>(0, 0);
 #else
         Matrix3d volume_trafo_3x3 = volume_trafo.get_matrix(true, false, volume_uniform_scaling, !volume_has_mirrorring).matrix().block<3, 3>(0, 0);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
         // Following method creates a new shared_ptr<TriangleMesh>
 		model_volume->transform_this_mesh(mesh_trafo_3x3 * volume_trafo_3x3, left_handed != volume_left_handed);
         // Reset the rotation, scaling and mirroring.
@@ -1524,11 +1524,11 @@ double ModelObject::get_instance_min_z(size_t instance_idx) const
     double min_z = DBL_MAX;
 
     const ModelInstance* inst = instances[instance_idx];
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
-    const Transform3d& mi = inst->get_matrix_no_offset();
+#if ENABLE_WORLD_COORDINATE
+    const Transform3d mi = inst->get_matrix_no_offset();
 #else
     const Transform3d& mi = inst->get_matrix(true);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 
     for (const ModelVolume* v : volumes) {
         if (!v->is_model_part())
@@ -1549,11 +1549,11 @@ double ModelObject::get_instance_max_z(size_t instance_idx) const
     double max_z = -DBL_MAX;
 
     const ModelInstance* inst = instances[instance_idx];
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
-    const Transform3d& mi = inst->get_matrix_no_offset();
+#if ENABLE_WORLD_COORDINATE
+    const Transform3d mi = inst->get_matrix_no_offset();
 #else
     const Transform3d& mi = inst->get_matrix(true);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 
     for (const ModelVolume* v : volumes) {
         if (!v->is_model_part())
@@ -1979,22 +1979,22 @@ void ModelVolume::convert_from_meters()
 
 void ModelInstance::transform_mesh(TriangleMesh* mesh, bool dont_translate) const
 {
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     mesh->transform(dont_translate ? get_matrix_no_offset() : get_matrix());
 #else
     mesh->transform(get_matrix(dont_translate));
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 }
 
 BoundingBoxf3 ModelInstance::transform_mesh_bounding_box(const TriangleMesh& mesh, bool dont_translate) const
 {
     // Rotate around mesh origin.
     TriangleMesh copy(mesh);
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     copy.transform(get_transformation().get_rotation_matrix());
 #else
     copy.transform(get_matrix(true, false, true, true));
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
     BoundingBoxf3 bbox = copy.bounding_box();
 
     if (!empty(bbox)) {
@@ -2019,20 +2019,20 @@ BoundingBoxf3 ModelInstance::transform_mesh_bounding_box(const TriangleMesh& mes
 
 BoundingBoxf3 ModelInstance::transform_bounding_box(const BoundingBoxf3 &bbox, bool dont_translate) const
 {
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     return bbox.transformed(dont_translate ? get_matrix_no_offset() : get_matrix());
 #else
     return bbox.transformed(get_matrix(dont_translate));
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 }
 
 Vec3d ModelInstance::transform_vector(const Vec3d& v, bool dont_translate) const
 {
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     return dont_translate ? get_matrix_no_offset() * v : get_matrix() * v;
 #else
     return get_matrix(dont_translate) * v;
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 }
 
 void ModelInstance::transform_polygon(Polygon* polygon) const
diff --git a/src/libslic3r/Model.hpp b/src/libslic3r/Model.hpp
index 016689a46..828358419 100644
--- a/src/libslic3r/Model.hpp
+++ b/src/libslic3r/Model.hpp
@@ -691,27 +691,26 @@ public:
 
     const Geometry::Transformation& get_transformation() const { return m_transformation; }
     void set_transformation(const Geometry::Transformation& transformation) { m_transformation = transformation; }
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     void set_transformation(const Transform3d& trafo) { m_transformation.set_matrix(trafo); }
-#else
-    void set_transformation(const Transform3d &trafo) { m_transformation.set_from_transform(trafo); }
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
     Vec3d get_offset() const { return m_transformation.get_offset(); }
 #else
+    void set_transformation(const Transform3d &trafo) { m_transformation.set_from_transform(trafo); }
+
     const Vec3d& get_offset() const { return m_transformation.get_offset(); }
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
+
     double get_offset(Axis axis) const { return m_transformation.get_offset(axis); }
 
     void set_offset(const Vec3d& offset) { m_transformation.set_offset(offset); }
     void set_offset(Axis axis, double offset) { m_transformation.set_offset(axis, offset); }
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     Vec3d get_rotation() const { return m_transformation.get_rotation(); }
 #else
     const Vec3d& get_rotation() const { return m_transformation.get_rotation(); }
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
     double get_rotation(Axis axis) const { return m_transformation.get_rotation(axis); }
 
     void set_rotation(const Vec3d& rotation) { m_transformation.set_rotation(rotation); }
@@ -723,11 +722,11 @@ public:
     void set_scaling_factor(const Vec3d& scaling_factor) { m_transformation.set_scaling_factor(scaling_factor); }
     void set_scaling_factor(Axis axis, double scaling_factor) { m_transformation.set_scaling_factor(axis, scaling_factor); }
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     Vec3d get_mirror() const { return m_transformation.get_mirror(); }
 #else
     const Vec3d& get_mirror() const { return m_transformation.get_mirror(); }
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
     double get_mirror(Axis axis) const { return m_transformation.get_mirror(axis); }
     bool is_left_handed() const { return m_transformation.is_left_handed(); }
 
@@ -736,12 +735,12 @@ public:
     void convert_from_imperial_units();
     void convert_from_meters();
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     const Transform3d& get_matrix() const { return m_transformation.get_matrix(); }
     Transform3d get_matrix_no_offset() const { return m_transformation.get_matrix_no_offset(); }
 #else
     const Transform3d& get_matrix(bool dont_translate = false, bool dont_rotate = false, bool dont_scale = false, bool dont_mirror = false) const { return m_transformation.get_matrix(dont_translate, dont_rotate, dont_scale, dont_mirror); }
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 
 	void set_new_unique_id() { 
         ObjectBase::set_new_unique_id();
@@ -944,41 +943,41 @@ public:
     const Geometry::Transformation& get_transformation() const { return m_transformation; }
     void set_transformation(const Geometry::Transformation& transformation) { m_transformation = transformation; }
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     Vec3d get_offset() const { return m_transformation.get_offset(); }
 #else
     const Vec3d& get_offset() const { return m_transformation.get_offset(); }
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
     double get_offset(Axis axis) const { return m_transformation.get_offset(axis); }
     
     void set_offset(const Vec3d& offset) { m_transformation.set_offset(offset); }
     void set_offset(Axis axis, double offset) { m_transformation.set_offset(axis, offset); }
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     Vec3d get_rotation() const { return m_transformation.get_rotation(); }
 #else
     const Vec3d& get_rotation() const { return m_transformation.get_rotation(); }
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
     double get_rotation(Axis axis) const { return m_transformation.get_rotation(axis); }
 
     void set_rotation(const Vec3d& rotation) { m_transformation.set_rotation(rotation); }
     void set_rotation(Axis axis, double rotation) { m_transformation.set_rotation(axis, rotation); }
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     Vec3d get_scaling_factor() const { return m_transformation.get_scaling_factor(); }
 #else
     const Vec3d& get_scaling_factor() const { return m_transformation.get_scaling_factor(); }
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
     double get_scaling_factor(Axis axis) const { return m_transformation.get_scaling_factor(axis); }
 
     void set_scaling_factor(const Vec3d& scaling_factor) { m_transformation.set_scaling_factor(scaling_factor); }
     void set_scaling_factor(Axis axis, double scaling_factor) { m_transformation.set_scaling_factor(axis, scaling_factor); }
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     Vec3d get_mirror() const { return m_transformation.get_mirror(); }
 #else
     const Vec3d& get_mirror() const { return m_transformation.get_mirror(); }
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
     double get_mirror(Axis axis) const { return m_transformation.get_mirror(axis); }
 	bool is_left_handed() const { return m_transformation.is_left_handed(); }
     
@@ -996,12 +995,12 @@ public:
     // To be called on an external polygon. It does not translate the polygon, only rotates and scales.
     void transform_polygon(Polygon* polygon) const;
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     const Transform3d& get_matrix() const { return m_transformation.get_matrix(); }
     Transform3d get_matrix_no_offset() const { return m_transformation.get_matrix_no_offset(); }
 #else
     const Transform3d& get_matrix(bool dont_translate = false, bool dont_rotate = false, bool dont_scale = false, bool dont_mirror = false) const { return m_transformation.get_matrix(dont_translate, dont_rotate, dont_scale, dont_mirror); }
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 
     bool is_printable() const { return object->printable && printable && (print_volume_state == ModelInstancePVS_Inside); }
 
diff --git a/src/libslic3r/Point.hpp b/src/libslic3r/Point.hpp
index 4fc76800c..ec071673b 100644
--- a/src/libslic3r/Point.hpp
+++ b/src/libslic3r/Point.hpp
@@ -545,10 +545,10 @@ namespace cereal {
 
 	template<class Archive> void load(Archive& archive, Slic3r::Matrix2f &m) { archive.loadBinary((char*)m.data(), sizeof(float) * 4); }
 	template<class Archive> void save(Archive& archive, Slic3r::Matrix2f &m) { archive.saveBinary((char*)m.data(), sizeof(float) * 4); }
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     template<class Archive> void load(Archive& archive, Slic3r::Transform3d& m)       { archive.loadBinary((char*)m.data(), sizeof(double) * 16); }
     template<class Archive> void save(Archive& archive, const Slic3r::Transform3d& m) { archive.saveBinary((char*)m.data(), sizeof(double) * 16); }
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 }
 
 // To be able to use Vec<> and Mat<> in range based for loops:
diff --git a/src/libslic3r/PrintApply.cpp b/src/libslic3r/PrintApply.cpp
index b88ae9e50..4c085728c 100644
--- a/src/libslic3r/PrintApply.cpp
+++ b/src/libslic3r/PrintApply.cpp
@@ -790,13 +790,13 @@ void update_volume_bboxes(
                     if (it != volumes_old.end() && it->volume_id == model_volume->id())
                         layer_range.volumes.emplace_back(*it);
                 } else
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
                     layer_range.volumes.push_back({ model_volume->id(),
                         transformed_its_bbox2d(model_volume->mesh().its, trafo_for_bbox(object_trafo, model_volume->get_matrix()), offset) });
 #else
                     layer_range.volumes.push_back({ model_volume->id(),
                         transformed_its_bbox2d(model_volume->mesh().its, trafo_for_bbox(object_trafo, model_volume->get_matrix(false)), offset) });
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
             }
     } else {
         std::vector<std::vector<PrintObjectRegions::VolumeExtents>> volumes_old;
@@ -828,11 +828,11 @@ void update_volume_bboxes(
                             layer_range.volumes.emplace_back(*it);
                     }
                 } else {
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
                     transformed_its_bboxes_in_z_ranges(model_volume->mesh().its, trafo_for_bbox(object_trafo, model_volume->get_matrix()), ranges, bboxes, offset);
 #else
                     transformed_its_bboxes_in_z_ranges(model_volume->mesh().its, trafo_for_bbox(object_trafo, model_volume->get_matrix(false)), ranges, bboxes, offset);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
                     for (PrintObjectRegions::LayerRangeRegions &layer_range : layer_ranges)
                         if (auto &bbox = bboxes[&layer_range - layer_ranges.data()]; bbox.second)
                             layer_range.volumes.push_back({ model_volume->id(), bbox.first });
diff --git a/src/libslic3r/Technologies.hpp b/src/libslic3r/Technologies.hpp
index 4f0a04df1..302c62879 100644
--- a/src/libslic3r/Technologies.hpp
+++ b/src/libslic3r/Technologies.hpp
@@ -71,8 +71,6 @@
 #define ENABLE_VOLUMETRIC_RATE_TOOLPATHS_RECALC (1 && ENABLE_2_5_0_ALPHA1)
 // Enable editing volumes transformation in world coordinates and instances in local coordinates
 #define ENABLE_WORLD_COORDINATE (1 && ENABLE_2_5_0_ALPHA1)
-// Enable implementation of Geometry::Transformation using matrices only
-#define ENABLE_TRANSFORMATIONS_BY_MATRICES (1 && ENABLE_WORLD_COORDINATE)
 // Enable modified camera control using mouse
 #define ENABLE_NEW_CAMERA_MOVEMENTS (1 && ENABLE_2_5_0_ALPHA1)
 // Enable modified rectangle selection
diff --git a/src/slic3r/GUI/3DScene.hpp b/src/slic3r/GUI/3DScene.hpp
index 9fb5a6965..4ef095223 100644
--- a/src/slic3r/GUI/3DScene.hpp
+++ b/src/slic3r/GUI/3DScene.hpp
@@ -432,23 +432,23 @@ public:
 
     const Geometry::Transformation& get_instance_transformation() const { return m_instance_transformation; }
     void set_instance_transformation(const Geometry::Transformation& transformation) { m_instance_transformation = transformation; set_bounding_boxes_as_dirty(); }
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     void set_instance_transformation(const Transform3d& transform) { m_instance_transformation.set_matrix(transform); set_bounding_boxes_as_dirty(); }
 
     Vec3d get_instance_offset() const { return m_instance_transformation.get_offset(); }
 #else
     const Vec3d& get_instance_offset() const { return m_instance_transformation.get_offset(); }
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
     double get_instance_offset(Axis axis) const { return m_instance_transformation.get_offset(axis); }
 
     void set_instance_offset(const Vec3d& offset) { m_instance_transformation.set_offset(offset); set_bounding_boxes_as_dirty(); }
     void set_instance_offset(Axis axis, double offset) { m_instance_transformation.set_offset(axis, offset); set_bounding_boxes_as_dirty(); }
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     Vec3d get_instance_rotation() const { return m_instance_transformation.get_rotation(); }
 #else
     const Vec3d& get_instance_rotation() const { return m_instance_transformation.get_rotation(); }
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
     double get_instance_rotation(Axis axis) const { return m_instance_transformation.get_rotation(axis); }
 
     void set_instance_rotation(const Vec3d& rotation) { m_instance_transformation.set_rotation(rotation); set_bounding_boxes_as_dirty(); }
@@ -460,11 +460,11 @@ public:
     void set_instance_scaling_factor(const Vec3d& scaling_factor) { m_instance_transformation.set_scaling_factor(scaling_factor); set_bounding_boxes_as_dirty(); }
     void set_instance_scaling_factor(Axis axis, double scaling_factor) { m_instance_transformation.set_scaling_factor(axis, scaling_factor); set_bounding_boxes_as_dirty(); }
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     Vec3d get_instance_mirror() const { return m_instance_transformation.get_mirror(); }
 #else
     const Vec3d& get_instance_mirror() const { return m_instance_transformation.get_mirror(); }
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
     double get_instance_mirror(Axis axis) const { return m_instance_transformation.get_mirror(axis); }
 
     void set_instance_mirror(const Vec3d& mirror) { m_instance_transformation.set_mirror(mirror); set_bounding_boxes_as_dirty(); }
@@ -472,43 +472,43 @@ public:
 
     const Geometry::Transformation& get_volume_transformation() const { return m_volume_transformation; }
     void set_volume_transformation(const Geometry::Transformation& transformation) { m_volume_transformation = transformation; set_bounding_boxes_as_dirty(); }
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     void set_volume_transformation(const Transform3d& transform) { m_volume_transformation.set_matrix(transform); set_bounding_boxes_as_dirty(); }
 
     Vec3d get_volume_offset() const { return m_volume_transformation.get_offset(); }
 #else
     const Vec3d& get_volume_offset() const { return m_volume_transformation.get_offset(); }
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
     double get_volume_offset(Axis axis) const { return m_volume_transformation.get_offset(axis); }
 
     void set_volume_offset(const Vec3d& offset) { m_volume_transformation.set_offset(offset); set_bounding_boxes_as_dirty(); }
     void set_volume_offset(Axis axis, double offset) { m_volume_transformation.set_offset(axis, offset); set_bounding_boxes_as_dirty(); }
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     Vec3d get_volume_rotation() const { return m_volume_transformation.get_rotation(); }
 #else
     const Vec3d& get_volume_rotation() const { return m_volume_transformation.get_rotation(); }
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
     double get_volume_rotation(Axis axis) const { return m_volume_transformation.get_rotation(axis); }
 
     void set_volume_rotation(const Vec3d& rotation) { m_volume_transformation.set_rotation(rotation); set_bounding_boxes_as_dirty(); }
     void set_volume_rotation(Axis axis, double rotation) { m_volume_transformation.set_rotation(axis, rotation); set_bounding_boxes_as_dirty(); }
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     Vec3d get_volume_scaling_factor() const { return m_volume_transformation.get_scaling_factor(); }
 #else
     const Vec3d& get_volume_scaling_factor() const { return m_volume_transformation.get_scaling_factor(); }
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
     double get_volume_scaling_factor(Axis axis) const { return m_volume_transformation.get_scaling_factor(axis); }
 
     void set_volume_scaling_factor(const Vec3d& scaling_factor) { m_volume_transformation.set_scaling_factor(scaling_factor); set_bounding_boxes_as_dirty(); }
     void set_volume_scaling_factor(Axis axis, double scaling_factor) { m_volume_transformation.set_scaling_factor(axis, scaling_factor); set_bounding_boxes_as_dirty(); }
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     Vec3d get_volume_mirror() const { return m_volume_transformation.get_mirror(); }
 #else
     const Vec3d& get_volume_mirror() const { return m_volume_transformation.get_mirror(); }
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
     double get_volume_mirror(Axis axis) const { return m_volume_transformation.get_mirror(axis); }
 
     void set_volume_mirror(const Vec3d& mirror) { m_volume_transformation.set_mirror(mirror); set_bounding_boxes_as_dirty(); }
diff --git a/src/slic3r/GUI/GLCanvas3D.cpp b/src/slic3r/GUI/GLCanvas3D.cpp
index 959611bea..026734711 100644
--- a/src/slic3r/GUI/GLCanvas3D.cpp
+++ b/src/slic3r/GUI/GLCanvas3D.cpp
@@ -1101,9 +1101,9 @@ wxDEFINE_EVENT(EVT_GLCANVAS_QUESTION_MARK, SimpleEvent);
 wxDEFINE_EVENT(EVT_GLCANVAS_INCREASE_INSTANCES, Event<int>);
 wxDEFINE_EVENT(EVT_GLCANVAS_INSTANCE_MOVED, SimpleEvent);
 wxDEFINE_EVENT(EVT_GLCANVAS_INSTANCE_ROTATED, SimpleEvent);
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
 wxDEFINE_EVENT(EVT_GLCANVAS_RESET_SKEW, SimpleEvent);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 wxDEFINE_EVENT(EVT_GLCANVAS_INSTANCE_SCALED, SimpleEvent);
 wxDEFINE_EVENT(EVT_GLCANVAS_FORCE_UPDATE, SimpleEvent);
 wxDEFINE_EVENT(EVT_GLCANVAS_WIPETOWER_MOVED, Vec3dEvent);
@@ -2917,13 +2917,13 @@ void GLCanvas3D::on_key(wxKeyEvent& evt)
             else
                 displacement = multiplier * direction;
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
             TransformationType trafo_type;
             trafo_type.set_relative();
             m_selection.translate(displacement, trafo_type);
 #else
             m_selection.translate(displacement);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
             m_dirty = true;
         }
     );
@@ -3588,13 +3588,13 @@ void GLCanvas3D::on_mouse(wxMouseEvent& evt)
                 }
             }
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
             TransformationType trafo_type;
             trafo_type.set_relative();
             m_selection.translate(cur_pos - m_mouse.drag.start_position_3D, trafo_type);
 #else
             m_selection.translate(cur_pos - m_mouse.drag.start_position_3D);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
             if (current_printer_technology() == ptFFF && fff_print()->config().complete_objects)
                 update_sequential_clearance();
             wxGetApp().obj_manipul()->set_dirty();
@@ -3840,17 +3840,17 @@ void GLCanvas3D::do_move(const std::string& snapshot_type)
             ModelObject* model_object = m_model->objects[object_idx];
             if (model_object != nullptr) {
                 if (selection_mode == Selection::Instance)
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
                     model_object->instances[instance_idx]->set_transformation(v->get_instance_transformation());
 #else
                     model_object->instances[instance_idx]->set_offset(v->get_instance_offset());
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
                 else if (selection_mode == Selection::Volume)
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
                     model_object->volumes[volume_idx]->set_transformation(v->get_volume_transformation());
 #else
                     model_object->volumes[volume_idx]->set_offset(v->get_volume_offset());
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 
                 object_moved = true;
                 model_object->invalidate_bounding_box();
@@ -3948,20 +3948,20 @@ void GLCanvas3D::do_rotate(const std::string& snapshot_type)
         ModelObject* model_object = m_model->objects[object_idx];
         if (model_object != nullptr) {
             if (selection_mode == Selection::Instance) {
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
                 model_object->instances[instance_idx]->set_transformation(v->get_instance_transformation());
 #else
                 model_object->instances[instance_idx]->set_rotation(v->get_instance_rotation());
                 model_object->instances[instance_idx]->set_offset(v->get_instance_offset());
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
             }
             else if (selection_mode == Selection::Volume) {
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
                 model_object->volumes[volume_idx]->set_transformation(v->get_volume_transformation());
 #else
                 model_object->volumes[volume_idx]->set_rotation(v->get_volume_rotation());
                 model_object->volumes[volume_idx]->set_offset(v->get_volume_offset());
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
             }
             model_object->invalidate_bounding_box();
         }
@@ -4024,22 +4024,22 @@ void GLCanvas3D::do_scale(const std::string& snapshot_type)
         ModelObject* model_object = m_model->objects[object_idx];
         if (model_object != nullptr) {
             if (selection_mode == Selection::Instance) {
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
                 model_object->instances[instance_idx]->set_transformation(v->get_instance_transformation());
 #else
                 model_object->instances[instance_idx]->set_scaling_factor(v->get_instance_scaling_factor());
                 model_object->instances[instance_idx]->set_offset(v->get_instance_offset());
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
             }
             else if (selection_mode == Selection::Volume) {
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
                 model_object->instances[instance_idx]->set_transformation(v->get_instance_transformation());
                 model_object->volumes[volume_idx]->set_transformation(v->get_volume_transformation());
 #else
                 model_object->instances[instance_idx]->set_offset(v->get_instance_offset());
                 model_object->volumes[volume_idx]->set_scaling_factor(v->get_volume_scaling_factor());
                 model_object->volumes[volume_idx]->set_offset(v->get_volume_offset());
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
             }
             model_object->invalidate_bounding_box();
         }
@@ -4101,17 +4101,17 @@ void GLCanvas3D::do_mirror(const std::string& snapshot_type)
         ModelObject* model_object = m_model->objects[object_idx];
         if (model_object != nullptr) {
             if (selection_mode == Selection::Instance)
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
                 model_object->instances[instance_idx]->set_transformation(v->get_instance_transformation());
 #else
                 model_object->instances[instance_idx]->set_mirror(v->get_instance_mirror());
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
             else if (selection_mode == Selection::Volume)
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
                 model_object->volumes[volume_idx]->set_transformation(v->get_volume_transformation());
 #else
                 model_object->volumes[volume_idx]->set_mirror(v->get_volume_mirror());
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 
             model_object->invalidate_bounding_box();
         }
@@ -4135,7 +4135,7 @@ void GLCanvas3D::do_mirror(const std::string& snapshot_type)
     m_dirty = true;
 }
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
 void GLCanvas3D::do_reset_skew(const std::string& snapshot_type)
 {
     if (m_model == nullptr)
@@ -4171,7 +4171,7 @@ void GLCanvas3D::do_reset_skew(const std::string& snapshot_type)
 
     m_dirty = true;
 }
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 
 void GLCanvas3D::update_gizmos_on_off_state()
 {
diff --git a/src/slic3r/GUI/GLCanvas3D.hpp b/src/slic3r/GUI/GLCanvas3D.hpp
index 9cf6501fc..18ad42ae1 100644
--- a/src/slic3r/GUI/GLCanvas3D.hpp
+++ b/src/slic3r/GUI/GLCanvas3D.hpp
@@ -156,9 +156,9 @@ wxDECLARE_EVENT(EVT_GLCANVAS_INSTANCE_MOVED, SimpleEvent);
 wxDECLARE_EVENT(EVT_GLCANVAS_FORCE_UPDATE, SimpleEvent);
 wxDECLARE_EVENT(EVT_GLCANVAS_WIPETOWER_MOVED, Vec3dEvent);
 wxDECLARE_EVENT(EVT_GLCANVAS_INSTANCE_ROTATED, SimpleEvent);
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
 wxDECLARE_EVENT(EVT_GLCANVAS_RESET_SKEW, SimpleEvent);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 wxDECLARE_EVENT(EVT_GLCANVAS_INSTANCE_SCALED, SimpleEvent);
 wxDECLARE_EVENT(EVT_GLCANVAS_WIPETOWER_ROTATED, Vec3dEvent);
 wxDECLARE_EVENT(EVT_GLCANVAS_ENABLE_ACTION_BUTTONS, Event<bool>);
@@ -742,11 +742,11 @@ public:
 
     void update_volumes_colors_by_extruder();
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     bool is_dragging() const { return m_gizmos.is_dragging() || (m_moving && !m_mouse.scene_position.isApprox(m_mouse.drag.start_position_3D)); }
 #else
     bool is_dragging() const { return m_gizmos.is_dragging() || m_moving; }
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 
     void render();
     // printable_only == false -> render also non printable volumes as grayed
@@ -814,9 +814,9 @@ public:
     void do_rotate(const std::string& snapshot_type);
     void do_scale(const std::string& snapshot_type);
     void do_mirror(const std::string& snapshot_type);
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     void do_reset_skew(const std::string& snapshot_type);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 
     void update_gizmos_on_off_state();
     void reset_all_gizmos() { m_gizmos.reset_all_states(); }
diff --git a/src/slic3r/GUI/GUI_ObjectList.cpp b/src/slic3r/GUI/GUI_ObjectList.cpp
index a8c9819a6..bfedd8e1e 100644
--- a/src/slic3r/GUI/GUI_ObjectList.cpp
+++ b/src/slic3r/GUI/GUI_ObjectList.cpp
@@ -1532,11 +1532,11 @@ void ObjectList::load_modifier(const wxArrayString& input_files, ModelObject& mo
     // First (any) GLVolume of the selected instance. They all share the same instance matrix.
     const GLVolume* v = selection.get_first_volume();
     const Geometry::Transformation inst_transform = v->get_instance_transformation();
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     const Transform3d inv_inst_transform = inst_transform.get_matrix_no_offset().inverse();
 #else
     const Transform3d inv_inst_transform = inst_transform.get_matrix(true).inverse();
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
     const Vec3d instance_offset = v->get_instance_offset();
 
     for (size_t i = 0; i < input_files.size(); ++i) {
@@ -1584,7 +1584,7 @@ void ObjectList::load_modifier(const wxArrayString& input_files, ModelObject& mo
             new_volume->source.mesh_offset = model.objects.front()->volumes.front()->source.mesh_offset;
 
         if (from_galery) {
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
             // Transform the new modifier to be aligned with the print bed.
             new_volume->set_transformation(v->get_instance_transformation().get_matrix_no_offset().inverse());
             const BoundingBoxf3 mesh_bb = new_volume->mesh().bounding_box();
@@ -1592,7 +1592,7 @@ void ObjectList::load_modifier(const wxArrayString& input_files, ModelObject& mo
             // Transform the new modifier to be aligned with the print bed.
             const BoundingBoxf3 mesh_bb = new_volume->mesh().bounding_box();
             new_volume->set_transformation(Geometry::Transformation::volume_to_bed_transformation(inst_transform, mesh_bb));
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
             // Set the modifier position.
             // Translate the new modifier to be pickable: move to the left front corner of the instance's bounding box, lift to print bed.
             const Vec3d offset = Vec3d(instance_bb.max.x(), instance_bb.min.y(), instance_bb.min.z()) + 0.5 * mesh_bb.size() - instance_offset;
@@ -1661,7 +1661,7 @@ void ObjectList::load_generic_subobject(const std::string& type_name, const Mode
 
     // First (any) GLVolume of the selected instance. They all share the same instance matrix.
     const GLVolume* v = selection.get_first_volume();
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     // Transform the new modifier to be aligned with the print bed.
     new_volume->set_transformation(v->get_instance_transformation().get_matrix_no_offset().inverse());
     const BoundingBoxf3 mesh_bb = new_volume->mesh().bounding_box();
@@ -1669,18 +1669,18 @@ void ObjectList::load_generic_subobject(const std::string& type_name, const Mode
     // Transform the new modifier to be aligned with the print bed.
     const BoundingBoxf3 mesh_bb = new_volume->mesh().bounding_box();
     new_volume->set_transformation(Geometry::Transformation::volume_to_bed_transformation(v->get_instance_transformation(), mesh_bb));
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
     // Set the modifier position.
     auto offset = (type_name == "Slab") ?
         // Slab: Lift to print bed
 		Vec3d(0., 0., 0.5 * mesh_bb.size().z() + instance_bb.min.z() - v->get_instance_offset().z()) :
         // Translate the new modifier to be pickable: move to the left front corner of the instance's bounding box, lift to print bed.
         Vec3d(instance_bb.max.x(), instance_bb.min.y(), instance_bb.min.z()) + 0.5 * mesh_bb.size() - v->get_instance_offset();
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     new_volume->set_offset(v->get_instance_transformation().get_matrix_no_offset().inverse() * offset);
 #else
     new_volume->set_offset(v->get_instance_transformation().get_matrix(true).inverse() * offset);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 
     const wxString name = _L("Generic") + "-" + _(type_name);
     new_volume->name = into_u8(name);
diff --git a/src/slic3r/GUI/GUI_ObjectManipulation.cpp b/src/slic3r/GUI/GUI_ObjectManipulation.cpp
index 8f5445f54..24ae01389 100644
--- a/src/slic3r/GUI/GUI_ObjectManipulation.cpp
+++ b/src/slic3r/GUI/GUI_ObjectManipulation.cpp
@@ -354,11 +354,7 @@ ObjectManipulation::ObjectManipulation(wxWindow* parent) :
             const GLVolume* volume = selection.get_first_volume();
             const double min_z = get_volume_min_z(*volume);
             if (!is_world_coordinates()) {
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
                 const Vec3d diff = m_cache.position - volume->get_instance_transformation().get_matrix_no_offset().inverse() * (min_z * Vec3d::UnitZ());
-#else
-                const Vec3d diff = m_cache.position - volume->get_instance_transformation().get_matrix(true).inverse() * (min_z * Vec3d::UnitZ());
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
 
                 Plater::TakeSnapshot snapshot(wxGetApp().plater(), _L("Drop to bed"));
                 change_position_value(0, diff.x());
@@ -385,11 +381,7 @@ ObjectManipulation::ObjectManipulation(wxWindow* parent) :
             const double min_z = selection.get_scaled_instance_bounding_box().min.z();
             if (!is_world_coordinates()) {
                 const GLVolume* volume = selection.get_first_volume();
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
                 const Vec3d diff = m_cache.position - volume->get_instance_transformation().get_matrix_no_offset().inverse() * (min_z * Vec3d::UnitZ());
-#else
-                const Vec3d diff = m_cache.position - volume->get_instance_transformation().get_matrix(true).inverse() * (min_z * Vec3d::UnitZ());
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
 
                 Plater::TakeSnapshot snapshot(wxGetApp().plater(), _L("Drop to bed"));
                 change_position_value(0, diff.x());
@@ -460,7 +452,7 @@ ObjectManipulation::ObjectManipulation(wxWindow* parent) :
     m_reset_scale_button = new ScalableButton(parent, wxID_ANY, ScalableBitmap(parent, "undo"));
     m_reset_scale_button->SetToolTip(_L("Reset scale"));
     m_reset_scale_button->Bind(wxEVT_BUTTON, [this](wxCommandEvent& e) {
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
         GLCanvas3D* canvas = wxGetApp().plater()->canvas3D();
         Selection& selection = canvas->get_selection();
         if (selection.is_single_volume_or_modifier())
@@ -481,8 +473,8 @@ ObjectManipulation::ObjectManipulation(wxWindow* parent) :
         change_scale_value(0, 100.);
         change_scale_value(1, 100.);
         change_scale_value(2, 100.);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
-    });
+#endif // ENABLE_WORLD_COORDINATE
+        });
     editors_grid_sizer->Add(m_reset_scale_button);
 
     for (size_t axis_idx = 0; axis_idx < sizeof(axes); axis_idx++)
@@ -492,7 +484,7 @@ ObjectManipulation::ObjectManipulation(wxWindow* parent) :
 
     m_main_grid_sizer->Add(editors_grid_sizer, 1, wxEXPAND);
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     m_skew_label = new wxStaticText(parent, wxID_ANY, _L("Skew"));
     m_main_grid_sizer->Add(m_skew_label, 1, wxEXPAND);
 
@@ -509,7 +501,7 @@ ObjectManipulation::ObjectManipulation(wxWindow* parent) :
         }
         });
     m_main_grid_sizer->Add(m_reset_skew_button);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 
     m_check_inch = new wxCheckBox(parent, wxID_ANY, _L("Inches"));
     m_check_inch->SetFont(wxGetApp().normal_font());
@@ -651,21 +643,15 @@ void ObjectManipulation::update_settings_value(const Selection& selection)
         const GLVolume* volume = selection.get_first_volume();
 #if !ENABLE_WORLD_COORDINATE
         m_new_position = volume->get_instance_offset();
-#endif // !ENABLE_WORLD_COORDINATE
 
-#if !ENABLE_TRANSFORMATIONS_BY_MATRICES
         // Verify whether the instance rotation is multiples of 90 degrees, so that the scaling in world coordinates is possible.
-#if ENABLE_WORLD_COORDINATE
-        if (is_world_coordinates() && !m_uniform_scale &&
-#else
         if (m_world_coordinates && ! m_uniform_scale &&
-#endif // ENABLE_WORLD_COORDINATE
             ! Geometry::is_rotation_ninety_degrees(volume->get_instance_rotation())) {
 			// Manipulating an instance in the world coordinate system, rotation is not multiples of ninety degrees, therefore enforce uniform scaling.
 			m_uniform_scale = true;
 			m_lock_bnt->SetLock(true);
 		}
-#endif // !ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // !ENABLE_WORLD_COORDINATE
 
 #if ENABLE_WORLD_COORDINATE
         if (is_world_coordinates()) {
@@ -674,32 +660,19 @@ void ObjectManipulation::update_settings_value(const Selection& selection)
         if (m_world_coordinates) {
 #endif // ENABLE_WORLD_COORDINATE
             m_new_rotate_label_string = L("Rotate");
-#if !ENABLE_TRANSFORMATIONS_BY_MATRICES
-#if ENABLE_WORLD_COORDINATE
-            m_new_scale_label_string = L("Scale");
-#endif // ENABLE_WORLD_COORDINATE
-#endif // !ENABLE_TRANSFORMATIONS_BY_MATRICES
             m_new_rotation = Vec3d::Zero();
             m_new_size     = selection.get_scaled_instance_bounding_box().size();
-#if ENABLE_WORLD_COORDINATE && !ENABLE_TRANSFORMATIONS_BY_MATRICES
-            m_new_scale    = Vec3d(100.0, 100.0, 100.0);
-#else
             m_new_scale    = m_new_size.cwiseQuotient(selection.get_unscaled_instance_bounding_box().size()) * 100.0;
-#endif // ENABLE_WORLD_COORDINATE && !ENABLE_TRANSFORMATIONS_BY_MATRICES
         }
         else {
 #if ENABLE_WORLD_COORDINATE
             m_new_move_label_string = L("Translate");
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
             m_new_rotate_label_string = L("Rotate");
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
             m_new_position = Vec3d::Zero();
-#endif // ENABLE_WORLD_COORDINATE
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
             m_new_rotation = Vec3d::Zero();
 #else
             m_new_rotation = volume->get_instance_rotation() * (180.0 / M_PI);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
             m_new_size     = volume->get_instance_scaling_factor().cwiseProduct(wxGetApp().model().objects[volume->object_idx()]->raw_mesh_bounding_box().size());
             m_new_scale    = volume->get_instance_scaling_factor() * 100.0;
 		}
@@ -731,28 +704,15 @@ void ObjectManipulation::update_settings_value(const Selection& selection)
 
             m_new_position = offset;
             m_new_rotate_label_string = L("Rotate");
-#if !ENABLE_TRANSFORMATIONS_BY_MATRICES
-            m_new_scale_label_string = L("Scale");
-#endif // !ENABLE_TRANSFORMATIONS_BY_MATRICES
             m_new_rotation = Vec3d::Zero();
             m_new_size = volume->transformed_convex_hull_bounding_box(trafo.get_matrix()).size();
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
             m_new_scale = m_new_size.cwiseQuotient(volume->transformed_convex_hull_bounding_box(volume->get_instance_transformation().get_matrix() * volume->get_volume_transformation().get_matrix_no_scaling_factor()).size()) * 100.0;
-#else
-            m_new_scale = Vec3d(100.0, 100.0, 100.0);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
         }
         else if (is_local_coordinates()) {
             m_new_move_label_string = L("Translate");
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
             m_new_rotate_label_string = L("Rotate");
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
             m_new_position = Vec3d::Zero();
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
             m_new_rotation = Vec3d::Zero();
-#else
-            m_new_rotation = volume->get_volume_rotation() * (180.0 / M_PI);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
             m_new_scale = volume->get_volume_scaling_factor() * 100.0;
             m_new_size = volume->get_volume_scaling_factor().cwiseProduct(volume->bounding_box().size());
         }
@@ -760,19 +720,10 @@ void ObjectManipulation::update_settings_value(const Selection& selection)
 #endif // ENABLE_WORLD_COORDINATE
         m_new_position = volume->get_volume_offset();
         m_new_rotate_label_string = L("Rotate");
-#if !ENABLE_TRANSFORMATIONS_BY_MATRICES
-#if ENABLE_WORLD_COORDINATE
-        m_new_scale_label_string = L("Scale");
-#endif // ENABLE_WORLD_COORDINATE
-#endif // !ENABLE_TRANSFORMATIONS_BY_MATRICES
         m_new_rotation = Vec3d::Zero();
 #if ENABLE_WORLD_COORDINATE
             m_new_size = volume->transformed_convex_hull_bounding_box(volume->get_volume_transformation().get_matrix()).size();
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
             m_new_scale = m_new_size.cwiseQuotient(volume->transformed_convex_hull_bounding_box(volume->get_volume_transformation().get_matrix_no_scaling_factor()).size()) * 100.0;
-#else
-            m_new_scale = Vec3d(100.0, 100.0, 100.0);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
         }
 #else
         m_new_scale    = volume->get_volume_scaling_factor() * 100.0;
@@ -843,29 +794,20 @@ void ObjectManipulation::update_if_dirty()
         update(m_cache.rotation, m_cache.rotation_rounded, meRotation, m_new_rotation);
     }
 
-#if !ENABLE_TRANSFORMATIONS_BY_MATRICES
-#if ENABLE_WORLD_COORDINATE
-    Selection::EUniformScaleRequiredReason reason;
-    if (selection.requires_uniform_scale(&reason)) {
-        wxString tooltip = _L("You cannot use non-uniform scaling mode for multiple objects/parts selection");
-        m_lock_bnt->SetToolTip(tooltip);
-#else
+#if !ENABLE_WORLD_COORDINATE
     if (selection.requires_uniform_scale()) {
         m_lock_bnt->SetLock(true);
         m_lock_bnt->SetToolTip(_L("You cannot use non-uniform scaling mode for multiple objects/parts selection"));
         m_lock_bnt->disable();
-#endif // ENABLE_WORLD_COORDINATE
     }
     else {
-#endif // !ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // !ENABLE_WORLD_COORDINATE
         m_lock_bnt->SetLock(m_uniform_scale);
         m_lock_bnt->SetToolTip(wxEmptyString);
         m_lock_bnt->enable();
-#if !ENABLE_TRANSFORMATIONS_BY_MATRICES
-    }
-#endif // !ENABLE_TRANSFORMATIONS_BY_MATRICES
-
 #if !ENABLE_WORLD_COORDINATE
+    }
+
     {
         int new_selection = m_world_coordinates ? 0 : 1; 
         if (m_word_local_combo->GetSelection() != new_selection)
@@ -898,35 +840,18 @@ void ObjectManipulation::update_reset_buttons_visibility()
     bool show_rotation = false;
     bool show_scale = false;
     bool show_drop_to_bed = false;
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
-    bool show_skew = false;
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
-
 #if ENABLE_WORLD_COORDINATE
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+    bool show_skew = false;
+
     if (selection.is_single_full_instance() || selection.is_single_volume_or_modifier()) {
-#else
-    if ((m_coordinates_type == ECoordinatesType::World && selection.is_single_full_instance()) ||
-        (m_coordinates_type == ECoordinatesType::Instance && selection.is_single_volume_or_modifier())) {
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
         const double min_z = selection.is_single_full_instance() ? selection.get_scaled_instance_bounding_box().min.z() :
             get_volume_min_z(*selection.get_first_volume());
 
         show_drop_to_bed = std::abs(min_z) > EPSILON;
-#if !ENABLE_TRANSFORMATIONS_BY_MATRICES
-    }
-
-    if (m_coordinates_type == ECoordinatesType::Local && (selection.is_single_full_instance() || selection.is_single_volume_or_modifier())) {
-#endif // !ENABLE_TRANSFORMATIONS_BY_MATRICES
         const GLVolume* volume = selection.get_first_volume();
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
         Transform3d rotation = Transform3d::Identity();
         Transform3d scale = Transform3d::Identity();
         Geometry::Transformation skew;
-#else
-        Vec3d rotation = Vec3d::Zero();
-        Vec3d scale = Vec3d::Ones();
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
 #else
     if (selection.is_single_full_instance() || selection.is_single_modifier() || selection.is_single_volume()) {
         const GLVolume* volume = selection.get_first_volume();
@@ -936,7 +861,7 @@ void ObjectManipulation::update_reset_buttons_visibility()
 #endif // ENABLE_WORLD_COORDINATE
 
         if (selection.is_single_full_instance()) {
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
             const Geometry::Transformation& trafo = volume->get_instance_transformation();
             rotation = trafo.get_rotation_matrix();
             scale = trafo.get_scaling_factor_matrix();
@@ -951,13 +876,11 @@ void ObjectManipulation::update_reset_buttons_visibility()
 #else
             rotation = volume->get_instance_rotation();
             scale = volume->get_instance_scaling_factor();
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
-#if !ENABLE_WORLD_COORDINATE
             min_z = selection.get_scaled_instance_bounding_box().min.z();
-#endif // !ENABLE_WORLD_COORDINATE
+#endif // ENABLE_WORLD_COORDINATE
         }
         else {
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
             const Geometry::Transformation& trafo = volume->get_volume_transformation();
             rotation = trafo.get_rotation_matrix();
             scale = trafo.get_scaling_factor_matrix();
@@ -967,29 +890,25 @@ void ObjectManipulation::update_reset_buttons_visibility()
 #else
             rotation = volume->get_volume_rotation();
             scale = volume->get_volume_scaling_factor();
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
-#if !ENABLE_WORLD_COORDINATE
             min_z = get_volume_min_z(*volume);
-#endif // !ENABLE_WORLD_COORDINATE
+#endif // ENABLE_WORLD_COORDINATE
         }
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
         show_rotation = !rotation.isApprox(Transform3d::Identity());
         show_scale = !scale.isApprox(Transform3d::Identity());
         show_skew = skew.has_skew();
 #else
         show_rotation = !rotation.isApprox(Vec3d::Zero());
         show_scale = !scale.isApprox(Vec3d::Ones());
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
-#if !ENABLE_WORLD_COORDINATE
         show_drop_to_bed = std::abs(min_z) > SINKING_Z_THRESHOLD;
-#endif // !ENABLE_WORLD_COORDINATE
+#endif // ENABLE_WORLD_COORDINATE
     }
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     wxGetApp().CallAfter([this, show_rotation, show_scale, show_drop_to_bed, show_skew] {
 #else
     wxGetApp().CallAfter([this, show_rotation, show_scale, show_drop_to_bed] {
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
         // There is a case (under OSX), when this function is called after the Manipulation panel is hidden
         // So, let check if Manipulation panel is still shown for this moment
         if (!this->IsShown())
@@ -997,10 +916,10 @@ void ObjectManipulation::update_reset_buttons_visibility()
         m_reset_rotation_button->Show(show_rotation);
         m_reset_scale_button->Show(show_scale);
         m_drop_to_bed_button->Show(show_drop_to_bed);
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
         m_reset_skew_button->Show(show_skew);
         m_skew_label->Show(show_skew);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 
         // Because of CallAfter we need to layout sidebar after Show/hide of reset buttons one more time
         Sidebar& panel = wxGetApp().sidebar();
@@ -1131,7 +1050,6 @@ void ObjectManipulation::change_position_value(int axis, double value)
     Selection& selection = canvas->get_selection();
     selection.setup_cache();
 #if ENABLE_WORLD_COORDINATE
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
     TransformationType trafo_type;
     trafo_type.set_relative();
     switch (get_coordinates_type())
@@ -1141,9 +1059,6 @@ void ObjectManipulation::change_position_value(int axis, double value)
     default:                         { break; }
     }
     selection.translate(position - m_cache.position, trafo_type);
-#else
-    selection.translate(position - m_cache.position, get_coordinates_type());
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
 #else
     selection.translate(position - m_cache.position, selection.requires_local_axes());
 #endif // ENABLE_WORLD_COORDINATE
@@ -1166,21 +1081,13 @@ void ObjectManipulation::change_rotation_value(int axis, double value)
     Selection& selection = canvas->get_selection();
 
 #if ENABLE_WORLD_COORDINATE
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
     TransformationType transformation_type;
     transformation_type.set_relative();
-#else
-    TransformationType transformation_type(TransformationType::World_Relative_Joint);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
     if (selection.is_single_full_instance())
         transformation_type.set_independent();
 
-    if (is_local_coordinates()) {
+    if (is_local_coordinates())
         transformation_type.set_local();
-#if !ENABLE_TRANSFORMATIONS_BY_MATRICES
-        transformation_type.set_absolute();
-#endif // !ENABLE_TRANSFORMATIONS_BY_MATRICES
-    }
 
     if (is_instance_coordinates())
         transformation_type.set_instance();
@@ -1286,28 +1193,10 @@ void ObjectManipulation::do_scale(int axis, const Vec3d &scale) const
     else if (is_instance_coordinates())
         transformation_type.set_instance();
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
     if (!selection.is_single_full_instance() && !selection.is_single_volume_or_modifier())
         transformation_type.set_relative();
 
     const Vec3d scaling_factor = m_uniform_scale ? scale(axis) * Vec3d::Ones() : scale;
-#else
-    if (!is_local_coordinates())
-        transformation_type.set_relative();
-
-    bool uniform_scale = m_uniform_scale || selection.requires_uniform_scale();
-    Vec3d scaling_factor = uniform_scale ? scale(axis) * Vec3d::Ones() : scale;
-
-    if (!uniform_scale && is_world_coordinates()) {
-        if (selection.is_single_full_instance())
-            scaling_factor = (Geometry::assemble_transform(Vec3d::Zero(), selection.get_first_volume()->get_instance_rotation()).inverse() * scaling_factor).cwiseAbs();
-        else if (selection.is_single_volume_or_modifier()) {
-            const Transform3d mi = Geometry::assemble_transform(Vec3d::Zero(), selection.get_first_volume()->get_instance_rotation()).inverse();
-            const Transform3d mv = Geometry::assemble_transform(Vec3d::Zero(), selection.get_first_volume()->get_volume_rotation()).inverse();
-            scaling_factor = (mv * mi * scaling_factor).cwiseAbs();
-        }
-    }
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
 #else
     TransformationType transformation_type(TransformationType::World_Relative_Joint);
     if (selection.is_single_full_instance()) {
@@ -1336,28 +1225,7 @@ void ObjectManipulation::do_size(int axis, const Vec3d& scale) const
     else if (is_instance_coordinates())
         transformation_type.set_instance();
 
-#if !ENABLE_TRANSFORMATIONS_BY_MATRICES
-    if (!is_local_coordinates())
-        transformation_type.set_relative();
-#endif // !ENABLE_TRANSFORMATIONS_BY_MATRICES
-
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
-    Vec3d scaling_factor = m_uniform_scale ? scale(axis) * Vec3d::Ones() : scale;
-#else
-    bool uniform_scale = m_uniform_scale || selection.requires_uniform_scale();
-    Vec3d scaling_factor = uniform_scale ? scale(axis) * Vec3d::Ones() : scale;
-
-    if (!uniform_scale && is_world_coordinates()) {
-        if (selection.is_single_full_instance())
-            scaling_factor = (Geometry::assemble_transform(Vec3d::Zero(), selection.get_first_volume()->get_instance_rotation()).inverse() * scaling_factor).cwiseAbs();
-        else if (selection.is_single_volume_or_modifier()) {
-            const Transform3d mi = Geometry::assemble_transform(Vec3d::Zero(), selection.get_first_volume()->get_instance_rotation()).inverse();
-            const Transform3d mv = Geometry::assemble_transform(Vec3d::Zero(), selection.get_first_volume()->get_volume_rotation()).inverse();
-            scaling_factor = (mv * mi * scaling_factor).cwiseAbs();
-        }
-    }
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
-
+    const Vec3d scaling_factor = m_uniform_scale ? scale(axis) * Vec3d::Ones() : scale;
     selection.setup_cache();
     selection.scale(scaling_factor, transformation_type);
     wxGetApp().plater()->canvas3D()->do_scale(L("Set Size"));
@@ -1400,30 +1268,16 @@ void ObjectManipulation::on_change(const std::string& opt_key, int axis, double
 
 void ObjectManipulation::set_uniform_scaling(const bool use_uniform_scale)
 { 
-#if !ENABLE_TRANSFORMATIONS_BY_MATRICES
-    const Selection &selection = wxGetApp().plater()->canvas3D()->get_selection();
-#endif // !ENABLE_TRANSFORMATIONS_BY_MATRICES
 #if ENABLE_WORLD_COORDINATE
-    if (!use_uniform_scale) {
-#if !ENABLE_TRANSFORMATIONS_BY_MATRICES
-        int res = selection.bake_transform_if_needed();
-        if (res == -1) {
-            // Enforce uniform scaling.
-            m_lock_bnt->SetLock(true);
-            return;
-        }
-        else if (res == 0)
-#endif // !ENABLE_TRANSFORMATIONS_BY_MATRICES
-            // Recalculate cached values at this panel, refresh the screen.
-            this->UpdateAndShow(true);
-    }
+    if (!use_uniform_scale)
+        // Recalculate cached values at this panel, refresh the screen.
+        this->UpdateAndShow(true);
 
     m_uniform_scale = use_uniform_scale;
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
     set_dirty();
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
 #else
+    const Selection& selection = wxGetApp().plater()->canvas3D()->get_selection();
     if (selection.is_single_full_instance() && m_world_coordinates && !use_uniform_scale) {
         // Verify whether the instance rotation is multiples of 90 degrees, so that the scaling in world coordinates is possible.
         // all volumes in the selection belongs to the same instance, any of them contains the needed instance data, so we take the first one
@@ -1493,9 +1347,9 @@ void ObjectManipulation::msw_rescale()
     m_mirror_bitmap_hidden.msw_rescale();
     m_reset_scale_button->msw_rescale();
     m_reset_rotation_button->msw_rescale();
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     m_reset_skew_button->msw_rescale();
-#endif /// ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif /// ENABLE_WORLD_COORDINATE
     m_drop_to_bed_button->msw_rescale();
     m_lock_bnt->msw_rescale();
 
@@ -1535,9 +1389,9 @@ void ObjectManipulation::sys_color_changed()
     m_mirror_bitmap_hidden.msw_rescale();
     m_reset_scale_button->msw_rescale();
     m_reset_rotation_button->msw_rescale();
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     m_reset_skew_button->msw_rescale();
-#endif /// ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
     m_drop_to_bed_button->msw_rescale();
     m_lock_bnt->msw_rescale();
 
diff --git a/src/slic3r/GUI/GUI_ObjectManipulation.hpp b/src/slic3r/GUI/GUI_ObjectManipulation.hpp
index e25e05f60..cfa43b43a 100644
--- a/src/slic3r/GUI/GUI_ObjectManipulation.hpp
+++ b/src/slic3r/GUI/GUI_ObjectManipulation.hpp
@@ -122,9 +122,9 @@ private:
     // Non-owning pointers to the reset buttons, so we can hide and show them.
     ScalableButton* m_reset_scale_button{ nullptr };
     ScalableButton* m_reset_rotation_button{ nullptr };
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     ScalableButton* m_reset_skew_button{ nullptr };
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
     ScalableButton* m_drop_to_bed_button{ nullptr };
 
     wxCheckBox*     m_check_inch {nullptr};
@@ -179,9 +179,9 @@ private:
     wxFlexGridSizer* m_main_grid_sizer;
     wxFlexGridSizer* m_labels_grid_sizer;
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     wxStaticText* m_skew_label{ nullptr };
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 
     // sizers, used for msw_rescale
     wxBoxSizer*     m_word_local_combo_sizer;
diff --git a/src/slic3r/GUI/Gizmos/GLGizmoFdmSupports.cpp b/src/slic3r/GUI/Gizmos/GLGizmoFdmSupports.cpp
index a52c85d67..49e97ee1f 100644
--- a/src/slic3r/GUI/Gizmos/GLGizmoFdmSupports.cpp
+++ b/src/slic3r/GUI/Gizmos/GLGizmoFdmSupports.cpp
@@ -341,11 +341,11 @@ void GLGizmoFdmSupports::select_facets_by_angle(float threshold_deg, bool block)
 
         ++mesh_id;
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
         const Transform3d trafo_matrix = mi->get_matrix_no_offset() * mv->get_matrix_no_offset();
 #else
         const Transform3d trafo_matrix = mi->get_matrix(true) * mv->get_matrix(true);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
         Vec3f down  = (trafo_matrix.inverse() * (-Vec3d::UnitZ())).cast<float>().normalized();
         Vec3f limit = (trafo_matrix.inverse() * Vec3d(std::sin(threshold), 0, -std::cos(threshold))).cast<float>().normalized();
 
diff --git a/src/slic3r/GUI/Gizmos/GLGizmoFlatten.cpp b/src/slic3r/GUI/Gizmos/GLGizmoFlatten.cpp
index 9bac7f293..f854edb81 100644
--- a/src/slic3r/GUI/Gizmos/GLGizmoFlatten.cpp
+++ b/src/slic3r/GUI/Gizmos/GLGizmoFlatten.cpp
@@ -228,11 +228,11 @@ void GLGizmoFlatten::update_planes()
     }
     ch = ch.convex_hull_3d();
     m_planes.clear();
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     const Transform3d inst_matrix = mo->instances.front()->get_matrix_no_offset();
 #else
     const Transform3d& inst_matrix = mo->instances.front()->get_matrix(true);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 
     // Following constants are used for discarding too small polygons.
     const float minimal_area = 5.f; // in square mm (world coordinates)
diff --git a/src/slic3r/GUI/Gizmos/GLGizmoHollow.cpp b/src/slic3r/GUI/Gizmos/GLGizmoHollow.cpp
index 8ef23d538..7272a5ef7 100644
--- a/src/slic3r/GUI/Gizmos/GLGizmoHollow.cpp
+++ b/src/slic3r/GUI/Gizmos/GLGizmoHollow.cpp
@@ -121,11 +121,11 @@ void GLGizmoHollow::render_points(const Selection& selection, bool picking)
     Geometry::Transformation trafo =  vol->get_instance_transformation() * vol->get_volume_transformation();
 
 #if ENABLE_GL_SHADERS_ATTRIBUTES
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     const Transform3d instance_scaling_matrix_inverse = vol->get_instance_transformation().get_scaling_factor_matrix().inverse();
 #else
     const Transform3d instance_scaling_matrix_inverse = vol->get_instance_transformation().get_matrix(true, true, false, true).inverse();
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
     const Transform3d instance_matrix = Geometry::translation_transform(m_c->selection_info()->get_sla_shift() * Vec3d::UnitZ()) * trafo.get_matrix();
 
     const Camera& camera = wxGetApp().plater()->get_camera();
diff --git a/src/slic3r/GUI/Gizmos/GLGizmoMove.cpp b/src/slic3r/GUI/Gizmos/GLGizmoMove.cpp
index 04ccfb4c8..79aed06b9 100644
--- a/src/slic3r/GUI/Gizmos/GLGizmoMove.cpp
+++ b/src/slic3r/GUI/Gizmos/GLGizmoMove.cpp
@@ -98,19 +98,11 @@ void GLGizmoMove3D::on_start_dragging()
         m_starting_drag_position = m_center + m_grabbers[m_hover_id].center;
     else if (coordinates_type == ECoordinatesType::Local && selection.is_single_volume_or_modifier()) {
         const GLVolume& v = *selection.get_first_volume();
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
         m_starting_drag_position = m_center + v.get_instance_transformation().get_rotation_matrix() * v.get_volume_transformation().get_rotation_matrix() * m_grabbers[m_hover_id].center;
-#else
-        m_starting_drag_position = m_center + Geometry::assemble_transform(Vec3d::Zero(), v.get_instance_rotation()) * Geometry::assemble_transform(Vec3d::Zero(), v.get_volume_rotation()) * m_grabbers[m_hover_id].center;
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
     }
     else {
         const GLVolume& v = *selection.get_first_volume();
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
         m_starting_drag_position = m_center + v.get_instance_transformation().get_rotation_matrix() * m_grabbers[m_hover_id].center;
-#else
-        m_starting_drag_position = m_center + Geometry::assemble_transform(Vec3d::Zero(), v.get_instance_rotation()) * m_grabbers[m_hover_id].center;
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
     }
     m_starting_box_center = m_center;
     m_starting_box_bottom_center = m_center;
@@ -141,7 +133,6 @@ void GLGizmoMove3D::on_dragging(const UpdateData& data)
         
     Selection &selection = m_parent.get_selection();
 #if ENABLE_WORLD_COORDINATE
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
     TransformationType trafo_type;
     trafo_type.set_relative();
     switch (wxGetApp().obj_manipul()->get_coordinates_type())
@@ -151,9 +142,6 @@ void GLGizmoMove3D::on_dragging(const UpdateData& data)
     default: { break; }
     }
     selection.translate(m_displacement, trafo_type);
-#else
-    selection.translate(m_displacement, wxGetApp().obj_manipul()->get_coordinates_type());
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
 #else
     selection.translate(m_displacement);
 #endif // ENABLE_WORLD_COORDINATE
@@ -529,17 +517,9 @@ Transform3d GLGizmoMove3D::local_transform(const Selection& selection) const
     Transform3d ret = Geometry::assemble_transform(m_center);
     if (!wxGetApp().obj_manipul()->is_world_coordinates()) {
         const GLVolume& v = *selection.get_first_volume();
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
         Transform3d orient_matrix = v.get_instance_transformation().get_rotation_matrix();
-#else
-        Transform3d orient_matrix = v.get_instance_transformation().get_matrix(true, false, true, true);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
         if (selection.is_single_volume_or_modifier() && wxGetApp().obj_manipul()->is_local_coordinates())
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
             orient_matrix = orient_matrix * v.get_volume_transformation().get_rotation_matrix();
-#else
-            orient_matrix = orient_matrix * v.get_volume_transformation().get_matrix(true, false, true, true);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
         ret = ret * orient_matrix;
     }
     return ret;
@@ -569,12 +549,8 @@ void GLGizmoMove3D::calc_selection_box_and_center()
     }
     else if (coordinates_type == ECoordinatesType::Local && selection.is_single_volume_or_modifier()) {
         const GLVolume& v = *selection.get_first_volume();
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
         m_bounding_box = v.transformed_convex_hull_bounding_box(
             v.get_instance_transformation().get_scaling_factor_matrix() * v.get_volume_transformation().get_scaling_factor_matrix());
-#else
-        m_bounding_box = v.transformed_convex_hull_bounding_box(v.get_instance_transformation().get_matrix(true, true, false, true) * v.get_volume_transformation().get_matrix(true, true, false, true));
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
         m_center = v.world_matrix() * m_bounding_box.center();
     }
     else {
@@ -584,14 +560,9 @@ void GLGizmoMove3D::calc_selection_box_and_center()
             const GLVolume& v = *selection.get_volume(id);
             m_bounding_box.merge(v.transformed_convex_hull_bounding_box(v.get_volume_transformation().get_matrix()));
         }
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
         const Geometry::Transformation inst_trafo = selection.get_first_volume()->get_instance_transformation();
         m_bounding_box = m_bounding_box.transformed(inst_trafo.get_scaling_factor_matrix());
         m_center = inst_trafo.get_matrix_no_scaling_factor() * m_bounding_box.center();
-#else
-        m_bounding_box = m_bounding_box.transformed(selection.get_first_volume()->get_instance_transformation().get_matrix(true, true, false, true));
-        m_center = selection.get_first_volume()->get_instance_transformation().get_matrix(false, false, true, false) * m_bounding_box.center();
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
     }
 }
 #endif // ENABLE_WORLD_COORDINATE
diff --git a/src/slic3r/GUI/Gizmos/GLGizmoPainterBase.cpp b/src/slic3r/GUI/Gizmos/GLGizmoPainterBase.cpp
index c7731f1ff..4e03abb33 100644
--- a/src/slic3r/GUI/Gizmos/GLGizmoPainterBase.cpp
+++ b/src/slic3r/GUI/Gizmos/GLGizmoPainterBase.cpp
@@ -291,11 +291,11 @@ void GLGizmoPainterBase::render_cursor_sphere(const Transform3d& trafo) const
         return;
 #endif // ENABLE_LEGACY_OPENGL_REMOVAL
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     const Transform3d complete_scaling_matrix_inverse = Geometry::Transformation(trafo).get_scaling_factor_matrix().inverse();
 #else
     const Transform3d complete_scaling_matrix_inverse = Geometry::Transformation(trafo).get_matrix(true, true, false, true).inverse();
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
     const bool is_left_handed = Geometry::Transformation(trafo).is_left_handed();
 
 #if !ENABLE_GL_SHADERS_ATTRIBUTES
@@ -512,11 +512,11 @@ bool GLGizmoPainterBase::gizmo_event(SLAGizmoEventType action, const Vec2d& mous
                     const Selection     &selection                 = m_parent.get_selection();
                     const ModelObject   *mo                        = m_c->selection_info()->model_object();
                     const ModelInstance *mi                        = mo->instances[selection.get_instance_idx()];
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
                     const Transform3d   trafo_matrix_not_translate = mi->get_transformation().get_matrix_no_offset() * mo->volumes[m_rr.mesh_id]->get_matrix_no_offset();
 #else
                     const Transform3d   trafo_matrix_not_translate = mi->get_transformation().get_matrix(true) * mo->volumes[m_rr.mesh_id]->get_matrix(true);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
                     const Transform3d   trafo_matrix = mi->get_transformation().get_matrix() * mo->volumes[m_rr.mesh_id]->get_matrix();
                     m_triangle_selectors[m_rr.mesh_id]->seed_fill_select_triangles(m_rr.hit, int(m_rr.facet), trafo_matrix_not_translate, this->get_clipping_plane_in_volume_coordinates(trafo_matrix), m_smart_fill_angle,
                                                                                    m_paint_on_overhangs_only ? m_highlight_by_angle_threshold_deg : 0.f, true);
@@ -555,11 +555,11 @@ bool GLGizmoPainterBase::gizmo_event(SLAGizmoEventType action, const Vec2d& mous
         const ModelObject   *mo                          = m_c->selection_info()->model_object();
         const ModelInstance *mi                          = mo->instances[selection.get_instance_idx()];
         const Transform3d   instance_trafo               = mi->get_transformation().get_matrix();
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
         const Transform3d   instance_trafo_not_translate = mi->get_transformation().get_matrix_no_offset();
 #else
         const Transform3d   instance_trafo_not_translate = mi->get_transformation().get_matrix(true);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 
         // Precalculate transformations of individual meshes.
         std::vector<Transform3d> trafo_matrices;
@@ -567,11 +567,11 @@ bool GLGizmoPainterBase::gizmo_event(SLAGizmoEventType action, const Vec2d& mous
         for (const ModelVolume *mv : mo->volumes)
             if (mv->is_model_part()) {
                 trafo_matrices.emplace_back(instance_trafo * mv->get_matrix());
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
                 trafo_matrices_not_translate.emplace_back(instance_trafo_not_translate * mv->get_matrix_no_offset());
 #else
                 trafo_matrices_not_translate.emplace_back(instance_trafo_not_translate * mv->get_matrix(true));
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
             }
 
         std::vector<std::vector<ProjectedMousePosition>> projected_mouse_positions_by_mesh = get_projected_mouse_positions(mouse_position, 1., trafo_matrices);
@@ -653,11 +653,11 @@ bool GLGizmoPainterBase::gizmo_event(SLAGizmoEventType action, const Vec2d& mous
         const ModelObject   *mo                           = m_c->selection_info()->model_object();
         const ModelInstance *mi                           = mo->instances[selection.get_instance_idx()];
         const Transform3d    instance_trafo               = mi->get_transformation().get_matrix();
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
         const Transform3d    instance_trafo_not_translate = mi->get_transformation().get_matrix_no_offset();
 #else
         const Transform3d    instance_trafo_not_translate = mi->get_transformation().get_matrix(true);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 
         // Precalculate transformations of individual meshes.
         std::vector<Transform3d> trafo_matrices;
@@ -665,11 +665,11 @@ bool GLGizmoPainterBase::gizmo_event(SLAGizmoEventType action, const Vec2d& mous
         for (const ModelVolume *mv : mo->volumes)
             if (mv->is_model_part()) {
                 trafo_matrices.emplace_back(instance_trafo * mv->get_matrix());
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
                 trafo_matrices_not_translate.emplace_back(instance_trafo_not_translate * mv->get_matrix_no_offset());
 #else
                 trafo_matrices_not_translate.emplace_back(instance_trafo_not_translate * mv->get_matrix(true));
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
             }
 
         // Now "click" into all the prepared points and spill paint around them.
diff --git a/src/slic3r/GUI/Gizmos/GLGizmoRotate.cpp b/src/slic3r/GUI/Gizmos/GLGizmoRotate.cpp
index b72c6761f..3a4f77837 100644
--- a/src/slic3r/GUI/Gizmos/GLGizmoRotate.cpp
+++ b/src/slic3r/GUI/Gizmos/GLGizmoRotate.cpp
@@ -287,27 +287,19 @@ void GLGizmoRotate::on_render_for_picking()
 #if ENABLE_WORLD_COORDINATE
 void GLGizmoRotate::init_data_from_selection(const Selection& selection)
 {
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
     ECoordinatesType coordinates_type;
     if (selection.is_wipe_tower())
         coordinates_type = ECoordinatesType::Local;
     else
         coordinates_type = wxGetApp().obj_manipul()->get_coordinates_type();
-#else
-    const ECoordinatesType coordinates_type = wxGetApp().obj_manipul()->get_coordinates_type();
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
     if (coordinates_type == ECoordinatesType::World) {
         m_bounding_box = selection.get_bounding_box();
         m_center = m_bounding_box.center();
     }
     else if (coordinates_type == ECoordinatesType::Local && selection.is_single_volume_or_modifier()) {
         const GLVolume& v = *selection.get_first_volume();
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
         m_bounding_box = v.transformed_convex_hull_bounding_box(
             v.get_instance_transformation().get_scaling_factor_matrix() * v.get_volume_transformation().get_scaling_factor_matrix());
-#else
-        m_bounding_box = v.transformed_convex_hull_bounding_box(v.get_instance_transformation().get_matrix(true, true, false, true) * v.get_volume_transformation().get_matrix(true, true, false, true));
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
         m_center = v.world_matrix() * m_bounding_box.center();
     }
     else {
@@ -317,14 +309,9 @@ void GLGizmoRotate::init_data_from_selection(const Selection& selection)
             const GLVolume& v = *selection.get_volume(id);
             m_bounding_box.merge(v.transformed_convex_hull_bounding_box(v.get_volume_transformation().get_matrix()));
         }
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
         const Geometry::Transformation inst_trafo = selection.get_first_volume()->get_instance_transformation();
         m_bounding_box = m_bounding_box.transformed(inst_trafo.get_scaling_factor_matrix());
         m_center = inst_trafo.get_matrix_no_scaling_factor() * m_bounding_box.center();
-#else
-        m_bounding_box = m_bounding_box.transformed(selection.get_first_volume()->get_instance_transformation().get_matrix(true, true, false, true));
-        m_center = selection.get_first_volume()->get_instance_transformation().get_matrix(false, false, true, false) * m_bounding_box.center();
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
     }
 
     m_radius = Offset + m_bounding_box.radius();
@@ -335,25 +322,13 @@ void GLGizmoRotate::init_data_from_selection(const Selection& selection)
 
     if (coordinates_type == ECoordinatesType::World)
         m_orient_matrix = Transform3d::Identity();
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
     else if (coordinates_type == ECoordinatesType::Local && (selection.is_wipe_tower() || selection.is_single_volume_or_modifier())) {
-#else
-    else if (coordinates_type == ECoordinatesType::Local && selection.is_single_volume_or_modifier()) {
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
         const GLVolume& v = *selection.get_first_volume();
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
         m_orient_matrix = v.get_instance_transformation().get_rotation_matrix() * v.get_volume_transformation().get_rotation_matrix();
-#else
-        m_orient_matrix = v.get_instance_transformation().get_matrix(true, false, true, true) * v.get_volume_transformation().get_matrix(true, false, true, true);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
     }
     else {
         const GLVolume& v = *selection.get_first_volume();
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
         m_orient_matrix = v.get_instance_transformation().get_rotation_matrix();
-#else
-        m_orient_matrix = v.get_instance_transformation().get_matrix(true, false, true, true);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
     }
 }
 #endif // ENABLE_WORLD_COORDINATE
@@ -762,20 +737,20 @@ Transform3d GLGizmoRotate::local_transform(const Selection& selection) const
     {
     case X:
     {
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
         ret = Geometry::rotation_transform(0.5 * PI * Vec3d::UnitY()) * Geometry::rotation_transform(-0.5 * PI * Vec3d::UnitZ());
 #else
         ret = Geometry::assemble_transform(Vec3d::Zero(), 0.5 * PI * Vec3d::UnitY()) * Geometry::assemble_transform(Vec3d::Zero(), -0.5 * PI * Vec3d::UnitZ());
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
         break;
     }
     case Y:
     {
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
         ret = Geometry::rotation_transform(-0.5 * PI * Vec3d::UnitZ()) * Geometry::rotation_transform(-0.5 * PI * Vec3d::UnitY());
 #else
         ret = Geometry::assemble_transform(Vec3d::Zero(), -0.5 * PI * Vec3d::UnitZ()) * Geometry::assemble_transform(Vec3d::Zero(), -0.5 * PI * Vec3d::UnitY());
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
         break;
     }
     default:
@@ -889,25 +864,22 @@ bool GLGizmoRotate3D::on_mouse(const wxMouseEvent &mouse_event)
         // Apply new temporary rotations
 #if ENABLE_WORLD_COORDINATE
         TransformationType transformation_type;
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
         if (m_parent.get_selection().is_wipe_tower())
             transformation_type = TransformationType::Instance_Relative_Joint;
         else {
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
             switch (wxGetApp().obj_manipul()->get_coordinates_type())
             {
             default:
-            case ECoordinatesType::World: { transformation_type = TransformationType::World_Relative_Joint; break; }
+            case ECoordinatesType::World:    { transformation_type = TransformationType::World_Relative_Joint; break; }
             case ECoordinatesType::Instance: { transformation_type = TransformationType::Instance_Relative_Joint; break; }
-            case ECoordinatesType::Local: { transformation_type = TransformationType::Local_Relative_Joint; break; }
+            case ECoordinatesType::Local:    { transformation_type = TransformationType::Local_Relative_Joint; break; }
             }
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
         }
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
 #else
         TransformationType transformation_type(TransformationType::World_Relative_Joint);
 #endif // ENABLE_WORLD_COORDINATE
-        if (mouse_event.AltDown()) transformation_type.set_independent();
+        if (mouse_event.AltDown())
+            transformation_type.set_independent();
         m_parent.get_selection().rotate(get_rotation(), transformation_type);
     }
     return use_grabbers(mouse_event);
@@ -915,26 +887,26 @@ bool GLGizmoRotate3D::on_mouse(const wxMouseEvent &mouse_event)
 
 void GLGizmoRotate3D::data_changed() {
     if (m_parent.get_selection().is_wipe_tower()) {
-#if !ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if !ENABLE_WORLD_COORDINATE
         const DynamicPrintConfig& config = wxGetApp().preset_bundle->prints.get_edited_preset().config;
         const float wipe_tower_rotation_angle =
             dynamic_cast<const ConfigOptionFloat*>(
                 config.option("wipe_tower_rotation_angle"))->value;
         set_rotation(Vec3d(0., 0., (M_PI / 180.) * wipe_tower_rotation_angle));
-#endif // !ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // !ENABLE_WORLD_COORDINATE
         m_gizmos[0].disable_grabber();
         m_gizmos[1].disable_grabber();
     }
     else {
-#if !ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if !ENABLE_WORLD_COORDINATE
         set_rotation(Vec3d::Zero());
-#endif // !ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // !ENABLE_WORLD_COORDINATE
         m_gizmos[0].enable_grabber();
         m_gizmos[1].enable_grabber();
     }
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     set_rotation(Vec3d::Zero());
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 }
 
 bool GLGizmoRotate3D::on_init()
diff --git a/src/slic3r/GUI/Gizmos/GLGizmoScale.cpp b/src/slic3r/GUI/Gizmos/GLGizmoScale.cpp
index 1d87d772a..f287a69f7 100644
--- a/src/slic3r/GUI/Gizmos/GLGizmoScale.cpp
+++ b/src/slic3r/GUI/Gizmos/GLGizmoScale.cpp
@@ -41,7 +41,7 @@ GLGizmoScale3D::GLGizmoScale3D(GLCanvas3D& parent, const std::string& icon_filen
 
 std::string GLGizmoScale3D::get_tooltip() const
 {
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     const Vec3d scale = 100.0 * m_scale;
 #else
     const Selection& selection = m_parent.get_selection();
@@ -49,13 +49,9 @@ std::string GLGizmoScale3D::get_tooltip() const
     Vec3d scale = 100.0 * Vec3d::Ones();
     if (selection.is_single_full_instance())
         scale = 100.0 * selection.get_first_volume()->get_instance_scaling_factor();
-#if ENABLE_WORLD_COORDINATE
-    else if (selection.is_single_volume_or_modifier())
-#else
     else if (selection.is_single_modifier() || selection.is_single_volume())
-#endif // ENABLE_WORLD_COORDINATE
         scale = 100.0 * selection.get_first_volume()->get_volume_scaling_factor();
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 
     if (m_hover_id == 0 || m_hover_id == 1 || m_grabbers[0].dragging || m_grabbers[1].dragging)
         return "X: " + format(scale.x(), 4) + "%";
@@ -79,54 +75,29 @@ bool GLGizmoScale3D::on_mouse(const wxMouseEvent &mouse_event)
 {
     if (mouse_event.Dragging()) {
         if (m_dragging) {
-#if !ENABLE_TRANSFORMATIONS_BY_MATRICES
-#if ENABLE_WORLD_COORDINATE
-            int res = 1;
-            if (m_scale.x() != m_scale.y() || m_scale.x() != m_scale.z())
-                res = m_parent.get_selection().bake_transform_if_needed();
-
-            if (res != 1) {
-                do_stop_dragging(true);
-                return true;
-            }
-            else {
-#endif // ENABLE_WORLD_COORDINATE
-#endif // !ENABLE_TRANSFORMATIONS_BY_MATRICES
             // Apply new temporary scale factors
 #if ENABLE_WORLD_COORDINATE
-                TransformationType transformation_type;
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
-                if (wxGetApp().obj_manipul()->is_local_coordinates())
-                    transformation_type.set_local();
-                else if (wxGetApp().obj_manipul()->is_instance_coordinates())
-                    transformation_type.set_instance();
+            TransformationType transformation_type;
+            if (wxGetApp().obj_manipul()->is_local_coordinates())
+                transformation_type.set_local();
+            else if (wxGetApp().obj_manipul()->is_instance_coordinates())
+                transformation_type.set_instance();
 
-                transformation_type.set_relative();
+            transformation_type.set_relative();
 #else
-                if (!wxGetApp().obj_manipul()->is_world_coordinates())
-                    transformation_type.set_local();
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
-#else
-                TransformationType transformation_type(TransformationType::Local_Absolute_Joint);
+            TransformationType transformation_type(TransformationType::Local_Absolute_Joint);
 #endif // ENABLE_WORLD_COORDINATE
-                if (mouse_event.AltDown()) transformation_type.set_independent();
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
-                m_parent.get_selection().scale_and_translate(m_scale, m_offset, transformation_type);
-#else
-                Selection& selection = m_parent.get_selection();
-                selection.scale(m_scale, transformation_type);
+            if (mouse_event.AltDown())
+                transformation_type.set_independent();
+
 #if ENABLE_WORLD_COORDINATE
-                if (mouse_event.CmdDown()) selection.translate(m_offset, wxGetApp().obj_manipul()->get_coordinates_type());
+            m_parent.get_selection().scale_and_translate(m_scale, m_offset, transformation_type);
 #else
-                if (mouse_event.CmdDown()) selection.translate(m_offset, true);
+            Selection& selection = m_parent.get_selection();
+            selection.scale(m_scale, transformation_type);
+            if (mouse_event.CmdDown()) selection.translate(m_offset, true);
 #endif // ENABLE_WORLD_COORDINATE
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
-#if !ENABLE_TRANSFORMATIONS_BY_MATRICES
-#if ENABLE_WORLD_COORDINATE
-        }
-#endif // ENABLE_WORLD_COORDINATE
-#endif // !ENABLE_TRANSFORMATIONS_BY_MATRICES
         }
     }
     return use_grabbers(mouse_event);
@@ -134,41 +105,29 @@ bool GLGizmoScale3D::on_mouse(const wxMouseEvent &mouse_event)
 
 void GLGizmoScale3D::data_changed()
 {
-#if !ENABLE_TRANSFORMATIONS_BY_MATRICES
-    const Selection &selection = m_parent.get_selection();
-#endif // !ENABLE_TRANSFORMATIONS_BY_MATRICES
 #if ENABLE_WORLD_COORDINATE
-#else
-    bool             enable_scale_xyz = selection.is_single_full_instance() ||
-                            selection.is_single_volume() ||
-                            selection.is_single_modifier();
-#endif // ENABLE_WORLD_COORDINATE
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
     set_scale(Vec3d::Ones());
 #else
-#if ENABLE_WORLD_COORDINATE
-    if (selection.is_single_full_instance() || selection.is_single_volume_or_modifier()) {
-#else
+    const Selection& selection = m_parent.get_selection();
+    bool enable_scale_xyz = selection.is_single_full_instance() ||
+        selection.is_single_volume() ||
+        selection.is_single_modifier();
+
     for (unsigned int i = 0; i < 6; ++i)
         m_grabbers[i].enabled = enable_scale_xyz;
 
     if (enable_scale_xyz) {
-#endif // ENABLE_WORLD_COORDINATE
         // all volumes in the selection belongs to the same instance, any of
         // them contains the needed data, so we take the first
         const GLVolume* volume = selection.get_first_volume();
         if (selection.is_single_full_instance())
             set_scale(volume->get_instance_scaling_factor());
-#if ENABLE_WORLD_COORDINATE
-        else if (selection.is_single_volume_or_modifier())
-#else
         else if (selection.is_single_volume() || selection.is_single_modifier())
-#endif // ENABLE_WORLD_COORDINATE
             set_scale(volume->get_volume_scaling_factor());
     }
     else
         set_scale(Vec3d::Ones());
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 }
 
 bool GLGizmoScale3D::on_init()
@@ -279,24 +238,15 @@ void GLGizmoScale3D::on_render()
         }
 
 #if ENABLE_WORLD_COORDINATE
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
         m_bounding_box = m_bounding_box.transformed(selection.get_first_volume()->get_instance_transformation().get_scaling_factor_matrix());
-#else
-        m_bounding_box = m_bounding_box.transformed(selection.get_first_volume()->get_instance_transformation().get_matrix(true, true, false, true));
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
 #endif // ENABLE_WORLD_COORDINATE
 
         // gets transform from first selected volume
         const GLVolume& v = *selection.get_first_volume();
 #if ENABLE_WORLD_COORDINATE
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
         const Transform3d inst_trafo = v.get_instance_transformation().get_matrix_no_scaling_factor();
         m_grabbers_transform = inst_trafo * Geometry::translation_transform(m_bounding_box.center());
         m_center = inst_trafo * m_bounding_box.center();
-#else
-        m_grabbers_transform = v.get_instance_transformation().get_matrix(false, false, true) * Geometry::assemble_transform(m_bounding_box.center());
-        m_center = selection.get_first_volume()->get_instance_transformation().get_matrix(false, false, true, false) * m_bounding_box.center();
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
         m_instance_center = v.get_instance_offset();
     }
     else if (selection.is_single_volume_or_modifier() && wxGetApp().obj_manipul()->is_instance_coordinates()) {
@@ -313,14 +263,9 @@ void GLGizmoScale3D::on_render()
 #endif // ENABLE_WORLD_COORDINATE
         const GLVolume& v = *selection.get_first_volume();
 #if ENABLE_WORLD_COORDINATE
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
         m_bounding_box.merge(v.transformed_convex_hull_bounding_box(
             v.get_instance_transformation().get_scaling_factor_matrix() * v.get_volume_transformation().get_matrix_no_offset()));
         Geometry::Transformation trafo(v.get_instance_transformation().get_rotation_matrix());
-#else
-        m_bounding_box.merge(v.transformed_convex_hull_bounding_box(v.get_instance_transformation().get_matrix(true, true, false, true) * v.get_volume_transformation().get_matrix(true, false, false, true)));
-        Geometry::Transformation trafo(v.get_instance_transformation().get_matrix(true, false, true, true));
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
         trafo.set_offset(v.world_matrix().translation());
         m_grabbers_transform = trafo.get_matrix();
         m_center = v.world_matrix() * m_bounding_box.center();
@@ -328,14 +273,9 @@ void GLGizmoScale3D::on_render()
     }
     else if (selection.is_single_volume_or_modifier() && wxGetApp().obj_manipul()->is_local_coordinates()) {
         const GLVolume& v = *selection.get_first_volume();
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
         m_bounding_box.merge(v.transformed_convex_hull_bounding_box(
             v.get_instance_transformation().get_scaling_factor_matrix() * v.get_volume_transformation().get_scaling_factor_matrix()));
         Geometry::Transformation trafo(v.get_instance_transformation().get_rotation_matrix() * v.get_volume_transformation().get_rotation_matrix());
-#else
-        m_bounding_box.merge(v.transformed_convex_hull_bounding_box(v.get_instance_transformation().get_matrix(true, true, false, true) * v.get_volume_transformation().get_matrix(true, true, false, true)));
-        Geometry::Transformation trafo(v.get_instance_transformation().get_matrix(true, false, true, true) * v.get_volume_transformation().get_matrix(true, false, true, true));
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
         trafo.set_offset(v.world_matrix().translation());
         m_grabbers_transform = trafo.get_matrix();
         m_center = v.world_matrix() * m_bounding_box.center();
@@ -736,7 +676,7 @@ void GLGizmoScale3D::render_grabbers_connection(unsigned int id_1, unsigned int
 }
 #endif // ENABLE_LEGACY_OPENGL_REMOVAL
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
 void GLGizmoScale3D::do_scale_along_axis(Axis axis, const UpdateData& data)
 {
     double ratio = calc_ratio(data);
@@ -790,76 +730,16 @@ void GLGizmoScale3D::do_scale_along_axis(Axis axis, const UpdateData& data)
 #else
 void GLGizmoScale3D::do_scale_along_axis(Axis axis, const UpdateData& data)
 {
-#if ENABLE_WORLD_COORDINATE
-    double ratio = calc_ratio(data);
-    if (ratio > 0.0) {
-        Vec3d curr_scale = m_scale;
-        Vec3d starting_scale = m_starting.scale;
-        const Selection& selection = m_parent.get_selection();
-        const ECoordinatesType coordinates_type = wxGetApp().obj_manipul()->get_coordinates_type();
-        if (coordinates_type == ECoordinatesType::World) {
-            if (selection.is_single_full_instance()) {
-                const Transform3d m = Geometry::assemble_transform(Vec3d::Zero(), selection.get_first_volume()->get_instance_rotation());
-                curr_scale = (m * curr_scale).cwiseAbs();
-                starting_scale = (m * starting_scale).cwiseAbs();
-            }
-            else if (selection.is_single_volume_or_modifier()) {
-                const Transform3d mi = Geometry::assemble_transform(Vec3d::Zero(), selection.get_first_volume()->get_instance_rotation());
-                const Transform3d mv = Geometry::assemble_transform(Vec3d::Zero(), selection.get_first_volume()->get_volume_rotation());
-                const Transform3d m = mi * mv;
-                curr_scale = (m * curr_scale).cwiseAbs();
-                starting_scale = (m * starting_scale).cwiseAbs();
-            }
-        }
-
-        curr_scale(axis) = starting_scale(axis) * ratio;
-
-        if (coordinates_type == ECoordinatesType::World) {
-            if (selection.is_single_full_instance())
-                m_scale = (Geometry::assemble_transform(Vec3d::Zero(), selection.get_first_volume()->get_instance_rotation()).inverse() * curr_scale).cwiseAbs();
-            else if (selection.is_single_volume_or_modifier()) {
-                const Transform3d mi = Geometry::assemble_transform(Vec3d::Zero(), selection.get_first_volume()->get_instance_rotation()).inverse();
-                const Transform3d mv = Geometry::assemble_transform(Vec3d::Zero(), selection.get_first_volume()->get_volume_rotation()).inverse();
-                m_scale = (mv * mi * curr_scale).cwiseAbs();
-            }
-            else
-                m_scale = curr_scale;
-        }
-        else
-            m_scale = curr_scale;
-#else
     const double ratio = calc_ratio(data);
     if (ratio > 0.0) {
         m_scale(axis) = m_starting.scale(axis) * ratio;
-#endif // ENABLE_WORLD_COORDINATE
 
         if (m_starting.ctrl_down) {
-#if ENABLE_WORLD_COORDINATE
-            double local_offset = 0.5 * (ratio - 1.0) * m_starting.box.size()(axis);
-#else
             double local_offset = 0.5 * (m_scale(axis) - m_starting.scale(axis)) * m_starting.box.size()(axis);
-#endif // ENABLE_WORLD_COORDINATE
 
             if (m_hover_id == 2 * axis)
                 local_offset *= -1.0;
 
-#if ENABLE_WORLD_COORDINATE
-            Vec3d center_offset = m_starting.instance_center - m_starting.center;
-            if (selection.is_single_full_instance() && coordinates_type != ECoordinatesType::World) {
-                const Transform3d m = Geometry::rotation_transform(selection.get_first_volume()->get_instance_rotation()).inverse();
-                center_offset = m * center_offset;
-            }
-
-            local_offset += (ratio - 1.0) * center_offset(axis);
-
-            switch (axis)
-            {
-            case X:  { m_offset = local_offset * Vec3d::UnitX(); break; }
-            case Y:  { m_offset = local_offset * Vec3d::UnitY(); break; }
-            case Z:  { m_offset = local_offset * Vec3d::UnitZ(); break; }
-            default: { m_offset = Vec3d::Zero(); break; }
-            }
-#else
             Vec3d local_offset_vec;
             switch (axis)
             {
@@ -870,15 +750,14 @@ void GLGizmoScale3D::do_scale_along_axis(Axis axis, const UpdateData& data)
             }
 
             m_offset = m_offsets_transform * local_offset_vec;
-#endif // ENABLE_WORLD_COORDINATE
         }
         else
             m_offset = Vec3d::Zero();
     }
 }
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
 void GLGizmoScale3D::do_scale_uniform(const UpdateData & data)
 {
     const double ratio = calc_ratio(data);
@@ -926,32 +805,10 @@ void GLGizmoScale3D::do_scale_uniform(const UpdateData& data)
     const double ratio = calc_ratio(data);
     if (ratio > 0.0) {
         m_scale = m_starting.scale * ratio;
-
-#if ENABLE_WORLD_COORDINATE
-        if (m_starting.ctrl_down) {
-            m_offset = 0.5 * (ratio - 1.0) * m_starting.box.size();
-
-            if (m_hover_id == 6 || m_hover_id == 9)
-                m_offset.x() *= -1.0;
-            if (m_hover_id == 6 || m_hover_id == 7)
-                m_offset.y() *= -1.0;
-
-            const Selection& selection = m_parent.get_selection();
-            Vec3d center_offset = m_starting.instance_center - m_starting.center;
-
-            if (selection.is_single_full_instance() && !wxGetApp().obj_manipul()->is_world_coordinates()) {
-                const Transform3d m = Geometry::rotation_transform(selection.get_first_volume()->get_instance_rotation()).inverse();
-                center_offset = m * center_offset;
-            }
-
-            m_offset += (ratio - 1.0) * center_offset;
-        }
-        else
-#endif // ENABLE_WORLD_COORDINATE
         m_offset = Vec3d::Zero();
     }
 }
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 
 double GLGizmoScale3D::calc_ratio(const UpdateData& data) const
 {
@@ -995,17 +852,9 @@ Transform3d GLGizmoScale3D::local_transform(const Selection& selection) const
     Transform3d ret = Geometry::assemble_transform(m_center);
     if (!wxGetApp().obj_manipul()->is_world_coordinates()) {
         const GLVolume& v = *selection.get_first_volume();
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
         Transform3d orient_matrix = v.get_instance_transformation().get_rotation_matrix();
-#else
-        Transform3d orient_matrix = v.get_instance_transformation().get_matrix(true, false, true, true);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
         if (selection.is_single_volume_or_modifier() && wxGetApp().obj_manipul()->is_local_coordinates())
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
             orient_matrix = orient_matrix * v.get_volume_transformation().get_rotation_matrix();
-#else
-            orient_matrix = orient_matrix * v.get_volume_transformation().get_matrix(true, false, true, true);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
         ret = ret * orient_matrix;
     }
     return ret;
diff --git a/src/slic3r/GUI/Gizmos/GLGizmoScale.hpp b/src/slic3r/GUI/Gizmos/GLGizmoScale.hpp
index 754b588b4..b2a9b7a23 100644
--- a/src/slic3r/GUI/Gizmos/GLGizmoScale.hpp
+++ b/src/slic3r/GUI/Gizmos/GLGizmoScale.hpp
@@ -67,11 +67,11 @@ public:
     void set_snap_step(double step) { m_snap_step = step; }
 
     const Vec3d& get_scale() const { return m_scale; }
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     void set_scale(const Vec3d& scale) { m_starting.scale = scale; m_scale = scale; m_offset = Vec3d::Zero(); }
 #else
     void set_scale(const Vec3d& scale) { m_starting.scale = scale; m_scale = scale; }
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 
 #if ENABLE_WORLD_COORDINATE_SCALE_REVISITED
     const Vec3d& get_starting_scale() const { return m_starting.scale; }
diff --git a/src/slic3r/GUI/Gizmos/GLGizmoSlaSupports.cpp b/src/slic3r/GUI/Gizmos/GLGizmoSlaSupports.cpp
index 25b918e4b..987fd325f 100644
--- a/src/slic3r/GUI/Gizmos/GLGizmoSlaSupports.cpp
+++ b/src/slic3r/GUI/Gizmos/GLGizmoSlaSupports.cpp
@@ -148,11 +148,11 @@ void GLGizmoSlaSupports::render_points(const Selection& selection, bool picking)
 
     const GLVolume* vol = selection.get_first_volume();
     Geometry::Transformation transformation(vol->get_instance_transformation().get_matrix() * vol->get_volume_transformation().get_matrix());
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     const Transform3d instance_scaling_matrix_inverse = transformation.get_scaling_factor_matrix().inverse();
 #else
     const Transform3d& instance_scaling_matrix_inverse = transformation.get_matrix(true, true, false, true).inverse();
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 #if ENABLE_GL_SHADERS_ATTRIBUTES
     const Transform3d instance_matrix = Geometry::assemble_transform(m_c->selection_info()->get_sla_shift() * Vec3d::UnitZ()) * transformation.get_matrix();
     const Camera& camera = wxGetApp().plater()->get_camera();
diff --git a/src/slic3r/GUI/MeshUtils.cpp b/src/slic3r/GUI/MeshUtils.cpp
index 777a4d7ba..7782b8d75 100644
--- a/src/slic3r/GUI/MeshUtils.cpp
+++ b/src/slic3r/GUI/MeshUtils.cpp
@@ -112,11 +112,11 @@ void MeshClipper::render_cut()
 
 void MeshClipper::recalculate_triangles()
 {
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     const Transform3f instance_matrix_no_translation_no_scaling = m_trafo.get_rotation_matrix().cast<float>();
 #else
     const Transform3f& instance_matrix_no_translation_no_scaling = m_trafo.get_matrix(true,false,true).cast<float>();
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
     // Calculate clipping plane normal in mesh coordinates.
     const Vec3f up_noscale = instance_matrix_no_translation_no_scaling.inverse() * m_plane.get_normal().cast<float>();
     const Vec3d up = up_noscale.cast<double>().cwiseProduct(m_trafo.get_scaling_factor());
@@ -307,11 +307,11 @@ std::vector<unsigned> MeshRaycaster::get_unobscured_idxs(const Geometry::Transfo
 {
     std::vector<unsigned> out;
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     const Transform3d instance_matrix_no_translation_no_scaling = trafo.get_rotation_matrix();
 #else
     const Transform3d& instance_matrix_no_translation_no_scaling = trafo.get_matrix(true,false,true);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
     Vec3d direction_to_camera = -camera.get_dir_forward();
     Vec3d direction_to_camera_mesh = (instance_matrix_no_translation_no_scaling.inverse() * direction_to_camera).normalized().eval();
     direction_to_camera_mesh = direction_to_camera_mesh.cwiseProduct(trafo.get_scaling_factor());
diff --git a/src/slic3r/GUI/Plater.cpp b/src/slic3r/GUI/Plater.cpp
index c9cc7fc22..d23a3dd13 100644
--- a/src/slic3r/GUI/Plater.cpp
+++ b/src/slic3r/GUI/Plater.cpp
@@ -2085,9 +2085,9 @@ Plater::priv::priv(Plater *q, MainFrame *main_frame)
         view3D_canvas->Bind(EVT_GLCANVAS_WIPETOWER_MOVED, &priv::on_wipetower_moved, this);
         view3D_canvas->Bind(EVT_GLCANVAS_WIPETOWER_ROTATED, &priv::on_wipetower_rotated, this);
         view3D_canvas->Bind(EVT_GLCANVAS_INSTANCE_ROTATED, [this](SimpleEvent&) { update(); });
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
         view3D_canvas->Bind(EVT_GLCANVAS_RESET_SKEW, [this](SimpleEvent&) { update(); });
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
         view3D_canvas->Bind(EVT_GLCANVAS_INSTANCE_SCALED, [this](SimpleEvent&) { update(); });
         view3D_canvas->Bind(EVT_GLCANVAS_ENABLE_ACTION_BUTTONS, [this](Event<bool>& evt) { this->sidebar->enable_buttons(evt.data); });
         view3D_canvas->Bind(EVT_GLCANVAS_UPDATE_GEOMETRY, &priv::on_update_geometry, this);
@@ -3495,11 +3495,11 @@ bool Plater::priv::replace_volume_with_stl(int object_idx, int volume_idx, const
     new_volume->set_type(old_volume->type());
     new_volume->set_material_id(old_volume->material_id());
     new_volume->set_transformation(old_volume->get_transformation());
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     new_volume->translate(new_volume->get_transformation().get_matrix_no_offset() * (new_volume->source.mesh_offset - old_volume->source.mesh_offset));
 #else
     new_volume->translate(new_volume->get_transformation().get_matrix(true) * (new_volume->source.mesh_offset - old_volume->source.mesh_offset));
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
     assert(!old_volume->source.is_converted_from_inches || !old_volume->source.is_converted_from_meters);
     if (old_volume->source.is_converted_from_inches)
         new_volume->convert_from_imperial_units();
@@ -3854,7 +3854,7 @@ void Plater::priv::reload_from_disk()
                 new_volume->config.apply(old_volume->config);
                 new_volume->set_type(old_volume->type());
                 new_volume->set_material_id(old_volume->material_id());
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
                 new_volume->set_transformation(Geometry::translation_transform(old_volume->source.transform.get_offset()) *
                     old_volume->get_transformation().get_matrix_no_offset() * old_volume->source.transform.get_matrix_no_offset());
                 new_volume->translate(new_volume->get_transformation().get_matrix_no_offset() * (new_volume->source.mesh_offset - old_volume->source.mesh_offset));
@@ -3863,7 +3863,7 @@ void Plater::priv::reload_from_disk()
                                                old_volume->get_transformation().get_matrix(true) *
                                                old_volume->source.transform.get_matrix(true));
                 new_volume->translate(new_volume->get_transformation().get_matrix(true) * (new_volume->source.mesh_offset - old_volume->source.mesh_offset));
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
                 new_volume->source.object_idx = old_volume->source.object_idx;
                 new_volume->source.volume_idx = old_volume->source.volume_idx;
                 assert(!old_volume->source.is_converted_from_inches || !old_volume->source.is_converted_from_meters);
diff --git a/src/slic3r/GUI/Selection.cpp b/src/slic3r/GUI/Selection.cpp
index 02edd9c31..61ffd4b19 100644
--- a/src/slic3r/GUI/Selection.cpp
+++ b/src/slic3r/GUI/Selection.cpp
@@ -41,18 +41,18 @@ Selection::VolumeCache::TransformCache::TransformCache(const Geometry::Transform
     , scaling_factor(transform.get_scaling_factor())
     , mirror(transform.get_mirror())
     , full_matrix(transform.get_matrix())
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     , transform(transform)
     , rotation_matrix(transform.get_rotation_matrix())
     , scale_matrix(transform.get_scaling_factor_matrix())
     , mirror_matrix(transform.get_mirror_matrix())
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 {
-#if !ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if !ENABLE_WORLD_COORDINATE
     rotation_matrix = Geometry::assemble_transform(Vec3d::Zero(), rotation);
-    scale_matrix = Geometry::assemble_transform(Vec3d::Zero(), Vec3d::Zero(), scaling_factor);
-    mirror_matrix = Geometry::assemble_transform(Vec3d::Zero(), Vec3d::Zero(), Vec3d::Ones(), mirror);
-#endif // !ENABLE_TRANSFORMATIONS_BY_MATRICES
+    scale_matrix    = Geometry::assemble_transform(Vec3d::Zero(), Vec3d::Zero(), scaling_factor);
+    mirror_matrix   = Geometry::assemble_transform(Vec3d::Zero(), Vec3d::Zero(), Vec3d::Ones(), mirror);
+#endif // !ENABLE_WORLD_COORDINATE
 }
 
 Selection::VolumeCache::VolumeCache(const Geometry::Transformation& volume_transform, const Geometry::Transformation& instance_transform)
@@ -599,76 +599,15 @@ bool Selection::matches(const std::vector<unsigned int>& volume_idxs) const
     return count == (unsigned int)m_list.size();
 }
 
-#if !ENABLE_TRANSFORMATIONS_BY_MATRICES
-#if ENABLE_WORLD_COORDINATE
-bool Selection::requires_uniform_scale(EUniformScaleRequiredReason* reason) const
-#else
+#if !ENABLE_WORLD_COORDINATE
 bool Selection::requires_uniform_scale() const
-#endif // ENABLE_WORLD_COORDINATE
 {
-#if ENABLE_WORLD_COORDINATE
-    if (is_empty())
-        return false;
-
-    ECoordinatesType coord_type = wxGetApp().obj_manipul()->get_coordinates_type();
-    if (is_single_volume_or_modifier()) {
-        if (coord_type == ECoordinatesType::World) {
-            if (!Geometry::is_rotation_ninety_degrees(Geometry::Transformation(get_first_volume()->world_matrix()).get_rotation())) {
-                if (reason != nullptr)
-                    *reason = EUniformScaleRequiredReason::VolumeNotAxisAligned_World;
-                return true;
-            }
-        }
-        else if (coord_type == ECoordinatesType::Instance) {
-            if (!Geometry::is_rotation_ninety_degrees(get_first_volume()->get_volume_rotation())) {
-                if (reason != nullptr)
-                    *reason = EUniformScaleRequiredReason::VolumeNotAxisAligned_Instance;
-                return true;
-            }
-        }
-        return false;
-    }
-    else if (is_single_full_instance()) {
-        if (coord_type == ECoordinatesType::World) {
-            if (!Geometry::is_rotation_ninety_degrees(get_first_volume()->get_instance_rotation())) {
-                if (reason != nullptr)
-                    *reason = EUniformScaleRequiredReason::InstanceNotAxisAligned_World;
-                return true;
-            }
-            else {
-                for (unsigned int i : m_list) {
-                    if (!Geometry::is_rotation_ninety_degrees((*m_volumes)[i]->get_volume_rotation())) {
-                        if (reason != nullptr)
-                            *reason = EUniformScaleRequiredReason::VolumeNotAxisAligned_Instance;
-                        return true;
-                    }
-                }
-            }
-        }
-        else {
-            for (unsigned int i : m_list) {
-                if (!Geometry::is_rotation_ninety_degrees((*m_volumes)[i]->get_volume_rotation())) {
-                    if (reason != nullptr)
-                        *reason = EUniformScaleRequiredReason::VolumeNotAxisAligned_Instance;
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-
-    if (reason != nullptr)
-        *reason = EUniformScaleRequiredReason::MultipleSelection;
-
-    return true;
-#else
     if (is_single_full_instance() || is_single_modifier() || is_single_volume())
         return false;
 
     return true;
-#endif // ENABLE_WORLD_COORDINATE
 }
-#endif // !ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // !ENABLE_WORLD_COORDINATE
 
 int Selection::get_object_idx() const
 {
@@ -723,11 +662,11 @@ const BoundingBoxf3& Selection::get_unscaled_instance_bounding_box() const
                 const GLVolume& volume = *(*m_volumes)[i];
                 if (volume.is_modifier)
                     continue;
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
                 Transform3d trafo = volume.get_instance_transformation().get_matrix_no_scaling_factor() * volume.get_volume_transformation().get_matrix();
 #else
                 Transform3d trafo = volume.get_instance_transformation().get_matrix(false, false, true, false) * volume.get_volume_transformation().get_matrix();
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
                 trafo.translation().z() += volume.get_sla_shift_z();
                 (*bbox)->merge(volume.transformed_convex_hull_bounding_box(trafo));
             }
@@ -757,7 +696,7 @@ const BoundingBoxf3& Selection::get_scaled_instance_bounding_box() const
     return *m_scaled_instance_bounding_box;
 }
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
 const BoundingBoxf3& Selection::get_full_unscaled_instance_bounding_box() const
 {
     assert(is_single_full_instance());
@@ -814,7 +753,7 @@ const BoundingBoxf3& Selection::get_full_unscaled_instance_local_bounding_box()
     }
     return *m_full_unscaled_instance_local_bounding_box;
 }
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 
 void Selection::setup_cache()
 {
@@ -824,7 +763,7 @@ void Selection::setup_cache()
     set_caches();
 }
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
 void Selection::translate(const Vec3d& displacement, TransformationType transformation_type)
 {
     if (!m_valid)
@@ -865,11 +804,7 @@ void Selection::translate(const Vec3d& displacement, TransformationType transfor
     wxGetApp().plater()->canvas3D()->requires_check_outside_state();
 }
 #else
-#if ENABLE_WORLD_COORDINATE
-void Selection::translate(const Vec3d& displacement, ECoordinatesType type)
-#else
 void Selection::translate(const Vec3d& displacement, bool local)
-#endif // ENABLE_WORLD_COORDINATE
 {
     if (!m_valid)
         return;
@@ -879,45 +814,16 @@ void Selection::translate(const Vec3d& displacement, bool local)
     for (unsigned int i : m_list) {
         GLVolume& v = *(*m_volumes)[i];
         if (m_mode == Volume || v.is_wipe_tower) {
-#if ENABLE_WORLD_COORDINATE
-            if (type == ECoordinatesType::Instance)
-#else
             if (local)
-#endif // ENABLE_WORLD_COORDINATE
                 v.set_volume_offset(m_cache.volumes_data[i].get_volume_position() + displacement);
-#if ENABLE_WORLD_COORDINATE
-            else if (type == ECoordinatesType::Local) {
-                const VolumeCache& volume_data = m_cache.volumes_data[i];
-                const Vec3d local_displacement = volume_data.get_volume_rotation_matrix() * displacement;
-                v.set_volume_offset(volume_data.get_volume_position() + local_displacement);
-            }
-#endif // ENABLE_WORLD_COORDINATE
             else {
-#if ENABLE_WORLD_COORDINATE
-                const VolumeCache& volume_data = m_cache.volumes_data[i];
-                const Vec3d local_displacement = (volume_data.get_instance_rotation_matrix() * volume_data.get_instance_scale_matrix() * volume_data.get_instance_mirror_matrix()).inverse() * displacement;
-                v.set_volume_offset(volume_data.get_volume_position() + local_displacement);
-#else
                 const Vec3d local_displacement = (m_cache.volumes_data[i].get_instance_rotation_matrix() * m_cache.volumes_data[i].get_instance_scale_matrix() * m_cache.volumes_data[i].get_instance_mirror_matrix()).inverse() * displacement;
                 v.set_volume_offset(m_cache.volumes_data[i].get_volume_position() + local_displacement);
-#endif // ENABLE_WORLD_COORDINATE
             }
         }
         else if (m_mode == Instance) {
-#if ENABLE_WORLD_COORDINATE
-            if (is_from_fully_selected_instance(i)) {
-                if (type == ECoordinatesType::Local) {
-                    const VolumeCache& volume_data = m_cache.volumes_data[i];
-                    const Vec3d world_displacement = volume_data.get_instance_rotation_matrix() * displacement;
-                    v.set_instance_offset(volume_data.get_instance_position() + world_displacement);
-                }
-                else
-                    v.set_instance_offset(m_cache.volumes_data[i].get_instance_position() + displacement);
-            }
-#else
             if (is_from_fully_selected_instance(i))
                 v.set_instance_offset(m_cache.volumes_data[i].get_instance_position() + displacement);
-#endif // ENABLE_WORLD_COORDINATE
             else {
                 const Vec3d local_displacement = (m_cache.volumes_data[i].get_instance_rotation_matrix() * m_cache.volumes_data[i].get_instance_scale_matrix() * m_cache.volumes_data[i].get_instance_mirror_matrix()).inverse() * displacement;
                 v.set_volume_offset(m_cache.volumes_data[i].get_volume_position() + local_displacement);
@@ -937,10 +843,10 @@ void Selection::translate(const Vec3d& displacement, bool local)
     set_bounding_boxes_dirty();
     wxGetApp().plater()->canvas3D()->requires_check_outside_state();
 }
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 
 // Rotate an object around one of the axes. Only one rotation component is expected to be changing.
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
 void Selection::rotate(const Vec3d& rotation, TransformationType transformation_type)
 {
     if (!m_valid)
@@ -1052,18 +958,6 @@ void Selection::rotate(const Vec3d& rotation, TransformationType transformation_
                 }
                 else {
                     // extracts rotations from the composed transformation
-#if ENABLE_WORLD_COORDINATE
-                    const Transform3d m = Geometry::assemble_transform(Vec3d::Zero(), rotation);
-                    const Vec3d new_rotation = transformation_type.world() ?
-                        Geometry::extract_euler_angles(m * m_cache.volumes_data[i].get_instance_rotation_matrix()) :
-                        transformation_type.absolute() ? rotation : Geometry::extract_euler_angles(m_cache.volumes_data[i].get_instance_rotation_matrix() * m);
-                    const Vec3d relative_instance_offset = m_cache.volumes_data[i].get_instance_position() - m_cache.dragging_center;
-                    if (rot_axis_max == 2 && transformation_type.joint() && !relative_instance_offset.isApprox(Vec3d::Zero())) {
-                        // Only allow rotation of multiple instances as a single rigid body when rotating around the Z axis.
-                        const double z_diff = Geometry::rotation_diff_z(m_cache.volumes_data[i].get_instance_rotation(), new_rotation);
-                        volume.set_instance_offset(m_cache.dragging_center + Eigen::AngleAxisd(z_diff, Vec3d::UnitZ()) * relative_instance_offset);
-                    }
-#else
                     const Vec3d new_rotation = transformation_type.world() ?
                         Geometry::extract_euler_angles(Geometry::assemble_transform(Vec3d::Zero(), rotation) * m_cache.volumes_data[i].get_instance_rotation_matrix()) :
                         transformation_type.absolute() ? rotation : rotation + m_cache.volumes_data[i].get_instance_rotation();
@@ -1072,9 +966,6 @@ void Selection::rotate(const Vec3d& rotation, TransformationType transformation_
                         const double z_diff = Geometry::rotation_diff_z(m_cache.volumes_data[i].get_instance_rotation(), new_rotation);
                         volume.set_instance_offset(m_cache.dragging_center + Eigen::AngleAxisd(z_diff, Vec3d::UnitZ()) * (m_cache.volumes_data[i].get_instance_position() - m_cache.dragging_center));
                     }
-#endif // ENABLE_WORLD_COORDINATE
-                    else if (!(m_cache.volumes_data[i].get_instance_position() - m_cache.dragging_center).isApprox(Vec3d::Zero()))
-                        volume.set_instance_offset(m_cache.dragging_center + Geometry::assemble_transform(Vec3d::Zero(), new_rotation) * m_cache.volumes_data[i].get_instance_rotation_matrix().inverse() * (m_cache.volumes_data[i].get_instance_position() - m_cache.dragging_center));
 
                     volume.set_instance_rotation(new_rotation);
                     object_instance_first[volume.object_idx()] = i;
@@ -1085,25 +976,6 @@ void Selection::rotate(const Vec3d& rotation, TransformationType transformation_
                 GLVolume &v = *(*m_volumes)[i];
                 if (is_single_full_instance())
                     rotate_instance(v, i);
-#if ENABLE_WORLD_COORDINATE
-                else if (is_single_volume_or_modifier()) {
-                    if (transformation_type.local()) {
-                        const Transform3d m = Geometry::assemble_transform(Vec3d::Zero(), rotation);
-                        const Vec3d new_rotation = transformation_type.absolute() ? rotation : Geometry::extract_euler_angles(m_cache.volumes_data[i].get_volume_rotation_matrix() * m);
-                        v.set_volume_rotation(new_rotation);
-                    }
-                    else if (transformation_type.instance()) {
-                        const Transform3d m = Geometry::assemble_transform(Vec3d::Zero(), rotation);
-                        v.set_volume_rotation(Geometry::extract_euler_angles(m * m_cache.volumes_data[i].get_volume_rotation_matrix()));
-                    }
-                    else {
-                        Transform3d m = Geometry::assemble_transform(Vec3d::Zero(), rotation);
-                        m = m * m_cache.volumes_data[i].get_instance_rotation_matrix();
-                        m = m * m_cache.volumes_data[i].get_volume_rotation_matrix();
-                        m = m_cache.volumes_data[i].get_instance_rotation_matrix().inverse() * m;
-                        v.set_volume_rotation(Geometry::extract_euler_angles(m));
-                    }
-#else
                 else if (is_single_volume() || is_single_modifier()) {
                     if (transformation_type.independent())
                         v.set_volume_rotation(m_cache.volumes_data[i].get_volume_rotation() + rotation);
@@ -1112,7 +984,6 @@ void Selection::rotate(const Vec3d& rotation, TransformationType transformation_
                         const Vec3d new_rotation = Geometry::extract_euler_angles(m * m_cache.volumes_data[i].get_volume_rotation_matrix());
                         v.set_volume_rotation(new_rotation);
                     }
-#endif // ENABLE_WORLD_COORDINATE
                 }
                 else {
                     if (m_mode == Instance)
@@ -1133,21 +1004,8 @@ void Selection::rotate(const Vec3d& rotation, TransformationType transformation_
         }
 
 #if !DISABLE_INSTANCES_SYNCH
-#if ENABLE_WORLD_COORDINATE
-        if (m_mode == Instance) {
-            SyncRotationType synch;
-            if (transformation_type.world() && rot_axis_max == 2)
-                synch = SyncRotationType::NONE;
-            else if (transformation_type.local())
-                synch = SyncRotationType::FULL;
-            else
-                synch = SyncRotationType::GENERAL;
-            synchronize_unselected_instances(synch);
-        }
-#else
         if (m_mode == Instance)
             synchronize_unselected_instances((rot_axis_max == 2) ? SyncRotationType::NONE : SyncRotationType::GENERAL);
-#endif // ENABLE_WORLD_COORDINATE
         else if (m_mode == Volume)
             synchronize_unselected_volumes();
 #endif // !DISABLE_INSTANCES_SYNCH
@@ -1166,7 +1024,7 @@ void Selection::rotate(const Vec3d& rotation, TransformationType transformation_
     set_bounding_boxes_dirty();
     wxGetApp().plater()->canvas3D()->requires_check_outside_state();
 }
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 
 void Selection::flattening_rotate(const Vec3d& normal)
 {
@@ -1181,7 +1039,7 @@ void Selection::flattening_rotate(const Vec3d& normal)
     for (unsigned int i : m_list) {
         GLVolume& v = *(*m_volumes)[i];
         // Normal transformed from the object coordinate space to the world coordinate space.
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
         const Geometry::Transformation& old_inst_trafo = v.get_instance_transformation();
         const Vec3d tnormal = old_inst_trafo.get_matrix().matrix().block(0, 0, 3, 3).inverse().transpose() * normal;
         // Additional rotation to align tnormal with the down vector in the world coordinate space.
@@ -1195,7 +1053,7 @@ void Selection::flattening_rotate(const Vec3d& normal)
         // Additional rotation to align tnormal with the down vector in the world coordinate space.
         auto  extra_rotation = Eigen::Quaterniond().setFromTwoVectors(tnormal, -Vec3d::UnitZ());
         v.set_instance_rotation(Geometry::extract_euler_angles(extra_rotation.toRotationMatrix() * m_cache.volumes_data[i].get_instance_rotation_matrix()));
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
     }
 
 #if !DISABLE_INSTANCES_SYNCH
@@ -1208,7 +1066,7 @@ void Selection::flattening_rotate(const Vec3d& normal)
     this->set_bounding_boxes_dirty();
 }
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
 void Selection::scale(const Vec3d& scale, TransformationType transformation_type)
 {
     scale_and_translate(scale, Vec3d::Zero(), transformation_type);
@@ -1233,9 +1091,6 @@ void Selection::scale(const Vec3d& scale, TransformationType transformation_type
                 v.set_instance_scaling_factor(new_scale);
             }
             else {
-#if ENABLE_WORLD_COORDINATE
-                v.set_instance_scaling_factor(scale);
-#else
                 if (transformation_type.world() && (std::abs(scale.x() - scale.y()) > EPSILON || std::abs(scale.x() - scale.z()) > EPSILON)) {
                     // Non-uniform scaling. Transform the scaling factors into the local coordinate system.
                     // This is only possible, if the instance rotation is mulitples of ninety degrees.
@@ -1244,14 +1099,9 @@ void Selection::scale(const Vec3d& scale, TransformationType transformation_type
                 }
                 else
                     v.set_instance_scaling_factor(scale);
-#endif // ENABLE_WORLD_COORDINATE
             }
         }
-#if ENABLE_WORLD_COORDINATE
-        else if (is_single_volume_or_modifier())
-#else
         else if (is_single_volume() || is_single_modifier())
-#endif // ENABLE_WORLD_COORDINATE
             v.set_volume_scaling_factor(scale);
         else {
             const Transform3d m = Geometry::assemble_transform(Vec3d::Zero(), Vec3d::Zero(), scale);
@@ -1288,7 +1138,7 @@ void Selection::scale(const Vec3d& scale, TransformationType transformation_type
     set_bounding_boxes_dirty();
     wxGetApp().plater()->canvas3D()->requires_check_outside_state();
 }
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 
 void Selection::scale_to_fit_print_volume(const BuildVolume& volume)
 {
@@ -1311,13 +1161,13 @@ void Selection::scale_to_fit_print_volume(const BuildVolume& volume)
         // center selection on print bed
         setup_cache();
         offset.z() = -get_bounding_box().min.z();
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
         TransformationType trafo_type;
         trafo_type.set_relative();
         translate(offset, trafo_type);
 #else
         translate(offset);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
         wxGetApp().plater()->canvas3D()->do_move(""); // avoid storing another snapshot
 
         wxGetApp().obj_manipul()->set_dirty();
@@ -1407,7 +1257,7 @@ void Selection::mirror(Axis axis)
     set_bounding_boxes_dirty();
 }
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
 void Selection::scale_and_translate(const Vec3d& scale, const Vec3d& translation, TransformationType transformation_type)
 {
     if (!m_valid)
@@ -1586,7 +1436,7 @@ void Selection::translate(unsigned int object_idx, const Vec3d& displacement)
 
     this->set_bounding_boxes_dirty();
 }
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 
 void Selection::translate(unsigned int object_idx, unsigned int instance_idx, const Vec3d& displacement)
 {
@@ -1596,11 +1446,11 @@ void Selection::translate(unsigned int object_idx, unsigned int instance_idx, co
     for (unsigned int i : m_list) {
         GLVolume& v = *(*m_volumes)[i];
         if (v.object_idx() == (int)object_idx && v.instance_idx() == (int)instance_idx)
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
             v.set_instance_transformation(Geometry::translation_transform(displacement) * v.get_instance_transformation().get_matrix());
 #else
             v.set_instance_offset(v.get_instance_offset() + displacement);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
     }
 
     std::set<unsigned int> done;  // prevent processing volumes twice
@@ -1633,11 +1483,11 @@ void Selection::translate(unsigned int object_idx, unsigned int instance_idx, co
             if (v.object_idx() != object_idx || v.instance_idx() != (int)instance_idx)
                 continue;
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
             v.set_instance_transformation(Geometry::translation_transform(displacement) * v.get_instance_transformation().get_matrix());
 #else
             v.set_instance_offset(v.get_instance_offset() + displacement);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
             done.insert(j);
         }
     }
@@ -1821,13 +1671,8 @@ void Selection::render(float scale_factor)
     }
     else if (coordinates_type == ECoordinatesType::Local && is_single_volume_or_modifier()) {
         const GLVolume& v = *get_first_volume();
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
         box = v.transformed_convex_hull_bounding_box(v.get_volume_transformation().get_scaling_factor_matrix());
         trafo = v.get_instance_transformation().get_matrix() * v.get_volume_transformation().get_matrix_no_scaling_factor();
-#else
-        box = v.transformed_convex_hull_bounding_box(v.get_instance_transformation().get_matrix(true, true, false, true) * v.get_volume_transformation().get_matrix(true, true, false, true));
-        trafo = v.get_instance_transformation().get_matrix(false, false, true, false) * v.get_volume_transformation().get_matrix(false, false, true, false);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
     }
     else {
         const Selection::IndicesList& ids = get_volume_idxs();
@@ -1835,14 +1680,9 @@ void Selection::render(float scale_factor)
             const GLVolume& v = *get_volume(id);
             box.merge(v.transformed_convex_hull_bounding_box(v.get_volume_transformation().get_matrix()));
         }
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
         const Geometry::Transformation inst_trafo = get_first_volume()->get_instance_transformation();
         box = box.transformed(inst_trafo.get_scaling_factor_matrix());
         trafo = inst_trafo.get_matrix_no_scaling_factor();
-#else
-        box = box.transformed(get_first_volume()->get_instance_transformation().get_matrix(true, true, false, true));
-        trafo = get_first_volume()->get_instance_transformation().get_matrix(false, false, true, false);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
     }
 
     render_bounding_box(box, trafo, ColorRGB::WHITE());
@@ -1929,12 +1769,10 @@ void Selection::render_sidebar_hints(const std::string& sidebar_field)
 
 #if ENABLE_GL_SHADERS_ATTRIBUTES
     const Transform3d base_matrix = Geometry::assemble_transform(get_bounding_box().center());
-#endif // ENABLE_GL_SHADERS_ATTRIBUTES
-#if ENABLE_GL_SHADERS_ATTRIBUTES || ENABLE_WORLD_COORDINATE
     Transform3d orient_matrix = Transform3d::Identity();
 #else
     glsafe(::glPushMatrix());
-#endif // ENABLE_GL_SHADERS_ATTRIBUTES || ENABLE_WORLD_COORDINATE
+#endif // ENABLE_GL_SHADERS_ATTRIBUTES
 
 #if ENABLE_WORLD_COORDINATE
     const Vec3d center = get_bounding_box().center();
@@ -1957,11 +1795,7 @@ void Selection::render_sidebar_hints(const std::string& sidebar_field)
             glsafe(::glTranslated(center.x(), center.y(), center.z()));
 #endif // !ENABLE_GL_SHADERS_ATTRIBUTES && !ENABLE_WORLD_COORDINATE
 #if ENABLE_WORLD_COORDINATE
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
             orient_matrix = (*m_volumes)[*m_list.begin()]->get_instance_transformation().get_rotation_matrix();
-#else
-            orient_matrix = (*m_volumes)[*m_list.begin()]->get_instance_transformation().get_matrix(true, false, true, true);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
             axes_center = (*m_volumes)[*m_list.begin()]->get_instance_offset();
 #else
             if (!boost::starts_with(sidebar_field, "position")) {
@@ -1999,19 +1833,11 @@ void Selection::render_sidebar_hints(const std::string& sidebar_field)
             if (!wxGetApp().obj_manipul()->is_world_coordinates()) {
                 if (wxGetApp().obj_manipul()->is_local_coordinates()) {
                     const GLVolume* v = (*m_volumes)[*m_list.begin()];
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
                     orient_matrix = v->get_instance_transformation().get_rotation_matrix() * v->get_volume_transformation().get_rotation_matrix();
-#else
-                    orient_matrix = v->get_instance_transformation().get_matrix(true, false, true, true) * v->get_volume_transformation().get_matrix(true, false, true, true);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
                     axes_center = (*m_volumes)[*m_list.begin()]->world_matrix().translation();
                 }
                 else {
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
                     orient_matrix = (*m_volumes)[*m_list.begin()]->get_instance_transformation().get_rotation_matrix();
-#else
-                    orient_matrix = (*m_volumes)[*m_list.begin()]->get_instance_transformation().get_matrix(true, false, true, true);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
                     axes_center = (*m_volumes)[*m_list.begin()]->get_instance_offset();
                 }
             }
@@ -2031,11 +1857,11 @@ void Selection::render_sidebar_hints(const std::string& sidebar_field)
         else {
 #if ENABLE_GL_SHADERS_ATTRIBUTES || ENABLE_WORLD_COORDINATE
             if (requires_local_axes())
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
                 orient_matrix = (*m_volumes)[*m_list.begin()]->get_instance_transformation().get_rotation_matrix();
 #else
                 orient_matrix = (*m_volumes)[*m_list.begin()]->get_instance_transformation().get_matrix(true, false, true, true);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 #else
             glsafe(::glTranslated(center.x(), center.y(), center.z()));
             if (requires_local_axes()) {
@@ -2917,11 +2743,11 @@ void Selection::render_sidebar_scale_hints(const std::string& sidebar_field, GLS
 void Selection::render_sidebar_scale_hints(const std::string& sidebar_field)
 #endif // ENABLE_GL_SHADERS_ATTRIBUTES
 {
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     const bool uniform_scale = wxGetApp().obj_manipul()->get_uniform_scaling();
 #else
     const bool uniform_scale = requires_uniform_scale() || wxGetApp().obj_manipul()->get_uniform_scaling();
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 
 #if ENABLE_GL_SHADERS_ATTRIBUTES
     auto render_sidebar_scale_hint = [this, uniform_scale](Axis axis, GLShaderProgram& shader, const Transform3d& matrix) {
@@ -3190,7 +3016,7 @@ void Selection::synchronize_unselected_instances(SyncRotationType sync_rotation_
 #endif // ENABLE_WIPETOWER_OBJECTID_1000_REMOVAL
 
         const int instance_idx = volume_i->instance_idx();
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
         const Geometry::Transformation& curr_inst_trafo_i = volume_i->get_instance_transformation();
         const Vec3d curr_inst_rotation_i = curr_inst_trafo_i.get_rotation();
         const Vec3d& curr_inst_scaling_factor_i = curr_inst_trafo_i.get_scaling_factor();
@@ -3200,7 +3026,7 @@ void Selection::synchronize_unselected_instances(SyncRotationType sync_rotation_
         const Vec3d& rotation = volume_i->get_instance_rotation();
         const Vec3d& scaling_factor = volume_i->get_instance_scaling_factor();
         const Vec3d& mirror = volume_i->get_instance_mirror();
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 
         // Process unselected instances.
         for (unsigned int j = 0; j < (unsigned int)m_volumes->size(); ++j) {
@@ -3214,7 +3040,7 @@ void Selection::synchronize_unselected_instances(SyncRotationType sync_rotation_
             if (volume_j->object_idx() != object_idx || volume_j->instance_idx() == instance_idx)
                 continue;
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
             const Vec3d old_inst_rotation_j = m_cache.volumes_data[j].get_instance_transform().get_rotation();
             assert(is_rotation_xy_synchronized(old_inst_rotation_i, old_inst_rotation_j));
             const Geometry::Transformation& curr_inst_trafo_j = volume_j->get_instance_transformation();
@@ -3223,12 +3049,12 @@ void Selection::synchronize_unselected_instances(SyncRotationType sync_rotation_
             Vec3d new_inst_rotation_j = curr_inst_rotation_j; 
 #else
             assert(is_rotation_xy_synchronized(m_cache.volumes_data[i].get_instance_rotation(), m_cache.volumes_data[j].get_instance_rotation()));
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
             switch (sync_rotation_type) {
             case SyncRotationType::NONE: {
                 // z only rotation -> synch instance z
                 // The X,Y rotations should be synchronized from start to end of the rotation.
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
                 assert(is_rotation_xy_synchronized(curr_inst_rotation_i, curr_inst_rotation_j));
                 if (wxGetApp().preset_bundle->printers.get_edited_preset().printer_technology() != ptSLA)
                     new_inst_offset_j.z() = curr_inst_trafo_i.get_offset().z();
@@ -3236,51 +3062,41 @@ void Selection::synchronize_unselected_instances(SyncRotationType sync_rotation_
                 assert(is_rotation_xy_synchronized(rotation, volume_j->get_instance_rotation()));
                 if (wxGetApp().preset_bundle->printers.get_edited_preset().printer_technology() != ptSLA)
                     volume_j->set_instance_offset(Z, volume_i->get_instance_offset().z());
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
                 break;
             }
             case SyncRotationType::GENERAL: {
                 // generic rotation -> update instance z with the delta of the rotation.
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
                 const double z_diff = Geometry::rotation_diff_z(old_inst_rotation_i, old_inst_rotation_j);
                 new_inst_rotation_j = curr_inst_rotation_i + z_diff * Vec3d::UnitZ();
 #else
                 const double z_diff = Geometry::rotation_diff_z(m_cache.volumes_data[i].get_instance_rotation(), m_cache.volumes_data[j].get_instance_rotation());
                 volume_j->set_instance_rotation({ rotation.x(), rotation.y(), rotation.z() + z_diff });
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
                 break;
             }
 #if ENABLE_WORLD_COORDINATE
             case SyncRotationType::FULL: {
                 // generic rotation -> update instance z with the delta of the rotation.
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
                 const Eigen::AngleAxisd angle_axis(Geometry::rotation_xyz_diff(curr_inst_rotation_i, old_inst_rotation_j));
-#else
-                const Eigen::AngleAxisd angle_axis(Geometry::rotation_xyz_diff(rotation, m_cache.volumes_data[j].get_instance_rotation()));
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
                 const Vec3d& axis = angle_axis.axis();
                 const double z_diff = (std::abs(axis.x()) > EPSILON || std::abs(axis.y()) > EPSILON) ?
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
                     angle_axis.angle() * axis.z() : Geometry::rotation_diff_z(curr_inst_rotation_i, old_inst_rotation_j);
 
                 new_inst_rotation_j = curr_inst_rotation_i + z_diff * Vec3d::UnitZ();
-#else
-                    angle_axis.angle()* axis.z() : Geometry::rotation_diff_z(rotation, m_cache.volumes_data[j].get_instance_rotation());
-
-                volume_j->set_instance_rotation({ rotation.x(), rotation.y(), rotation.z() + z_diff });
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
                 break;
             }
 #endif // ENABLE_WORLD_COORDINATE
             }
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
             volume_j->set_instance_transformation(Geometry::assemble_transform(new_inst_offset_j, new_inst_rotation_j,
                 curr_inst_scaling_factor_i, curr_inst_mirror_i));
 #else
             volume_j->set_instance_scaling_factor(scaling_factor);
             volume_j->set_instance_mirror(mirror);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 
             done.insert(j);
         }
@@ -3307,14 +3123,14 @@ void Selection::synchronize_unselected_volumes()
 #endif // ENABLE_WIPETOWER_OBJECTID_1000_REMOVAL
 
         const int volume_idx = volume->volume_idx();
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
         const Geometry::Transformation& trafo = volume->get_volume_transformation();
 #else
         const Vec3d& offset = volume->get_volume_offset();
         const Vec3d& rotation = volume->get_volume_rotation();
         const Vec3d& scaling_factor = volume->get_volume_scaling_factor();
         const Vec3d& mirror = volume->get_volume_mirror();
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 
         // Process unselected volumes.
         for (unsigned int j = 0; j < (unsigned int)m_volumes->size(); ++j) {
@@ -3325,14 +3141,14 @@ void Selection::synchronize_unselected_volumes()
             if (v->object_idx() != object_idx || v->volume_idx() != volume_idx)
                 continue;
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
             v->set_volume_transformation(trafo);
 #else
             v->set_volume_offset(offset);
             v->set_volume_rotation(rotation);
             v->set_volume_scaling_factor(scaling_factor);
             v->set_volume_mirror(mirror);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
         }
     }
 }
@@ -3447,13 +3263,13 @@ void Selection::paste_volumes_from_clipboard()
     {
         ModelInstance* dst_instance = dst_object->instances[dst_inst_idx];
         BoundingBoxf3 dst_instance_bb = dst_object->instance_bounding_box(dst_inst_idx);
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
         Transform3d src_matrix = src_object->instances[0]->get_transformation().get_matrix_no_offset();
         Transform3d dst_matrix = dst_instance->get_transformation().get_matrix_no_offset();
 #else
         Transform3d src_matrix = src_object->instances[0]->get_transformation().get_matrix(true);
         Transform3d dst_matrix = dst_instance->get_transformation().get_matrix(true);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
         bool from_same_object = (src_object->input_file == dst_object->input_file) && src_matrix.isApprox(dst_matrix);
 
         // used to keep relative position of multivolume selections when pasting from another object
@@ -3531,7 +3347,7 @@ void Selection::paste_objects_from_clipboard()
 #endif /* _DEBUG */
 }
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
 void Selection::transform_volume_relative(GLVolume& volume, const VolumeCache& volume_data, TransformationType transformation_type,
     const Transform3d& transform)
 {
@@ -3551,7 +3367,7 @@ void Selection::transform_volume_relative(GLVolume& volume, const VolumeCache& v
     else
         assert(false);
 }
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 
 } // namespace GUI
 } // namespace Slic3r
diff --git a/src/slic3r/GUI/Selection.hpp b/src/slic3r/GUI/Selection.hpp
index a20e952f3..0e6922c63 100644
--- a/src/slic3r/GUI/Selection.hpp
+++ b/src/slic3r/GUI/Selection.hpp
@@ -125,9 +125,9 @@ private:
             Transform3d scale_matrix{ Transform3d::Identity() };
             Transform3d mirror_matrix{ Transform3d::Identity() };
             Transform3d full_matrix{ Transform3d::Identity() };
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
             Geometry::Transformation transform;
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 
             TransformCache() = default;
             explicit TransformCache(const Geometry::Transformation& transform);
@@ -141,18 +141,18 @@ private:
         VolumeCache(const Geometry::Transformation& volume_transform, const Geometry::Transformation& instance_transform);
 
         const Vec3d& get_volume_position() const { return m_volume.position; }
-#if !ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if !ENABLE_WORLD_COORDINATE
         const Vec3d& get_volume_rotation() const { return m_volume.rotation; }
         const Vec3d& get_volume_scaling_factor() const { return m_volume.scaling_factor; }
         const Vec3d& get_volume_mirror() const { return m_volume.mirror; }
-#endif // !ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // !ENABLE_WORLD_COORDINATE
         const Transform3d& get_volume_rotation_matrix() const { return m_volume.rotation_matrix; }
         const Transform3d& get_volume_scale_matrix() const { return m_volume.scale_matrix; }
         const Transform3d& get_volume_mirror_matrix() const { return m_volume.mirror_matrix; }
         const Transform3d& get_volume_full_matrix() const { return m_volume.full_matrix; }
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
         const Geometry::Transformation& get_volume_transform() const { return m_volume.transform; }
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 
         const Vec3d& get_instance_position() const { return m_instance.position; }
         const Vec3d& get_instance_rotation() const { return m_instance.rotation; }
@@ -162,9 +162,9 @@ private:
         const Transform3d& get_instance_scale_matrix() const { return m_instance.scale_matrix; }
         const Transform3d& get_instance_mirror_matrix() const { return m_instance.mirror_matrix; }
         const Transform3d& get_instance_full_matrix() const { return m_instance.full_matrix; }
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
         const Geometry::Transformation& get_instance_transform() const { return m_instance.transform; }
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
     };
 
 public:
@@ -232,7 +232,7 @@ private:
     // Bounding box of a single full instance selection, in world coordinates.
     // Modifiers are NOT taken in account
     std::optional<BoundingBoxf3> m_scaled_instance_bounding_box;
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     // Bounding box of a single full instance selection, in world coordinates, with no instance scaling applied.
     // Modifiers are taken in account
     std::optional<BoundingBoxf3> m_full_unscaled_instance_bounding_box;
@@ -242,7 +242,7 @@ private:
     // Bounding box of a single full instance selection, in local coordinates, with no instance scaling applied.
     // Modifiers are taken in account
     std::optional<BoundingBoxf3> m_full_unscaled_instance_local_bounding_box;
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 
 #if ENABLE_RENDER_SELECTION_CENTER
     GLModel m_vbo_sphere;
@@ -346,9 +346,6 @@ public:
         VolumeNotAxisAligned_Instance,
         MultipleSelection,
     };
-#if !ENABLE_TRANSFORMATIONS_BY_MATRICES
-    bool requires_uniform_scale(EUniformScaleRequiredReason* reason = nullptr) const;
-#endif // !ENABLE_TRANSFORMATIONS_BY_MATRICES
 #else
     bool requires_uniform_scale() const;
 #endif // ENABLE_WORLD_COORDINATE
@@ -376,7 +373,7 @@ public:
     // Bounding box of a single full instance selection, in world coordinates.
     // Modifiers are NOT taken in account
     const BoundingBoxf3& get_scaled_instance_bounding_box() const;
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     // Bounding box of a single full instance selection, in world coordinates, with no instance scaling applied.
     // Modifiers are taken in account
     const BoundingBoxf3& get_full_unscaled_instance_bounding_box() const;
@@ -387,16 +384,12 @@ public:
     // Bounding box of a single full instance selection, in local coordinates, with no instance scaling applied.
     // Modifiers are taken in account
     const BoundingBoxf3& get_full_unscaled_instance_local_bounding_box() const;
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 
     void setup_cache();
 
 #if ENABLE_WORLD_COORDINATE
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
     void translate(const Vec3d& displacement, TransformationType transformation_type);
-#else
-    void translate(const Vec3d& displacement, ECoordinatesType type = ECoordinatesType::World);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
 #else
     void translate(const Vec3d& displacement, bool local = false);
 #endif // ENABLE_WORLD_COORDINATE
@@ -405,14 +398,12 @@ public:
     void scale(const Vec3d& scale, TransformationType transformation_type);
     void scale_to_fit_print_volume(const BuildVolume& volume);
     void mirror(Axis axis);
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     void scale_and_translate(const Vec3d& scale, const Vec3d& translation, TransformationType transformation_type);
     void reset_skew();
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
-
-#if !ENABLE_TRANSFORMATIONS_BY_MATRICES
+#else
     void translate(unsigned int object_idx, const Vec3d& displacement);
-#endif // !ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
     void translate(unsigned int object_idx, unsigned int instance_idx, const Vec3d& displacement);
 
 #if ENABLE_WORLD_COORDINATE
@@ -458,7 +449,7 @@ private:
     void do_remove_volume(unsigned int volume_idx);
     void do_remove_instance(unsigned int object_idx, unsigned int instance_idx);
     void do_remove_object(unsigned int object_idx);
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     void set_bounding_boxes_dirty() {
         m_bounding_box.reset();
         m_unscaled_instance_bounding_box.reset(); m_scaled_instance_bounding_box.reset();
@@ -467,7 +458,7 @@ private:
     }
 #else
     void set_bounding_boxes_dirty() { m_bounding_box.reset(); m_unscaled_instance_bounding_box.reset(); m_scaled_instance_bounding_box.reset(); }
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
     void render_synchronized_volumes();
 #if ENABLE_LEGACY_OPENGL_REMOVAL
 #if ENABLE_WORLD_COORDINATE
@@ -513,10 +504,10 @@ private:
     void paste_volumes_from_clipboard();
     void paste_objects_from_clipboard();
 
-#if ENABLE_TRANSFORMATIONS_BY_MATRICES
+#if ENABLE_WORLD_COORDINATE
     void transform_volume_relative(GLVolume& volume, const VolumeCache& volume_data, TransformationType transformation_type,
         const Transform3d& transform);
-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES
+#endif // ENABLE_WORLD_COORDINATE
 };
 
 } // namespace GUI