3DPrinting/PrusaSlicer-NonPlainar
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

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

Browse Source 
Fixed conflicts during rebase with master
This commit is contained in:
enricoturri1966 2022-05-05 09:56:23 +02:00
parent c8d93e69be
commit 63c9ce23df
1 changed files with 48 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

71
src/slic3r/GUI/Selection.cpp
View File

@ -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);
}