Tech ENABLE_TRANSFORMATIONS_BY_MATRICES - Reworked method void synchronize_unselected_instances(SyncRotationType sync_rotation_type) to use the new matrix only implementation of Geometry::Transformation

Fixed conflicts during rebase with master

1 files changed, 48 insertions, 23 deletions

diff --git a/src/slic3r/GUI/Selection.cpp b/src/slic3r/GUI/Selection.cpp
index b94c2eb38..a3bf2bf7b 100644
--- a/src/slic3r/GUI/Selection.cpp
+++ b/src/slic3r/GUI/Selection.cpp
@@ -3026,22 +3026,30 @@ void Selection::synchronize_unselected_instances(SyncRotationType sync_rotation_
         if (done.size() == m_volumes->size())

             break;

 

-        const GLVolume* volume = (*m_volumes)[i];

+        const GLVolume* volume_i = (*m_volumes)[i];

 #if ENABLE_WIPETOWER_OBJECTID_1000_REMOVAL

-        if (volume->is_wipe_tower)

+        if (volume_i->is_wipe_tower)

             continue;

 

-        const int object_idx = volume->object_idx();

+        const int object_idx = volume_i->object_idx();

 #else

-        const int object_idx = volume->object_idx();

+        const int object_idx = volume_i->object_idx();

         if (object_idx >= 1000)

             continue;

 #endif // ENABLE_WIPETOWER_OBJECTID_1000_REMOVAL

 

-        const int instance_idx = volume->instance_idx();

-        const Vec3d& rotation = volume->get_instance_rotation();

-        const Vec3d& scaling_factor = volume->get_instance_scaling_factor();

-        const Vec3d& mirror = volume->get_instance_mirror();

+        const int instance_idx = volume_i->instance_idx();

+#if ENABLE_TRANSFORMATIONS_BY_MATRICES

+        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();

+        const Vec3d& curr_inst_mirror_i = curr_inst_trafo_i.get_mirror();

+        const Vec3d old_inst_rotation_i = m_cache.volumes_data[i].get_instance_transform().get_rotation();

+#else

+        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

 

         // Process unselected instances.

         for (unsigned int j = 0; j < (unsigned int)m_volumes->size(); ++j) {

@@ -3051,14 +3059,17 @@ void Selection::synchronize_unselected_instances(SyncRotationType sync_rotation_
             if (done.find(j) != done.end())

                 continue;

 

-            GLVolume* v = (*m_volumes)[j];

-            if (v->object_idx() != object_idx || v->instance_idx() == instance_idx)

+            GLVolume* volume_j = (*m_volumes)[j];

+            if (volume_j->object_idx() != object_idx || volume_j->instance_idx() == instance_idx)

                 continue;

 

 #if ENABLE_TRANSFORMATIONS_BY_MATRICES

-            const Vec3d inst_rotation_i = m_cache.volumes_data[i].get_instance_transform().get_rotation();

-            const Vec3d inst_rotation_j = m_cache.volumes_data[j].get_instance_transform().get_rotation();

-            assert(is_rotation_xy_synchronized(inst_rotation_i, inst_rotation_j));

+            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();

+            const Vec3d curr_inst_rotation_j = curr_inst_trafo_j.get_rotation();

+            Vec3d new_inst_offset_j = curr_inst_trafo_j.get_offset();

+            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

@@ -3066,45 +3077,59 @@ void Selection::synchronize_unselected_instances(SyncRotationType sync_rotation_
             case SyncRotationType::NONE: {

                 // z only rotation -> synch instance z

                 // The X,Y rotations should be synchronized from start to end of the rotation.

-                assert(is_rotation_xy_synchronized(rotation, v->get_instance_rotation()));

+#if ENABLE_TRANSFORMATIONS_BY_MATRICES

+                assert(is_rotation_xy_synchronized(curr_inst_rotation_i, curr_inst_rotation_j));

                 if (wxGetApp().preset_bundle->printers.get_edited_preset().printer_technology() != ptSLA)

-                    v->set_instance_offset(Z, volume->get_instance_offset().z());

+                    new_inst_offset_j.z() = curr_inst_trafo_i.get_offset().z();

+#else

+                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

                 break;

             }

             case SyncRotationType::GENERAL: {

                 // generic rotation -> update instance z with the delta of the rotation.

 #if ENABLE_TRANSFORMATIONS_BY_MATRICES

-                const double z_diff = Geometry::rotation_diff_z(inst_rotation_i, inst_rotation_j);

+                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

-                v->set_instance_rotation({ rotation.x(), rotation.y(), rotation.z() + z_diff });

                 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(rotation, inst_rotation_j));

+                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(rotation, inst_rotation_j);

+                    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());

-#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES

 

-                v->set_instance_rotation({ rotation.x(), rotation.y(), rotation.z() + z_diff });

+                volume_j->set_instance_rotation({ rotation.x(), rotation.y(), rotation.z() + z_diff });

+#endif // ENABLE_TRANSFORMATIONS_BY_MATRICES

                 break;

             }

 #endif // ENABLE_WORLD_COORDINATE

             }

 

-            v->set_instance_scaling_factor(scaling_factor);

-            v->set_instance_mirror(mirror);

+#if ENABLE_TRANSFORMATIONS_BY_MATRICES

+            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

 

             done.insert(j);

         }