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

Merge remote-tracking branch 'origin/dev2' into dev_native

Browse Source
This commit is contained in:
bubnikv 2018-09-25 15:33:51 +02:00
commit 6260e43f61
30 changed files with 785 additions and 443 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
lib/Slic3r/GUI/Plater.pm
View File

@ -144,6 +144,40 @@ sub new {
$self->schedule_background_process; $self->schedule_background_process;
}; };
# callback to react to gizmo scale
my $on_gizmo_scale_3D = sub {
my ($scale_x, $scale_y, $scale_z) = @_;
my ($obj_idx, $object) = $self->selected_object;
return if !defined $obj_idx;
my $model_object = $self->{model}->objects->[$obj_idx];
my $model_instance = $model_object->instances->[0];
$self->stop_background_process;
#FIXME Scale the layer height profile?
# my $variation = $scale / $model_instance->scaling_factor;
# foreach my $range (@{ $model_object->layer_height_ranges }) {
# $range->[0] *= $variation;
# $range->[1] *= $variation;
# }
my $scale = Slic3r::Pointf3->new($scale_x, $scale_y, $scale_z);
foreach my $inst (@{ $model_object->instances }) {
$inst->set_scaling_factors($scale);
}
Slic3r::GUI::_3DScene::update_gizmos_data($self->{canvas3D}) if ($self->{canvas3D});
#update print and start background processing
$self->{print}->add_model_object($model_object, $obj_idx);
$self->selection_changed(1); # refresh info (size, volume etc.)
$self->update;
$self->schedule_background_process;
};
# callback to react to gizmo rotate # callback to react to gizmo rotate
my $on_gizmo_rotate = sub { my $on_gizmo_rotate = sub {
my ($angle) = @_; my ($angle) = @_;
@ -223,6 +257,21 @@ sub new {
} }
}; };
# callback to update object's geometry info while using gizmos
my $on_update_geometry_3D_info = sub {
my ($size_x, $size_y, $size_z, $scale_x, $scale_y, $scale_z) = @_;
my ($obj_idx, $object) = $self->selected_object;
if ((defined $obj_idx) && ($self->{object_info_size})) { # have we already loaded the info pane?
$self->{object_info_size}->SetLabel(sprintf("%.2f x %.2f x %.2f", $size_x, $size_y, $size_z));
my $model_object = $self->{model}->objects->[$obj_idx];
if (my $stats = $model_object->mesh_stats) {
$self->{object_info_volume}->SetLabel(sprintf('%.2f', $stats->{volume} * $scale_x * $scale_y * $scale_z));
}
}
};
# callbacks for toolbar # callbacks for toolbar
my $on_action_add = sub { my $on_action_add = sub {
$self->add; $self->add;
@ -312,11 +361,13 @@ sub new {
Slic3r::GUI::_3DScene::register_on_instance_moved_callback($self->{canvas3D}, $on_instances_moved); Slic3r::GUI::_3DScene::register_on_instance_moved_callback($self->{canvas3D}, $on_instances_moved);
Slic3r::GUI::_3DScene::register_on_enable_action_buttons_callback($self->{canvas3D}, $enable_action_buttons); Slic3r::GUI::_3DScene::register_on_enable_action_buttons_callback($self->{canvas3D}, $enable_action_buttons);
Slic3r::GUI::_3DScene::register_on_gizmo_scale_uniformly_callback($self->{canvas3D}, $on_gizmo_scale_uniformly); Slic3r::GUI::_3DScene::register_on_gizmo_scale_uniformly_callback($self->{canvas3D}, $on_gizmo_scale_uniformly);
Slic3r::GUI::_3DScene::register_on_gizmo_scale_3D_callback($self->{canvas3D}, $on_gizmo_scale_3D);
Slic3r::GUI::_3DScene::register_on_gizmo_rotate_callback($self->{canvas3D}, $on_gizmo_rotate); Slic3r::GUI::_3DScene::register_on_gizmo_rotate_callback($self->{canvas3D}, $on_gizmo_rotate);
Slic3r::GUI::_3DScene::register_on_gizmo_rotate_3D_callback($self->{canvas3D}, $on_gizmo_rotate_3D); Slic3r::GUI::_3DScene::register_on_gizmo_rotate_3D_callback($self->{canvas3D}, $on_gizmo_rotate_3D);
Slic3r::GUI::_3DScene::register_on_gizmo_flatten_callback($self->{canvas3D}, $on_gizmo_flatten); Slic3r::GUI::_3DScene::register_on_gizmo_flatten_callback($self->{canvas3D}, $on_gizmo_flatten);
Slic3r::GUI::_3DScene::register_on_gizmo_flatten_3D_callback($self->{canvas3D}, $on_gizmo_flatten_3D); Slic3r::GUI::_3DScene::register_on_gizmo_flatten_3D_callback($self->{canvas3D}, $on_gizmo_flatten_3D);
Slic3r::GUI::_3DScene::register_on_update_geometry_info_callback($self->{canvas3D}, $on_update_geometry_info); Slic3r::GUI::_3DScene::register_on_update_geometry_info_callback($self->{canvas3D}, $on_update_geometry_info);
Slic3r::GUI::_3DScene::register_on_update_geometry_3D_info_callback($self->{canvas3D}, $on_update_geometry_3D_info);
Slic3r::GUI::_3DScene::register_action_add_callback($self->{canvas3D}, $on_action_add); Slic3r::GUI::_3DScene::register_action_add_callback($self->{canvas3D}, $on_action_add);
Slic3r::GUI::_3DScene::register_action_delete_callback($self->{canvas3D}, $on_action_delete); Slic3r::GUI::_3DScene::register_action_delete_callback($self->{canvas3D}, $on_action_delete);
Slic3r::GUI::_3DScene::register_action_deleteall_callback($self->{canvas3D}, $on_action_deleteall); Slic3r::GUI::_3DScene::register_action_deleteall_callback($self->{canvas3D}, $on_action_deleteall);

4
lib/Slic3r/Model.pm
View File

@ -122,9 +122,9 @@ sub add_instance {
my $new_instance = $self->_add_instance; my $new_instance = $self->_add_instance;
$new_instance->set_rotation($args{rotation}) $new_instance->set_rotations($args{rotation})
if defined $args{rotation}; if defined $args{rotation};
$new_instance->set_scaling_factor($args{scaling_factor}) $new_instance->set_scaling_factors($args{scaling_factor})
if defined $args{scaling_factor}; if defined $args{scaling_factor};
$new_instance->set_offset($args{offset}) $new_instance->set_offset($args{offset})
if defined $args{offset}; if defined $args{offset};

8
lib/Slic3r/Test.pm
View File

@ -158,8 +158,12 @@ sub model {
$object->add_volume(mesh => $mesh, material_id => $model_name); $object->add_volume(mesh => $mesh, material_id => $model_name);
$object->add_instance( $object->add_instance(
offset => Slic3r::Pointf->new(0,0), offset => Slic3r::Pointf->new(0,0),
rotation => $params{rotation} // 0, # 3D full transform
scaling_factor => $params{scale} // 1, rotation => Slic3r::Pointf3->new(0, 0, $params{rotation} // 0),
scaling_factor => Slic3r::Pointf3->new($params{scale} // 1, $params{scale} // 1, $params{scale} // 1),
# old transform
# rotation => $params{rotation} // 0,
# scaling_factor => $params{scale} // 1,
); );
return $model; return $model;
} }

27
src/libslic3r/Format/3mf.cpp
View File

@ -1252,13 +1252,13 @@ namespace Slic3r {
// we extract from the given matrix only the values currently used // we extract from the given matrix only the values currently used
// translation // translation
#if ENABLE_MODELINSTANCE_3D_OFFSET #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
Vec3d offset(transform(0, 3), transform(1, 3), transform(2, 3)); Vec3d offset(transform(0, 3), transform(1, 3), transform(2, 3));
#else #else
double offset_x = transform(0, 3); double offset_x = transform(0, 3);
double offset_y = transform(1, 3); double offset_y = transform(1, 3);
double offset_z = transform(2, 3); double offset_z = transform(2, 3);
#endif // ENABLE_MODELINSTANCE_3D_OFFSET #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
// scale // scale
double sx = ::sqrt(sqr(transform(0, 0)) + sqr(transform(1, 0)) + sqr(transform(2, 0))); double sx = ::sqrt(sqr(transform(0, 0)) + sqr(transform(1, 0)) + sqr(transform(2, 0)));
@ -1269,21 +1269,28 @@ namespace Slic3r {
if ((sx == 0.0) || (sy == 0.0) || (sz == 0.0)) if ((sx == 0.0) || (sy == 0.0) || (sz == 0.0))
return; return;
#if !ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
// non-uniform scale value, return // non-uniform scale value, return
if ((std::abs(sx - sy) > 0.00001) || (std::abs(sx - sz) > 0.00001)) if ((std::abs(sx - sy) > 0.00001) || (std::abs(sx - sz) > 0.00001))
return; return;
#endif // !ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
double inv_sx = 1.0 / sx; double inv_sx = 1.0 / sx;
double inv_sy = 1.0 / sy; double inv_sy = 1.0 / sy;
double inv_sz = 1.0 / sz; double inv_sz = 1.0 / sz;
Eigen::Matrix3d m3x3; Eigen::Matrix<double, 3, 3, Eigen::DontAlign> m3x3;
m3x3 << transform(0, 0) * inv_sx, transform(0, 1) * inv_sy, transform(0, 2) * inv_sz, m3x3 << transform(0, 0) * inv_sx, transform(0, 1) * inv_sy, transform(0, 2) * inv_sz,
transform(1, 0) * inv_sx, transform(1, 1) * inv_sy, transform(1, 2) * inv_sz, transform(1, 0) * inv_sx, transform(1, 1) * inv_sy, transform(1, 2) * inv_sz,
transform(2, 0) * inv_sx, transform(2, 1) * inv_sy, transform(2, 2) * inv_sz; transform(2, 0) * inv_sx, transform(2, 1) * inv_sy, transform(2, 2) * inv_sz;
#if ENABLE_MODELINSTANCE_3D_ROTATION #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
Vec3d rotation = m3x3.eulerAngles(0, 1, 2); Vec3d angles = m3x3.eulerAngles(2, 1, 0);
Vec3d rotation(angles(2), angles(1), angles(0));
instance.set_offset(offset);
instance.set_scaling_factor(Vec3d(sx, sy, sz));
instance.set_rotation(rotation);
#else #else
Eigen::AngleAxisd rotation; Eigen::AngleAxisd rotation;
rotation.fromRotationMatrix(m3x3); rotation.fromRotationMatrix(m3x3);
@ -1293,20 +1300,12 @@ namespace Slic3r {
return; return;
double angle_z = (rotation.axis() == Vec3d::UnitZ()) ? rotation.angle() : -rotation.angle(); double angle_z = (rotation.axis() == Vec3d::UnitZ()) ? rotation.angle() : -rotation.angle();
#endif // ENABLE_MODELINSTANCE_3D_ROTATION
#if ENABLE_MODELINSTANCE_3D_OFFSET
instance.set_offset(offset);
#else
instance.offset(0) = offset_x; instance.offset(0) = offset_x;
instance.offset(1) = offset_y; instance.offset(1) = offset_y;
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
instance.scaling_factor = sx; instance.scaling_factor = sx;
#if ENABLE_MODELINSTANCE_3D_ROTATION
instance.set_rotation(rotation);
#else
instance.rotation = angle_z; instance.rotation = angle_z;
#endif // ENABLE_MODELINSTANCE_3D_ROTATION #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
} }
bool _3MF_Importer::_handle_start_config(const char** attributes, unsigned int num_attributes) bool _3MF_Importer::_handle_start_config(const char** attributes, unsigned int num_attributes)

140
src/libslic3r/Format/AMF.cpp
View File

@ -29,17 +29,14 @@
// VERSION NUMBERS // VERSION NUMBERS
// 0 : .amf, .amf.xml and .zip.amf files saved by older slic3r. No version definition in them. // 0 : .amf, .amf.xml and .zip.amf files saved by older slic3r. No version definition in them.
// 1 : Introduction of amf versioning. No other change in data saved into amf files. // 1 : Introduction of amf versioning. No other change in data saved into amf files.
#if ENABLE_MODELINSTANCE_3D_OFFSET #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
#if ENABLE_MODELINSTANCE_3D_ROTATION
// 2 : Added z component of offset // 2 : Added z component of offset
// Added x and y components of rotation // Added x and y components of rotation
#else // Added x, y and z components of scale
// 2 : Added z component of offset.
#endif // ENABLE_MODELINSTANCE_3D_ROTATION
const unsigned int VERSION_AMF = 2; const unsigned int VERSION_AMF = 2;
#else #else
const unsigned int VERSION_AMF = 1; const unsigned int VERSION_AMF = 1;
#endif // ENABLE_MODELINSTANCE_3D_OFFSET #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
const char* SLIC3RPE_AMF_VERSION = "slic3rpe_amf_version"; const char* SLIC3RPE_AMF_VERSION = "slic3rpe_amf_version";
const char* SLIC3R_CONFIG_TYPE = "slic3rpe_config"; const char* SLIC3R_CONFIG_TYPE = "slic3rpe_config";
@ -128,53 +125,60 @@ struct AMFParserContext
NODE_TYPE_INSTANCE, // amf/constellation/instance NODE_TYPE_INSTANCE, // amf/constellation/instance
NODE_TYPE_DELTAX, // amf/constellation/instance/deltax NODE_TYPE_DELTAX, // amf/constellation/instance/deltax
NODE_TYPE_DELTAY, // amf/constellation/instance/deltay NODE_TYPE_DELTAY, // amf/constellation/instance/deltay
#if ENABLE_MODELINSTANCE_3D_OFFSET #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
NODE_TYPE_DELTAZ, // amf/constellation/instance/deltaz NODE_TYPE_DELTAZ, // amf/constellation/instance/deltaz
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
#if ENABLE_MODELINSTANCE_3D_ROTATION
NODE_TYPE_RX, // amf/constellation/instance/rx NODE_TYPE_RX, // amf/constellation/instance/rx
NODE_TYPE_RY, // amf/constellation/instance/ry NODE_TYPE_RY, // amf/constellation/instance/ry
#endif // ENABLE_MODELINSTANCE_3D_ROTATION #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
NODE_TYPE_RZ, // amf/constellation/instance/rz NODE_TYPE_RZ, // amf/constellation/instance/rz
NODE_TYPE_SCALE, // amf/constellation/instance/scale NODE_TYPE_SCALE, // amf/constellation/instance/scale
#if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
NODE_TYPE_SCALEX, // amf/constellation/instance/scalex
NODE_TYPE_SCALEY, // amf/constellation/instance/scaley
NODE_TYPE_SCALEZ, // amf/constellation/instance/scalez
#endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
NODE_TYPE_METADATA, // anywhere under amf/*/metadata NODE_TYPE_METADATA, // anywhere under amf/*/metadata
}; };
struct Instance { struct Instance {
#if ENABLE_MODELINSTANCE_3D_OFFSET #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
#if ENABLE_MODELINSTANCE_3D_ROTATION Instance() : deltax_set(false), deltay_set(false), deltaz_set(false), rx_set(false), ry_set(false), rz_set(false), scalex_set(false), scaley_set(false), scalez_set(false) {}
Instance() : deltax_set(false), deltay_set(false), deltaz_set(false), rx_set(false), ry_set(false), rz_set(false), scale_set(false) {}
#else
Instance() : deltax_set(false), deltay_set(false), deltaz_set(false), rz_set(false), scale_set(false) {}
#endif // ENABLE_MODELINSTANCE_3D_ROTATION
#else #else
Instance() : deltax_set(false), deltay_set(false), rz_set(false), scale_set(false) {} Instance() : deltax_set(false), deltay_set(false), rz_set(false), scale_set(false) {}
#endif // ENABLE_MODELINSTANCE_3D_OFFSET #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
// Shift in the X axis. // Shift in the X axis.
float deltax; float deltax;
bool deltax_set; bool deltax_set;
// Shift in the Y axis. // Shift in the Y axis.
float deltay; float deltay;
bool deltay_set; bool deltay_set;
#if ENABLE_MODELINSTANCE_3D_OFFSET #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
// Shift in the Z axis. // Shift in the Z axis.
float deltaz; float deltaz;
bool deltaz_set; bool deltaz_set;
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
#if ENABLE_MODELINSTANCE_3D_ROTATION
// Rotation around the X axis. // Rotation around the X axis.
float rx; float rx;
bool rx_set; bool rx_set;
// Rotation around the Y axis. // Rotation around the Y axis.
float ry; float ry;
bool ry_set; bool ry_set;
#endif // ENABLE_MODELINSTANCE_3D_ROTATION #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
// Rotation around the Z axis. // Rotation around the Z axis.
float rz; float rz;
bool rz_set; bool rz_set;
#if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
// Scaling factors
float scalex;
bool scalex_set;
float scaley;
bool scaley_set;
float scalez;
bool scalez_set;
#else
// Scaling factor // Scaling factor
float scale; float scale;
bool scale_set; bool scale_set;
#endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
}; };
struct Object { struct Object {
@ -289,18 +293,24 @@ void AMFParserContext::startElement(const char *name, const char **atts)
node_type_new = NODE_TYPE_DELTAX; node_type_new = NODE_TYPE_DELTAX;
else if (strcmp(name, "deltay") == 0) else if (strcmp(name, "deltay") == 0)
node_type_new = NODE_TYPE_DELTAY; node_type_new = NODE_TYPE_DELTAY;
#if ENABLE_MODELINSTANCE_3D_OFFSET #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
else if (strcmp(name, "deltaz") == 0) else if (strcmp(name, "deltaz") == 0)
node_type_new = NODE_TYPE_DELTAZ; node_type_new = NODE_TYPE_DELTAZ;
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
#if ENABLE_MODELINSTANCE_3D_ROTATION
else if (strcmp(name, "rx") == 0) else if (strcmp(name, "rx") == 0)
node_type_new = NODE_TYPE_RX; node_type_new = NODE_TYPE_RX;
else if (strcmp(name, "ry") == 0) else if (strcmp(name, "ry") == 0)
node_type_new = NODE_TYPE_RY; node_type_new = NODE_TYPE_RY;
#endif // ENABLE_MODELINSTANCE_3D_ROTATION #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
else if (strcmp(name, "rz") == 0) else if (strcmp(name, "rz") == 0)
node_type_new = NODE_TYPE_RZ; node_type_new = NODE_TYPE_RZ;
#if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
else if (strcmp(name, "scalex") == 0)
node_type_new = NODE_TYPE_SCALEX;
else if (strcmp(name, "scaley") == 0)
node_type_new = NODE_TYPE_SCALEY;
else if (strcmp(name, "scalez") == 0)
node_type_new = NODE_TYPE_SCALEZ;
#endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
else if (strcmp(name, "scale") == 0) else if (strcmp(name, "scale") == 0)
node_type_new = NODE_TYPE_SCALE; node_type_new = NODE_TYPE_SCALE;
} }
@ -359,19 +369,20 @@ void AMFParserContext::characters(const XML_Char *s, int len)
{ {
switch (m_path.size()) { switch (m_path.size()) {
case 4: case 4:
#if ENABLE_MODELINSTANCE_3D_OFFSET #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
if (m_path.back() == NODE_TYPE_DELTAX || if (m_path.back() == NODE_TYPE_DELTAX ||
m_path.back() == NODE_TYPE_DELTAY || m_path.back() == NODE_TYPE_DELTAY ||
m_path.back() == NODE_TYPE_DELTAZ || m_path.back() == NODE_TYPE_DELTAZ ||
#if ENABLE_MODELINSTANCE_3D_ROTATION
m_path.back() == NODE_TYPE_RX || m_path.back() == NODE_TYPE_RX ||
m_path.back() == NODE_TYPE_RY || m_path.back() == NODE_TYPE_RY ||
#endif // ENABLE_MODELINSTANCE_3D_ROTATION
m_path.back() == NODE_TYPE_RZ || m_path.back() == NODE_TYPE_RZ ||
m_path.back() == NODE_TYPE_SCALEX ||
m_path.back() == NODE_TYPE_SCALEY ||
m_path.back() == NODE_TYPE_SCALEZ ||
m_path.back() == NODE_TYPE_SCALE) m_path.back() == NODE_TYPE_SCALE)
#else #else
if (m_path.back() == NODE_TYPE_DELTAX || m_path.back() == NODE_TYPE_DELTAY || m_path.back() == NODE_TYPE_RZ || m_path.back() == NODE_TYPE_SCALE) if (m_path.back() == NODE_TYPE_DELTAX || m_path.back() == NODE_TYPE_DELTAY || m_path.back() == NODE_TYPE_RZ || m_path.back() == NODE_TYPE_SCALE)
#endif // ENABLE_MODELINSTANCE_3D_OFFSET #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
m_value[0].append(s, len); m_value[0].append(s, len);
break; break;
case 6: case 6:
@ -411,15 +422,13 @@ void AMFParserContext::endElement(const char * /* name */)
m_instance->deltay_set = true; m_instance->deltay_set = true;
m_value[0].clear(); m_value[0].clear();
break; break;
#if ENABLE_MODELINSTANCE_3D_OFFSET #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
case NODE_TYPE_DELTAZ: case NODE_TYPE_DELTAZ:
assert(m_instance); assert(m_instance);
m_instance->deltaz = float(atof(m_value[0].c_str())); m_instance->deltaz = float(atof(m_value[0].c_str()));
m_instance->deltaz_set = true; m_instance->deltaz_set = true;
m_value[0].clear(); m_value[0].clear();
break; break;
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
#if ENABLE_MODELINSTANCE_3D_ROTATION
case NODE_TYPE_RX: case NODE_TYPE_RX:
assert(m_instance); assert(m_instance);
m_instance->rx = float(atof(m_value[0].c_str())); m_instance->rx = float(atof(m_value[0].c_str()));
@ -432,7 +441,7 @@ void AMFParserContext::endElement(const char * /* name */)
m_instance->ry_set = true; m_instance->ry_set = true;
m_value[0].clear(); m_value[0].clear();
break; break;
#endif // ENABLE_MODELINSTANCE_3D_ROTATION #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
case NODE_TYPE_RZ: case NODE_TYPE_RZ:
assert(m_instance); assert(m_instance);
m_instance->rz = float(atof(m_value[0].c_str())); m_instance->rz = float(atof(m_value[0].c_str()));
@ -441,10 +450,39 @@ void AMFParserContext::endElement(const char * /* name */)
break; break;
case NODE_TYPE_SCALE: case NODE_TYPE_SCALE:
assert(m_instance); assert(m_instance);
#if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
m_instance->scalex = float(atof(m_value[0].c_str()));
m_instance->scalex_set = true;
m_instance->scaley = float(atof(m_value[0].c_str()));
m_instance->scaley_set = true;
m_instance->scalez = float(atof(m_value[0].c_str()));
m_instance->scalez_set = true;
#else
m_instance->scale = float(atof(m_value[0].c_str())); m_instance->scale = float(atof(m_value[0].c_str()));
m_instance->scale_set = true; m_instance->scale_set = true;
#endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
m_value[0].clear(); m_value[0].clear();
break; break;
#if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
case NODE_TYPE_SCALEX:
assert(m_instance);
m_instance->scalex = float(atof(m_value[0].c_str()));
m_instance->scalex_set = true;
m_value[0].clear();
break;
case NODE_TYPE_SCALEY:
assert(m_instance);
m_instance->scaley = float(atof(m_value[0].c_str()));
m_instance->scaley_set = true;
m_value[0].clear();
break;
case NODE_TYPE_SCALEZ:
assert(m_instance);
m_instance->scalez = float(atof(m_value[0].c_str()));
m_instance->scalez_set = true;
m_value[0].clear();
break;
#endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
// Object vertices: // Object vertices:
case NODE_TYPE_VERTEX: case NODE_TYPE_VERTEX:
@ -581,18 +619,16 @@ void AMFParserContext::endDocument()
for (const Instance &instance : object.second.instances) for (const Instance &instance : object.second.instances)
if (instance.deltax_set && instance.deltay_set) { if (instance.deltax_set && instance.deltay_set) {
ModelInstance *mi = m_model.objects[object.second.idx]->add_instance(); ModelInstance *mi = m_model.objects[object.second.idx]->add_instance();
#if ENABLE_MODELINSTANCE_3D_OFFSET #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
mi->set_offset(Vec3d(instance.deltax_set ? (double)instance.deltax : 0.0, instance.deltay_set ? (double)instance.deltay : 0.0, instance.deltaz_set ? (double)instance.deltaz : 0.0)); mi->set_offset(Vec3d(instance.deltax_set ? (double)instance.deltax : 0.0, instance.deltay_set ? (double)instance.deltay : 0.0, instance.deltaz_set ? (double)instance.deltaz : 0.0));
mi->set_rotation(Vec3d(instance.rx_set ? (double)instance.rx : 0.0, instance.ry_set ? (double)instance.ry : 0.0, instance.rz_set ? (double)instance.rz : 0.0));
mi->set_scaling_factor(Vec3d(instance.scalex_set ? (double)instance.scalex : 1.0, instance.scaley_set ? (double)instance.scaley : 1.0, instance.scalez_set ? (double)instance.scalez : 1.0));
#else #else
mi->offset(0) = instance.deltax; mi->offset(0) = instance.deltax;
mi->offset(1) = instance.deltay; mi->offset(1) = instance.deltay;
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
#if ENABLE_MODELINSTANCE_3D_ROTATION
mi->set_rotation(Vec3d(instance.rx_set ? (double)instance.rx : 0.0, instance.ry_set ? (double)instance.ry : 0.0, instance.rz_set ? (double)instance.rz : 0.0));
#else
mi->rotation = instance.rz_set ? instance.rz : 0.f; mi->rotation = instance.rz_set ? instance.rz : 0.f;
#endif // ENABLE_MODELINSTANCE_3D_ROTATION
mi->scaling_factor = instance.scale_set ? instance.scale : 1.f; mi->scaling_factor = instance.scale_set ? instance.scale : 1.f;
#endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
} }
} }
} }
@ -892,33 +928,37 @@ bool store_amf(const char *path, Model *model, Print* print, bool export_print_c
" <instance objectid=\"" PRINTF_ZU "\">\n" " <instance objectid=\"" PRINTF_ZU "\">\n"
" <deltax>%lf</deltax>\n" " <deltax>%lf</deltax>\n"
" <deltay>%lf</deltay>\n" " <deltay>%lf</deltay>\n"
#if ENABLE_MODELINSTANCE_3D_OFFSET #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
" <deltaz>%lf</deltaz>\n" " <deltaz>%lf</deltaz>\n"
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
#if ENABLE_MODELINSTANCE_3D_ROTATION
" <rx>%lf</rx>\n" " <rx>%lf</rx>\n"
" <ry>%lf</ry>\n" " <ry>%lf</ry>\n"
#endif // ENABLE_MODELINSTANCE_3D_ROTATION #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
" <rz>%lf</rz>\n" " <rz>%lf</rz>\n"
#if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
" <scalex>%lf</scalex>\n"
" <scaley>%lf</scaley>\n"
" <scalez>%lf</scalez>\n"
#else
" <scale>%lf</scale>\n" " <scale>%lf</scale>\n"
#endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
" </instance>\n", " </instance>\n",
object_id, object_id,
#if ENABLE_MODELINSTANCE_3D_OFFSET #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
instance->get_offset(X), instance->get_offset(X),
instance->get_offset(Y), instance->get_offset(Y),
instance->get_offset(Z), instance->get_offset(Z),
#else
instance->offset(0),
instance->offset(1),
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
#if ENABLE_MODELINSTANCE_3D_ROTATION
instance->get_rotation(X), instance->get_rotation(X),
instance->get_rotation(Y), instance->get_rotation(Y),
instance->get_rotation(Z), instance->get_rotation(Z),
instance->get_scaling_factor(X),
instance->get_scaling_factor(Y),
instance->get_scaling_factor(Z));
#else #else
instance->offset(0),
instance->offset(1),
instance->rotation, instance->rotation,
#endif // ENABLE_MODELINSTANCE_3D_ROTATION
instance->scaling_factor); instance->scaling_factor);
#endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
//FIXME missing instance->scaling_factor //FIXME missing instance->scaling_factor
instances.append(buf); instances.append(buf);

41
src/libslic3r/Format/PRUS.cpp
View File

@ -97,17 +97,15 @@ static void extract_model_from_archive(
const char *zero_tag = "<zero>"; const char *zero_tag = "<zero>";
const char *zero_xml = strstr(scene_xml_data.data(), zero_tag); const char *zero_xml = strstr(scene_xml_data.data(), zero_tag);
float trafo[3][4] = { 0 }; float trafo[3][4] = { 0 };
#if ENABLE_MODELINSTANCE_3D_ROTATION #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
Vec3d instance_rotation = Vec3d::Zero(); Vec3d instance_rotation = Vec3d::Zero();
#else Vec3d instance_scaling_factor = Vec3d::Ones();
double instance_rotation = 0.;
#endif // ENABLE_MODELINSTANCE_3D_ROTATION
double instance_scaling_factor = 1.f;
#if ENABLE_MODELINSTANCE_3D_OFFSET
Vec3d instance_offset = Vec3d::Zero(); Vec3d instance_offset = Vec3d::Zero();
#else #else
double instance_rotation = 0.;
double instance_scaling_factor = 1.f;
Vec2d instance_offset(0., 0.); Vec2d instance_offset(0., 0.);
#endif // ENABLE_MODELINSTANCE_3D_OFFSET #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
bool trafo_set = false; bool trafo_set = false;
unsigned int group_id = (unsigned int)-1; unsigned int group_id = (unsigned int)-1;
unsigned int extruder_id = (unsigned int)-1; unsigned int extruder_id = (unsigned int)-1;
@ -130,18 +128,19 @@ static void extract_model_from_archive(
"[%f, %f, %f]", scale, scale+1, scale+2) == 3 && "[%f, %f, %f]", scale, scale+1, scale+2) == 3 &&
sscanf(zero_xml+strlen(zero_tag), sscanf(zero_xml+strlen(zero_tag),
"[%f, %f, %f]", zero, zero+1, zero+2) == 3) { "[%f, %f, %f]", zero, zero+1, zero+2) == 3) {
#if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
instance_scaling_factor = Vec3d((double)scale[0], (double)scale[1], (double)scale[2]);
instance_rotation = Vec3d(-(double)rotation[0], -(double)rotation[1], -(double)rotation[2]);
#else
if (scale[0] == scale[1] && scale[1] == scale[2]) { if (scale[0] == scale[1] && scale[1] == scale[2]) {
instance_scaling_factor = scale[0]; instance_scaling_factor = scale[0];
scale[0] = scale[1] = scale[2] = 1.; scale[0] = scale[1] = scale[2] = 1.;
} }
#if ENABLE_MODELINSTANCE_3D_ROTATION
instance_rotation = Vec3d(-(double)rotation[0], -(double)rotation[1], -(double)rotation[2]);
#else
if (rotation[0] == 0. && rotation[1] == 0.) { if (rotation[0] == 0. && rotation[1] == 0.) {
instance_rotation = - rotation[2]; instance_rotation = -rotation[2];
rotation[2] = 0.; rotation[2] = 0.;
} }
#endif // ENABLE_MODELINSTANCE_3D_ROTATION #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
Eigen::Matrix3f mat_rot, mat_scale, mat_trafo; Eigen::Matrix3f mat_rot, mat_scale, mat_trafo;
mat_rot = Eigen::AngleAxisf(-rotation[2], Eigen::Vector3f::UnitZ()) * mat_rot = Eigen::AngleAxisf(-rotation[2], Eigen::Vector3f::UnitZ()) *
Eigen::AngleAxisf(-rotation[1], Eigen::Vector3f::UnitY()) * Eigen::AngleAxisf(-rotation[1], Eigen::Vector3f::UnitY()) *
@ -152,13 +151,15 @@ static void extract_model_from_archive(
for (size_t c = 0; c < 3; ++ c) for (size_t c = 0; c < 3; ++ c)
trafo[r][c] += mat_trafo(r, c); trafo[r][c] += mat_trafo(r, c);
} }
#if ENABLE_MODELINSTANCE_3D_OFFSET #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
instance_offset = Vec3d((double)(position[0] - zero[0]), (double)(position[1] - zero[1]), (double)(position[2] - zero[2])); instance_offset = Vec3d((double)(position[0] - zero[0]), (double)(position[1] - zero[1]), (double)(position[2] - zero[2]));
// CHECK_ME -> Is the following correct ?
trafo[2][3] = position[2] / instance_scaling_factor(2);
#else #else
instance_offset(0) = position[0] - zero[0]; instance_offset(0) = position[0] - zero[0];
instance_offset(1) = position[1] - zero[1]; instance_offset(1) = position[1] - zero[1];
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
trafo[2][3] = position[2] / instance_scaling_factor; trafo[2][3] = position[2] / instance_scaling_factor;
#endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
trafo_set = true; trafo_set = true;
} }
const char *group_tag = "<group>"; const char *group_tag = "<group>";
@ -314,17 +315,15 @@ static void extract_model_from_archive(
model_object = model->add_object(name, path, std::move(mesh)); model_object = model->add_object(name, path, std::move(mesh));
volume = model_object->volumes.front(); volume = model_object->volumes.front();
ModelInstance *instance = model_object->add_instance(); ModelInstance *instance = model_object->add_instance();
#if ENABLE_MODELINSTANCE_3D_ROTATION #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
instance->set_rotation(instance_rotation); instance->set_rotation(instance_rotation);
#else instance->set_scaling_factor(instance_scaling_factor);
instance->rotation = instance_rotation;
#endif // ENABLE_MODELINSTANCE_3D_ROTATION
instance->scaling_factor = instance_scaling_factor;
#if ENABLE_MODELINSTANCE_3D_OFFSET
instance->set_offset(instance_offset); instance->set_offset(instance_offset);
#else #else
instance->rotation = instance_rotation;
instance->scaling_factor = instance_scaling_factor;
instance->offset = instance_offset; instance->offset = instance_offset;
#endif // ENABLE_MODELINSTANCE_3D_OFFSET #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
if (group_id != (size_t)-1) if (group_id != (size_t)-1)
group_to_model_object[group_id] = model_object; group_to_model_object[group_id] = model_object;
} else { } else {

83
src/libslic3r/Model.cpp
View File

@ -252,19 +252,19 @@ void Model::center_instances_around_point(const Vec2d &point)
for (size_t i = 0; i < o->instances.size(); ++ i) for (size_t i = 0; i < o->instances.size(); ++ i)
bb.merge(o->instance_bounding_box(i, false)); bb.merge(o->instance_bounding_box(i, false));
#if ENABLE_MODELINSTANCE_3D_OFFSET #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
Vec2d shift2 = point - to_2d(bb.center()); Vec2d shift2 = point - to_2d(bb.center());
Vec3d shift3 = Vec3d(shift2(0), shift2(1), 0.0); Vec3d shift3 = Vec3d(shift2(0), shift2(1), 0.0);
#else #else
Vec2d shift = point - 0.5 * to_2d(bb.size()) - to_2d(bb.min); Vec2d shift = point - 0.5 * to_2d(bb.size()) - to_2d(bb.min);
#endif // ENABLE_MODELINSTANCE_3D_OFFSET #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
for (ModelObject *o : this->objects) { for (ModelObject *o : this->objects) {
for (ModelInstance *i : o->instances) for (ModelInstance *i : o->instances)
#if ENABLE_MODELINSTANCE_3D_OFFSET #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
i->set_offset(i->get_offset() + shift3); i->set_offset(i->get_offset() + shift3);
#else #else
i->offset += shift; i->offset += shift;
#endif // ENABLE_MODELINSTANCE_3D_OFFSET #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
o->invalidate_bounding_box(); o->invalidate_bounding_box();
} }
} }
@ -330,12 +330,12 @@ bool Model::arrange_objects(coordf_t dist, const BoundingBoxf* bb)
size_t idx = 0; size_t idx = 0;
for (ModelObject *o : this->objects) { for (ModelObject *o : this->objects) {
for (ModelInstance *i : o->instances) { for (ModelInstance *i : o->instances) {
#if ENABLE_MODELINSTANCE_3D_OFFSET #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
Vec2d offset_xy = positions[idx] - instance_centers[idx]; Vec2d offset_xy = positions[idx] - instance_centers[idx];
i->set_offset(Vec3d(offset_xy(0), offset_xy(1), i->get_offset(Z))); i->set_offset(Vec3d(offset_xy(0), offset_xy(1), i->get_offset(Z)));
#else #else
i->offset = positions[idx] - instance_centers[idx]; i->offset = positions[idx] - instance_centers[idx];
#endif // ENABLE_MODELINSTANCE_3D_OFFSET #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
++idx; ++idx;
} }
o->invalidate_bounding_box(); o->invalidate_bounding_box();
@ -360,11 +360,11 @@ void Model::duplicate(size_t copies_num, coordf_t dist, const BoundingBoxf* bb)
for (const ModelInstance *i : instances) { for (const ModelInstance *i : instances) {
for (const Vec2d &pos : positions) { for (const Vec2d &pos : positions) {
ModelInstance *instance = o->add_instance(*i); ModelInstance *instance = o->add_instance(*i);
#if ENABLE_MODELINSTANCE_3D_OFFSET #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
instance->set_offset(instance->get_offset() + Vec3d(pos(0), pos(1), 0.0)); instance->set_offset(instance->get_offset() + Vec3d(pos(0), pos(1), 0.0));
#else #else
instance->offset += pos; instance->offset += pos;
#endif // ENABLE_MODELINSTANCE_3D_OFFSET #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
} }
} }
o->invalidate_bounding_box(); o->invalidate_bounding_box();
@ -394,21 +394,21 @@ void Model::duplicate_objects_grid(size_t x, size_t y, coordf_t dist)
ModelObject* object = this->objects.front(); ModelObject* object = this->objects.front();
object->clear_instances(); object->clear_instances();
#if ENABLE_MODELINSTANCE_3D_OFFSET #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
Vec3d ext_size = object->bounding_box().size() + dist * Vec3d::Ones(); Vec3d ext_size = object->bounding_box().size() + dist * Vec3d::Ones();
#else #else
Vec3d size = object->bounding_box().size(); Vec3d size = object->bounding_box().size();
#endif // ENABLE_MODELINSTANCE_3D_OFFSET #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
for (size_t x_copy = 1; x_copy <= x; ++x_copy) { for (size_t x_copy = 1; x_copy <= x; ++x_copy) {
for (size_t y_copy = 1; y_copy <= y; ++y_copy) { for (size_t y_copy = 1; y_copy <= y; ++y_copy) {
ModelInstance* instance = object->add_instance(); ModelInstance* instance = object->add_instance();
#if ENABLE_MODELINSTANCE_3D_OFFSET #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
instance->set_offset(Vec3d(ext_size(0) * (double)(x_copy - 1), ext_size(1) * (double)(y_copy - 1), 0.0)); instance->set_offset(Vec3d(ext_size(0) * (double)(x_copy - 1), ext_size(1) * (double)(y_copy - 1), 0.0));
#else #else
instance->offset(0) = (size(0) + dist) * (x_copy - 1); instance->offset(0) = (size(0) + dist) * (x_copy - 1);
instance->offset(1) = (size(1) + dist) * (y_copy - 1); instance->offset(1) = (size(1) + dist) * (y_copy - 1);
#endif // ENABLE_MODELINSTANCE_3D_OFFSET #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
} }
} }
} }
@ -714,21 +714,21 @@ void ModelObject::center_around_origin()
this->translate(shift); this->translate(shift);
this->origin_translation += shift; this->origin_translation += shift;
#if ENABLE_MODELINSTANCE_3D_OFFSET #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
// set z to zero, translation in z has already been done within the mesh // set z to zero, translation in z has already been done within the mesh
shift(2) = 0.0; shift(2) = 0.0;
#endif // ENABLE_MODELINSTANCE_3D_OFFSET #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
if (!this->instances.empty()) { if (!this->instances.empty()) {
for (ModelInstance *i : this->instances) { for (ModelInstance *i : this->instances) {
// apply rotation and scaling to vector as well before translating instance, // apply rotation and scaling to vector as well before translating instance,
// in order to leave final position unaltered // in order to leave final position unaltered
#if ENABLE_MODELINSTANCE_3D_OFFSET #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
i->set_offset(i->get_offset() + i->transform_vector(-shift, true)); i->set_offset(i->get_offset() + i->transform_vector(-shift, true));
#else #else
Vec3d i_shift = i->world_matrix(true) * shift; Vec3d i_shift = i->world_matrix(true) * shift;
i->offset -= to_2d(i_shift); i->offset -= to_2d(i_shift);
#endif // ENABLE_MODELINSTANCE_3D_OFFSET #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
} }
this->invalidate_bounding_box(); this->invalidate_bounding_box();
} }
@ -1070,7 +1070,7 @@ size_t ModelVolume::split(unsigned int max_extruders)
return idx; return idx;
} }
#if ENABLE_MODELINSTANCE_3D_ROTATION #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
void ModelInstance::set_rotation(const Vec3d& rotation) void ModelInstance::set_rotation(const Vec3d& rotation)
{ {
set_rotation(X, rotation(0)); set_rotation(X, rotation(0));
@ -1091,7 +1091,7 @@ void ModelInstance::set_rotation(Axis axis, double rotation)
} }
m_rotation(axis) = rotation; m_rotation(axis) = rotation;
} }
#endif // ENABLE_MODELINSTANCE_3D_ROTATION #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
void ModelInstance::transform_mesh(TriangleMesh* mesh, bool dont_translate) const void ModelInstance::transform_mesh(TriangleMesh* mesh, bool dont_translate) const
{ {
@ -1106,21 +1106,35 @@ BoundingBoxf3 ModelInstance::transform_mesh_bounding_box(const TriangleMesh* mes
BoundingBoxf3 bbox = copy.bounding_box(); BoundingBoxf3 bbox = copy.bounding_box();
if (!empty(bbox)) { if (!empty(bbox)) {
#if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
// Scale the bounding box along the three axes.
for (unsigned int i = 0; i < 3; ++i)
{
if (std::abs(this->m_scaling_factor(i) - 1.0) > EPSILON)
{
bbox.min(i) *= this->m_scaling_factor(i);
bbox.max(i) *= this->m_scaling_factor(i);
}
}
// Translate the bounding box.
if (! dont_translate) {
bbox.min += this->m_offset;
bbox.max += this->m_offset;
}
#else
// Scale the bounding box uniformly. // Scale the bounding box uniformly.
if (std::abs(this->scaling_factor - 1.) > EPSILON) { if (std::abs(this->scaling_factor - 1.) > EPSILON) {
bbox.min *= this->scaling_factor; bbox.min *= this->scaling_factor;
bbox.max *= this->scaling_factor; bbox.max *= this->scaling_factor;
} }
// Translate the bounding box. // Translate the bounding box.
if (! dont_translate) { if (!dont_translate) {
#if ENABLE_MODELINSTANCE_3D_OFFSET
bbox.min += this->m_offset;
bbox.max += this->m_offset;
#else
Eigen::Map<Vec2d>(bbox.min.data()) += this->offset; Eigen::Map<Vec2d>(bbox.min.data()) += this->offset;
Eigen::Map<Vec2d>(bbox.max.data()) += this->offset; Eigen::Map<Vec2d>(bbox.max.data()) += this->offset;
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
} }
#endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
} }
return bbox; return bbox;
} }
@ -1137,39 +1151,44 @@ Vec3d ModelInstance::transform_vector(const Vec3d& v, bool dont_translate) const
void ModelInstance::transform_polygon(Polygon* polygon) const void ModelInstance::transform_polygon(Polygon* polygon) const
{ {
#if ENABLE_MODELINSTANCE_3D_ROTATION #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
// CHECK_ME -> Is the following correct or it should take in account all three rotations ? // CHECK_ME -> Is the following correct or it should take in account all three rotations ?
polygon->rotate(this->m_rotation(2)); // rotate around polygon origin polygon->rotate(this->m_rotation(2)); // rotate around polygon origin
// CHECK_ME -> Is the following correct ?
polygon->scale(this->m_scaling_factor(0), this->m_scaling_factor(1)); // scale around polygon origin
#else #else
polygon->rotate(this->rotation); // rotate around polygon origin polygon->rotate(this->rotation); // rotate around polygon origin
#endif // ENABLE_MODELINSTANCE_3D_ROTATION
polygon->scale(this->scaling_factor); // scale around polygon origin polygon->scale(this->scaling_factor); // scale around polygon origin
#endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
} }
Transform3d ModelInstance::world_matrix(bool dont_translate, bool dont_rotate, bool dont_scale) const Transform3d ModelInstance::world_matrix(bool dont_translate, bool dont_rotate, bool dont_scale) const
{ {
Transform3d m = Transform3d::Identity(); Transform3d m = Transform3d::Identity();
#if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
if (!dont_translate) if (!dont_translate)
#if ENABLE_MODELINSTANCE_3D_OFFSET
m.translate(m_offset); m.translate(m_offset);
#else
m.translate(Vec3d(offset(0), offset(1), 0.0));
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
if (!dont_rotate) if (!dont_rotate)
#if ENABLE_MODELINSTANCE_3D_ROTATION
{ {
m.rotate(Eigen::AngleAxisd(m_rotation(2), Vec3d::UnitZ())); m.rotate(Eigen::AngleAxisd(m_rotation(2), Vec3d::UnitZ()));
m.rotate(Eigen::AngleAxisd(m_rotation(1), Vec3d::UnitY())); m.rotate(Eigen::AngleAxisd(m_rotation(1), Vec3d::UnitY()));
m.rotate(Eigen::AngleAxisd(m_rotation(0), Vec3d::UnitX())); m.rotate(Eigen::AngleAxisd(m_rotation(0), Vec3d::UnitX()));
} }
if (!dont_scale)
m.scale(m_scaling_factor);
#else #else
if (!dont_translate)
m.translate(Vec3d(offset(0), offset(1), 0.0));
if (!dont_rotate)
m.rotate(Eigen::AngleAxisd(rotation, Vec3d::UnitZ())); m.rotate(Eigen::AngleAxisd(rotation, Vec3d::UnitZ()));
#endif // ENABLE_MODELINSTANCE_3D_ROTATION
if (!dont_scale) if (!dont_scale)
m.scale(scaling_factor); m.scale(scaling_factor);
#endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
return m; return m;
} }

39
src/libslic3r/Model.hpp
View File

@ -245,44 +245,43 @@ public:
friend class ModelObject; friend class ModelObject;
#if ENABLE_MODELINSTANCE_3D_OFFSET #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
private: private:
Vec3d m_offset; // in unscaled coordinates Vec3d m_offset; // in unscaled coordinates
#if ENABLE_MODELINSTANCE_3D_ROTATION
Vec3d m_rotation; // Rotation around the three axes, in radians around mesh center point Vec3d m_rotation; // Rotation around the three axes, in radians around mesh center point
#endif // ENABLE_MODELINSTANCE_3D_ROTATION Vec3d m_scaling_factor; // Scaling factors along the three axes
public: public:
#endif // ENABLE_MODELINSTANCE_3D_OFFSET #else
#if !ENABLE_MODELINSTANCE_3D_ROTATION
double rotation; // Rotation around the Z axis, in radians around mesh center point double rotation; // Rotation around the Z axis, in radians around mesh center point
#endif // !ENABLE_MODELINSTANCE_3D_ROTATION
double scaling_factor; double scaling_factor;
#if !ENABLE_MODELINSTANCE_3D_OFFSET
Vec2d offset; // in unscaled coordinates Vec2d offset; // in unscaled coordinates
#endif // !ENABLE_MODELINSTANCE_3D_OFFSET #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
// flag showing the position of this instance with respect to the print volume (set by Print::validate() using ModelObject::check_instances_print_volume_state()) // flag showing the position of this instance with respect to the print volume (set by Print::validate() using ModelObject::check_instances_print_volume_state())
EPrintVolumeState print_volume_state; EPrintVolumeState print_volume_state;
ModelObject* get_object() const { return this->object; } ModelObject* get_object() const { return this->object; }
#if ENABLE_MODELINSTANCE_3D_OFFSET #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
const Vec3d& get_offset() const { return m_offset; } const Vec3d& get_offset() const { return m_offset; }
double get_offset(Axis axis) const { return m_offset(axis); } double get_offset(Axis axis) const { return m_offset(axis); }
void set_offset(const Vec3d& offset) { m_offset = offset; } void set_offset(const Vec3d& offset) { m_offset = offset; }
void set_offset(Axis axis, double offset) { m_offset(axis) = offset; } void set_offset(Axis axis, double offset) { m_offset(axis) = offset; }
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
#if ENABLE_MODELINSTANCE_3D_ROTATION
const Vec3d& get_rotation() const { return m_rotation; } const Vec3d& get_rotation() const { return m_rotation; }
double get_rotation(Axis axis) const { return m_rotation(axis); } double get_rotation(Axis axis) const { return m_rotation(axis); }
void set_rotation(const Vec3d& rotation); void set_rotation(const Vec3d& rotation);
void set_rotation(Axis axis, double rotation); void set_rotation(Axis axis, double rotation);
#endif // ENABLE_MODELINSTANCE_3D_ROTATION
Vec3d get_scaling_factor() const { return m_scaling_factor; }
double get_scaling_factor(Axis axis) const { return m_scaling_factor(axis); }
void set_scaling_factor(const Vec3d& scaling_factor) { m_scaling_factor = scaling_factor; }
void set_scaling_factor(Axis axis, double scaling_factor) { m_scaling_factor(axis) = scaling_factor; }
#endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
// To be called on an external mesh // To be called on an external mesh
void transform_mesh(TriangleMesh* mesh, bool dont_translate = false) const; void transform_mesh(TriangleMesh* mesh, bool dont_translate = false) const;
@ -303,21 +302,15 @@ private:
// Parent object, owning this instance. // Parent object, owning this instance.
ModelObject* object; ModelObject* object;
#if ENABLE_MODELINSTANCE_3D_OFFSET #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
#if ENABLE_MODELINSTANCE_3D_ROTATION ModelInstance(ModelObject *object) : m_rotation(Vec3d::Zero()), m_scaling_factor(Vec3d::Ones()), m_offset(Vec3d::Zero()), object(object), print_volume_state(PVS_Inside) {}
ModelInstance(ModelObject *object) : m_rotation(Vec3d::Zero()), scaling_factor(1), m_offset(Vec3d::Zero()), object(object), print_volume_state(PVS_Inside) {}
ModelInstance(ModelObject *object, const ModelInstance &other) : ModelInstance(ModelObject *object, const ModelInstance &other) :
m_rotation(other.m_rotation), scaling_factor(other.scaling_factor), m_offset(other.m_offset), object(object), print_volume_state(PVS_Inside) {} m_rotation(other.m_rotation), m_scaling_factor(other.m_scaling_factor), m_offset(other.m_offset), object(object), print_volume_state(PVS_Inside) {}
#else
ModelInstance(ModelObject *object) : rotation(0), scaling_factor(1), m_offset(Vec3d::Zero()), object(object), print_volume_state(PVS_Inside) {}
ModelInstance(ModelObject *object, const ModelInstance &other) :
rotation(other.rotation), scaling_factor(other.scaling_factor), m_offset(other.m_offset), object(object), print_volume_state(PVS_Inside) {}
#endif // ENABLE_MODELINSTANCE_3D_ROTATION
#else #else
ModelInstance(ModelObject *object) : rotation(0), scaling_factor(1), offset(Vec2d::Zero()), object(object), print_volume_state(PVS_Inside) {} ModelInstance(ModelObject *object) : rotation(0), scaling_factor(1), offset(Vec2d::Zero()), object(object), print_volume_state(PVS_Inside) {}
ModelInstance(ModelObject *object, const ModelInstance &other) : ModelInstance(ModelObject *object, const ModelInstance &other) :
rotation(other.rotation), scaling_factor(other.scaling_factor), offset(other.offset), object(object), print_volume_state(PVS_Inside) {} rotation(other.rotation), scaling_factor(other.scaling_factor), offset(other.offset), object(object), print_volume_state(PVS_Inside) {}
#endif // ENABLE_MODELINSTANCE_3D_OFFSET #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
}; };

41
src/libslic3r/ModelArrange.hpp
View File

@ -29,7 +29,12 @@ std::string toString(const Model& model, bool holes = true) {
if(!objinst) continue; if(!objinst) continue;
Slic3r::TriangleMesh tmpmesh = rmesh; Slic3r::TriangleMesh tmpmesh = rmesh;
#if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
// CHECK_ME -> Is the following correct ?
tmpmesh.scale(objinst->get_scaling_factor());
#else
tmpmesh.scale(objinst->scaling_factor); tmpmesh.scale(objinst->scaling_factor);
#endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
objinst->transform_mesh(&tmpmesh); objinst->transform_mesh(&tmpmesh);
ExPolygons expolys = tmpmesh.horizontal_projection(); ExPolygons expolys = tmpmesh.horizontal_projection();
for(auto& expoly_complex : expolys) { for(auto& expoly_complex : expolys) {
@ -87,7 +92,11 @@ void toSVG(SVG& svg, const Model& model) {
if(!objinst) continue; if(!objinst) continue;
Slic3r::TriangleMesh tmpmesh = rmesh; Slic3r::TriangleMesh tmpmesh = rmesh;
#if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
tmpmesh.scale(objinst->get_scaling_factor());
#else
tmpmesh.scale(objinst->scaling_factor); tmpmesh.scale(objinst->scaling_factor);
#endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
objinst->transform_mesh(&tmpmesh); objinst->transform_mesh(&tmpmesh);
ExPolygons expolys = tmpmesh.horizontal_projection(); ExPolygons expolys = tmpmesh.horizontal_projection();
svg.draw(expolys); svg.draw(expolys);
@ -513,7 +522,12 @@ ShapeData2D projectModelFromTop(const Slic3r::Model &model) {
Slic3r::TriangleMesh tmpmesh = rmesh; Slic3r::TriangleMesh tmpmesh = rmesh;
ClipperLib::PolygonImpl pn; ClipperLib::PolygonImpl pn;
#if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
// CHECK_ME -> is the following correct ?
tmpmesh.scale(objinst->get_scaling_factor());
#else
tmpmesh.scale(objinst->scaling_factor); tmpmesh.scale(objinst->scaling_factor);
#endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
// TODO export the exact 2D projection // TODO export the exact 2D projection
auto p = tmpmesh.convex_hull(); auto p = tmpmesh.convex_hull();
@ -527,20 +541,20 @@ ShapeData2D projectModelFromTop(const Slic3r::Model &model) {
// Invalid geometries would throw exceptions when arranging // Invalid geometries would throw exceptions when arranging
if(item.vertexCount() > 3) { if(item.vertexCount() > 3) {
#if ENABLE_MODELINSTANCE_3D_ROTATION #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
// CHECK_ME -> is the following correct or it should take in account all three rotations ? // CHECK_ME -> is the following correct or it should take in account all three rotations ?
item.rotation(objinst->get_rotation(Z)); item.rotation(objinst->get_rotation(Z));
#else #else
item.rotation(objinst->rotation); item.rotation(objinst->rotation);
#endif // ENABLE_MODELINSTANCE_3D_ROTATION #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
item.translation({ item.translation({
#if ENABLE_MODELINSTANCE_3D_OFFSET #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
ClipperLib::cInt(objinst->get_offset(X)/SCALING_FACTOR), ClipperLib::cInt(objinst->get_offset(X)/SCALING_FACTOR),
ClipperLib::cInt(objinst->get_offset(Y)/SCALING_FACTOR) ClipperLib::cInt(objinst->get_offset(Y)/SCALING_FACTOR)
#else #else
ClipperLib::cInt(objinst->offset(0)/SCALING_FACTOR), ClipperLib::cInt(objinst->offset(0)/SCALING_FACTOR),
ClipperLib::cInt(objinst->offset(1)/SCALING_FACTOR) ClipperLib::cInt(objinst->offset(1)/SCALING_FACTOR)
#endif // ENABLE_MODELINSTANCE_3D_OFFSET #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
}); });
ret.emplace_back(objinst, item); ret.emplace_back(objinst, item);
} }
@ -677,26 +691,21 @@ void applyResult(
// appropriately // appropriately
auto off = item.translation(); auto off = item.translation();
Radians rot = item.rotation(); Radians rot = item.rotation();
#if ENABLE_MODELINSTANCE_3D_OFFSET #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
Vec3d foff(off.X*SCALING_FACTOR + batch_offset, Vec3d foff(off.X*SCALING_FACTOR + batch_offset,
off.Y*SCALING_FACTOR, off.Y*SCALING_FACTOR,
0.0); 0.0);
#else
Vec2d foff(off.X*SCALING_FACTOR + batch_offset, off.Y*SCALING_FACTOR);
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
// write the transformation data into the model instance // write the transformation data into the model instance
#if ENABLE_MODELINSTANCE_3D_ROTATION inst_ptr->set_rotation(Z, rot);
// CHECK_ME -> Is the following correct ?
inst_ptr->set_rotation(Vec3d(0.0, 0.0, rot));
#else
inst_ptr->rotation = rot;
#endif // ENABLE_MODELINSTANCE_3D_ROTATION
#if ENABLE_MODELINSTANCE_3D_OFFSET
inst_ptr->set_offset(foff); inst_ptr->set_offset(foff);
#else #else
Vec2d foff(off.X*SCALING_FACTOR + batch_offset, off.Y*SCALING_FACTOR);
// write the transformation data into the model instance
inst_ptr->rotation = rot;
inst_ptr->offset = foff; inst_ptr->offset = foff;
#endif // ENABLE_MODELINSTANCE_3D_OFFSET #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
} }
} }

11
src/libslic3r/MultiPoint.cpp
View File

@ -14,6 +14,17 @@ void MultiPoint::scale(double factor)
pt *= factor; pt *= factor;
} }
#if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
void MultiPoint::scale(double factor_x, double factor_y)
{
for (Point &pt : points)
{
pt(0) *= factor_x;
pt(1) *= factor_y;
}
}
#endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
void MultiPoint::translate(double x, double y) void MultiPoint::translate(double x, double y)
{ {
Vector v(x, y); Vector v(x, y);

3
src/libslic3r/MultiPoint.hpp
View File

@ -26,6 +26,9 @@ public:
MultiPoint& operator=(const MultiPoint &other) { points = other.points; return *this; } MultiPoint& operator=(const MultiPoint &other) { points = other.points; return *this; }
MultiPoint& operator=(MultiPoint &&other) { points = std::move(other.points); return *this; } MultiPoint& operator=(MultiPoint &&other) { points = std::move(other.points); return *this; }
void scale(double factor); void scale(double factor);
#if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
void scale(double factor_x, double factor_y);
#endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
void translate(double x, double y); void translate(double x, double y);
void translate(const Point &vector); void translate(const Point &vector);
void rotate(double angle) { this->rotate(cos(angle), sin(angle)); } void rotate(double angle) { this->rotate(cos(angle), sin(angle)); }

9
src/libslic3r/Print.cpp
View File

@ -431,7 +431,14 @@ void Print::add_model_object(ModelObject* model_object, int idx)
std::vector<std::string> v_scale; std::vector<std::string> v_scale;
for (const PrintObject *object : m_objects) { for (const PrintObject *object : m_objects) {
const ModelObject &mobj = *object->model_object(); const ModelObject &mobj = *object->model_object();
v_scale.push_back(boost::lexical_cast<std::string>(mobj.instances[0]->scaling_factor*100) + "%"); #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
// CHECK_ME -> Is the following correct ?
v_scale.push_back("x:" + boost::lexical_cast<std::string>(mobj.instances[0]->get_scaling_factor(X) * 100) +
"% y:" + boost::lexical_cast<std::string>(mobj.instances[0]->get_scaling_factor(Y) * 100) +
"% z:" + boost::lexical_cast<std::string>(mobj.instances[0]->get_scaling_factor(Z) * 100) + "%");
#else
v_scale.push_back(boost::lexical_cast<std::string>(mobj.instances[0]->scaling_factor * 100) + "%");
#endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
if (input_file.empty()) if (input_file.empty())
input_file = mobj.input_file; input_file = mobj.input_file;
} }

4
src/libslic3r/PrintObject.cpp
View File

@ -113,7 +113,7 @@ bool PrintObject::reload_model_instances()
copies.reserve(m_model_object->instances.size()); copies.reserve(m_model_object->instances.size());
for (const ModelInstance *mi : m_model_object->instances) for (const ModelInstance *mi : m_model_object->instances)
{ {
#if ENABLE_MODELINSTANCE_3D_OFFSET #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
if (mi->is_printable()) if (mi->is_printable())
{ {
const Vec3d& offset = mi->get_offset(); const Vec3d& offset = mi->get_offset();
@ -122,7 +122,7 @@ bool PrintObject::reload_model_instances()
#else #else
if (mi->is_printable()) if (mi->is_printable())
copies.emplace_back(Point::new_scale(mi->offset(0), mi->offset(1))); copies.emplace_back(Point::new_scale(mi->offset(0), mi->offset(1)));
#endif // ENABLE_MODELINSTANCE_3D_OFFSET #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
} }
return this->set_copies(copies); return this->set_copies(copies);
} }

6
src/libslic3r/Technologies.hpp
View File

@ -5,11 +5,11 @@
#define ENABLE_1_42_0 1 #define ENABLE_1_42_0 1
// Add z coordinate to model instances' offset // Add z coordinate to model instances' offset
#define ENABLE_MODELINSTANCE_3D_OFFSET (1 && ENABLE_1_42_0) // Add x and y rotation components to model instances' offset
// Add scaling factors for all the three axes to model instances
#define ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM (1 && ENABLE_1_42_0)
// Add double click on gizmo grabbers to reset transformation components to their default value // Add double click on gizmo grabbers to reset transformation components to their default value
#define ENABLE_GIZMOS_RESET (1 && ENABLE_1_42_0) #define ENABLE_GIZMOS_RESET (1 && ENABLE_1_42_0)
// Add x and y rotation components to model instances' offset
#define ENABLE_MODELINSTANCE_3D_ROTATION (1 && ENABLE_MODELINSTANCE_3D_OFFSET)
#endif // _technologies_h_ #endif // _technologies_h_

14
src/libslic3r/Utils.hpp
View File

@ -74,6 +74,20 @@ inline std::string header_slic3r_generated() { return std::string("generated by
// getpid platform wrapper // getpid platform wrapper
extern unsigned get_current_pid(); extern unsigned get_current_pid();
template <typename Real>
Real round_nearest(Real value, unsigned int decimals)
{
Real res = (Real)0;
if (decimals == 0)
res = ::round(value);
else
{
Real power = ::pow((Real)10, (int)decimals);
res = ::round(value * power + (Real)0.5) / power;
}
return res;
}
// Compute the next highest power of 2 of 32-bit v // Compute the next highest power of 2 of 32-bit v
// http://graphics.stanford.edu/~seander/bithacks.html // http://graphics.stanford.edu/~seander/bithacks.html
inline uint16_t next_highest_power_of_2(uint16_t v) inline uint16_t next_highest_power_of_2(uint16_t v)

104
src/slic3r/GUI/3DScene.cpp
View File

@ -196,12 +196,13 @@ const float GLVolume::SELECTED_OUTSIDE_COLOR[4] = { 0.19f, 0.58f, 1.0f, 1.0f };
GLVolume::GLVolume(float r, float g, float b, float a) GLVolume::GLVolume(float r, float g, float b, float a)
: m_offset(Vec3d::Zero()) : m_offset(Vec3d::Zero())
#if ENABLE_MODELINSTANCE_3D_ROTATION #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
, m_rotation(Vec3d::Zero()) , m_rotation(Vec3d::Zero())
, m_scaling_factor(Vec3d::Ones())
#else #else
, m_rotation(0.0) , m_rotation(0.0)
#endif // ENABLE_MODELINSTANCE_3D_ROTATION
, m_scaling_factor(1.0) , m_scaling_factor(1.0)
#endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
, m_world_matrix(Transform3f::Identity()) , m_world_matrix(Transform3f::Identity())
, m_world_matrix_dirty(true) , m_world_matrix_dirty(true)
, m_transformed_bounding_box_dirty(true) , m_transformed_bounding_box_dirty(true)
@ -259,7 +260,7 @@ void GLVolume::set_render_color()
set_render_color(color, 4); set_render_color(color, 4);
} }
#if ENABLE_MODELINSTANCE_3D_ROTATION #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
const Vec3d& GLVolume::get_rotation() const const Vec3d& GLVolume::get_rotation() const
{ {
return m_rotation; return m_rotation;
@ -291,7 +292,7 @@ void GLVolume::set_rotation(double rotation)
m_transformed_convex_hull_bounding_box_dirty = true; m_transformed_convex_hull_bounding_box_dirty = true;
} }
} }
#endif // ENABLE_MODELINSTANCE_3D_ROTATION #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
const Vec3d& GLVolume::get_offset() const const Vec3d& GLVolume::get_offset() const
{ {
@ -309,6 +310,18 @@ void GLVolume::set_offset(const Vec3d& offset)
} }
} }
#if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
void GLVolume::set_scaling_factor(const Vec3d& scaling_factor)
{
if (m_scaling_factor != scaling_factor)
{
m_scaling_factor = scaling_factor;
m_world_matrix_dirty = true;
m_transformed_bounding_box_dirty = true;
m_transformed_convex_hull_bounding_box_dirty = true;
}
}
#else
void GLVolume::set_scaling_factor(double factor) void GLVolume::set_scaling_factor(double factor)
{ {
if (m_scaling_factor != factor) if (m_scaling_factor != factor)
@ -319,6 +332,7 @@ void GLVolume::set_scaling_factor(double factor)
m_transformed_convex_hull_bounding_box_dirty = true; m_transformed_convex_hull_bounding_box_dirty = true;
} }
} }
#endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
void GLVolume::set_convex_hull(const TriangleMesh& convex_hull) void GLVolume::set_convex_hull(const TriangleMesh& convex_hull)
{ {
@ -349,14 +363,15 @@ const Transform3f& GLVolume::world_matrix() const
{ {
m_world_matrix = Transform3f::Identity(); m_world_matrix = Transform3f::Identity();
m_world_matrix.translate(m_offset.cast<float>()); m_world_matrix.translate(m_offset.cast<float>());
#if ENABLE_MODELINSTANCE_3D_ROTATION #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
m_world_matrix.rotate(Eigen::AngleAxisf((float)m_rotation(2), Vec3f::UnitZ())); m_world_matrix.rotate(Eigen::AngleAxisf((float)m_rotation(2), Vec3f::UnitZ()));
m_world_matrix.rotate(Eigen::AngleAxisf((float)m_rotation(1), Vec3f::UnitY())); m_world_matrix.rotate(Eigen::AngleAxisf((float)m_rotation(1), Vec3f::UnitY()));
m_world_matrix.rotate(Eigen::AngleAxisf((float)m_rotation(0), Vec3f::UnitX())); m_world_matrix.rotate(Eigen::AngleAxisf((float)m_rotation(0), Vec3f::UnitX()));
m_world_matrix.scale(m_scaling_factor.cast<float>());
#else #else
m_world_matrix.rotate(Eigen::AngleAxisf((float)m_rotation, Vec3f::UnitZ())); m_world_matrix.rotate(Eigen::AngleAxisf((float)m_rotation, Vec3f::UnitZ()));
#endif // ENABLE_MODELINSTANCE_3D_ROTATION
m_world_matrix.scale((float)m_scaling_factor); m_world_matrix.scale((float)m_scaling_factor);
#endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
m_world_matrix_dirty = false; m_world_matrix_dirty = false;
} }
return m_world_matrix; return m_world_matrix;
@ -430,15 +445,14 @@ void GLVolume::render() const
::glCullFace(GL_BACK); ::glCullFace(GL_BACK);
::glPushMatrix(); ::glPushMatrix();
::glTranslated(m_offset(0), m_offset(1), m_offset(2));
#if ENABLE_MODELINSTANCE_3D_ROTATION #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
::glRotated(m_rotation(2) * 180.0 / (double)PI, 0.0, 0.0, 1.0); ::glMultMatrixf(world_matrix().data());
::glRotated(m_rotation(1) * 180.0 / (double)PI, 0.0, 1.0, 0.0);
::glRotated(m_rotation(0) * 180.0 / (double)PI, 1.0, 0.0, 0.0);
#else #else
::glTranslated(m_offset(0), m_offset(1), m_offset(2));
::glRotated(m_rotation * 180.0 / (double)PI, 0.0, 0.0, 1.0); ::glRotated(m_rotation * 180.0 / (double)PI, 0.0, 0.0, 1.0);
#endif // ENABLE_MODELINSTANCE_3D_ROTATION
::glScaled(m_scaling_factor, m_scaling_factor, m_scaling_factor); ::glScaled(m_scaling_factor, m_scaling_factor, m_scaling_factor);
#endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
if (this->indexed_vertex_array.indexed()) if (this->indexed_vertex_array.indexed())
this->indexed_vertex_array.render(this->tverts_range, this->qverts_range); this->indexed_vertex_array.render(this->tverts_range, this->qverts_range);
else else
@ -562,15 +576,14 @@ void GLVolume::render_VBOs(int color_id, int detection_id, int worldmatrix_id) c
::glNormalPointer(GL_FLOAT, 6 * sizeof(float), nullptr); ::glNormalPointer(GL_FLOAT, 6 * sizeof(float), nullptr);
::glPushMatrix(); ::glPushMatrix();
::glTranslated(m_offset(0), m_offset(1), m_offset(2));
#if ENABLE_MODELINSTANCE_3D_ROTATION #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
::glRotated(m_rotation(2) * 180.0 / (double)PI, 0.0, 0.0, 1.0); ::glMultMatrixf(world_matrix().data());
::glRotated(m_rotation(1) * 180.0 / (double)PI, 0.0, 1.0, 0.0);
::glRotated(m_rotation(0) * 180.0 / (double)PI, 1.0, 0.0, 0.0);
#else #else
::glTranslated(m_offset(0), m_offset(1), m_offset(2));
::glRotated(m_rotation * 180.0 / (double)PI, 0.0, 0.0, 1.0); ::glRotated(m_rotation * 180.0 / (double)PI, 0.0, 0.0, 1.0);
#endif // ENABLE_MODELINSTANCE_3D_ROTATION
::glScaled(m_scaling_factor, m_scaling_factor, m_scaling_factor); ::glScaled(m_scaling_factor, m_scaling_factor, m_scaling_factor);
#endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
if (n_triangles > 0) if (n_triangles > 0)
{ {
@ -613,15 +626,14 @@ void GLVolume::render_legacy() const
::glNormalPointer(GL_FLOAT, 6 * sizeof(float), indexed_vertex_array.vertices_and_normals_interleaved.data()); ::glNormalPointer(GL_FLOAT, 6 * sizeof(float), indexed_vertex_array.vertices_and_normals_interleaved.data());
::glPushMatrix(); ::glPushMatrix();
::glTranslated(m_offset(0), m_offset(1), m_offset(2));
#if ENABLE_MODELINSTANCE_3D_ROTATION #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
::glRotated(m_rotation(2) * 180.0 / (double)PI, 0.0, 0.0, 1.0); ::glMultMatrixf(world_matrix().data());
::glRotated(m_rotation(1) * 180.0 / (double)PI, 0.0, 1.0, 0.0);
::glRotated(m_rotation(0) * 180.0 / (double)PI, 1.0, 0.0, 0.0);
#else #else
::glTranslated(m_offset(0), m_offset(1), m_offset(2));
::glRotated(m_rotation * 180.0 / (double)PI, 0.0, 0.0, 1.0); ::glRotated(m_rotation * 180.0 / (double)PI, 0.0, 0.0, 1.0);
#endif // ENABLE_MODELINSTANCE_3D_ROTATION
::glScaled(m_scaling_factor, m_scaling_factor, m_scaling_factor); ::glScaled(m_scaling_factor, m_scaling_factor, m_scaling_factor);
#endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
if (n_triangles > 0) if (n_triangles > 0)
::glDrawElements(GL_TRIANGLES, n_triangles, GL_UNSIGNED_INT, indexed_vertex_array.triangle_indices.data() + tverts_range.first); ::glDrawElements(GL_TRIANGLES, n_triangles, GL_UNSIGNED_INT, indexed_vertex_array.triangle_indices.data() + tverts_range.first);
@ -739,17 +751,15 @@ std::vector<int> GLVolumeCollection::load_object(
} }
v.is_modifier = ! model_volume->is_model_part(); v.is_modifier = ! model_volume->is_model_part();
v.shader_outside_printer_detection_enabled = model_volume->is_model_part(); v.shader_outside_printer_detection_enabled = model_volume->is_model_part();
#if ENABLE_MODELINSTANCE_3D_OFFSET #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
v.set_offset(instance->get_offset()); v.set_offset(instance->get_offset());
v.set_rotation(instance->get_rotation());
v.set_scaling_factor(instance->get_scaling_factor());
#else #else
v.set_offset(Vec3d(instance->offset(0), instance->offset(1), 0.0)); v.set_offset(Vec3d(instance->offset(0), instance->offset(1), 0.0));
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
#if ENABLE_MODELINSTANCE_3D_ROTATION
v.set_rotation(instance->get_rotation());
#else
v.set_rotation(instance->rotation); v.set_rotation(instance->rotation);
#endif // ENABLE_MODELINSTANCE_3D_ROTATION
v.set_scaling_factor(instance->scaling_factor); v.set_scaling_factor(instance->scaling_factor);
#endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
} }
} }
@ -2112,40 +2122,58 @@ void _3DScene::register_on_enable_action_buttons_callback(wxGLCanvas* canvas, vo
void _3DScene::register_on_gizmo_scale_uniformly_callback(wxGLCanvas* canvas, void* callback) void _3DScene::register_on_gizmo_scale_uniformly_callback(wxGLCanvas* canvas, void* callback)
{ {
#if !ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
s_canvas_mgr.register_on_gizmo_scale_uniformly_callback(canvas, callback); s_canvas_mgr.register_on_gizmo_scale_uniformly_callback(canvas, callback);
#endif // !ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
}
void _3DScene::register_on_gizmo_scale_3D_callback(wxGLCanvas* canvas, void* callback)
{
#if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
s_canvas_mgr.register_on_gizmo_scale_3D_callback(canvas, callback);
#endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
} }
void _3DScene::register_on_gizmo_rotate_callback(wxGLCanvas* canvas, void* callback) void _3DScene::register_on_gizmo_rotate_callback(wxGLCanvas* canvas, void* callback)
{ {
#if !ENABLE_MODELINSTANCE_3D_ROTATION #if !ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
s_canvas_mgr.register_on_gizmo_rotate_callback(canvas, callback); s_canvas_mgr.register_on_gizmo_rotate_callback(canvas, callback);
#endif // !ENABLE_MODELINSTANCE_3D_ROTATION #endif // !ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
} }
void _3DScene::register_on_gizmo_rotate_3D_callback(wxGLCanvas* canvas, void* callback) void _3DScene::register_on_gizmo_rotate_3D_callback(wxGLCanvas* canvas, void* callback)
{ {
#if ENABLE_MODELINSTANCE_3D_ROTATION #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
s_canvas_mgr.register_on_gizmo_rotate_3D_callback(canvas, callback); s_canvas_mgr.register_on_gizmo_rotate_3D_callback(canvas, callback);
#endif // ENABLE_MODELINSTANCE_3D_ROTATION #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
} }
void _3DScene::register_on_gizmo_flatten_callback(wxGLCanvas* canvas, void* callback) void _3DScene::register_on_gizmo_flatten_callback(wxGLCanvas* canvas, void* callback)
{ {
#if !ENABLE_MODELINSTANCE_3D_ROTATION #if !ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
s_canvas_mgr.register_on_gizmo_flatten_callback(canvas, callback); s_canvas_mgr.register_on_gizmo_flatten_callback(canvas, callback);
#endif // !ENABLE_MODELINSTANCE_3D_ROTATION #endif // !ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
} }
void _3DScene::register_on_gizmo_flatten_3D_callback(wxGLCanvas* canvas, void* callback) void _3DScene::register_on_gizmo_flatten_3D_callback(wxGLCanvas* canvas, void* callback)
{ {
#if ENABLE_MODELINSTANCE_3D_ROTATION #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
s_canvas_mgr.register_on_gizmo_flatten_3D_callback(canvas, callback); s_canvas_mgr.register_on_gizmo_flatten_3D_callback(canvas, callback);
#endif // ENABLE_MODELINSTANCE_3D_ROTATION #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
} }
void _3DScene::register_on_update_geometry_info_callback(wxGLCanvas* canvas, void* callback) void _3DScene::register_on_update_geometry_info_callback(wxGLCanvas* canvas, void* callback)
{ {
#if !ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
s_canvas_mgr.register_on_update_geometry_info_callback(canvas, callback); s_canvas_mgr.register_on_update_geometry_info_callback(canvas, callback);
#endif // !ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
}
void _3DScene::register_on_update_geometry_3D_info_callback(wxGLCanvas* canvas, void* callback)
{
#if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
s_canvas_mgr.register_on_update_geometry_3D_info_callback(canvas, callback);
#endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
} }
void _3DScene::register_action_add_callback(wxGLCanvas* canvas, void* callback) void _3DScene::register_action_add_callback(wxGLCanvas* canvas, void* callback)

18
src/slic3r/GUI/3DScene.hpp
View File

@ -256,15 +256,17 @@ public:
private: private:
// Offset of the volume to be rendered. // Offset of the volume to be rendered.
Vec3d m_offset; Vec3d m_offset;
#if ENABLE_MODELINSTANCE_3D_ROTATION #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
// Rotation around three axes of the volume to be rendered. // Rotation around three axes of the volume to be rendered.
Vec3d m_rotation; Vec3d m_rotation;
// Scale factor along the three axes of the volume to be rendered.
Vec3d m_scaling_factor;
#else #else
// Rotation around Z axis of the volume to be rendered. // Rotation around Z axis of the volume to be rendered.
double m_rotation; double m_rotation;
#endif // ENABLE_MODELINSTANCE_3D_ROTATION
// Scale factor of the volume to be rendered. // Scale factor of the volume to be rendered.
double m_scaling_factor; double m_scaling_factor;
#endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
// World matrix of the volume to be rendered. // World matrix of the volume to be rendered.
mutable Transform3f m_world_matrix; mutable Transform3f m_world_matrix;
// Whether or not is needed to recalculate the world matrix. // Whether or not is needed to recalculate the world matrix.
@ -332,19 +334,21 @@ public:
// Sets render color in dependence of current state // Sets render color in dependence of current state
void set_render_color(); void set_render_color();
#if ENABLE_MODELINSTANCE_3D_ROTATION #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
const Vec3d& get_rotation() const; const Vec3d& get_rotation() const;
void set_rotation(const Vec3d& rotation); void set_rotation(const Vec3d& rotation);
void set_scaling_factor(const Vec3d& scaling_factor);
#else #else
double get_rotation() const; double get_rotation() const;
void set_rotation(double rotation); void set_rotation(double rotation);
#endif // ENABLE_MODELINSTANCE_3D_ROTATION
void set_scaling_factor(double factor);
#endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
const Vec3d& get_offset() const; const Vec3d& get_offset() const;
void set_offset(const Vec3d& offset); void set_offset(const Vec3d& offset);
void set_scaling_factor(double factor);
void set_convex_hull(const TriangleMesh& convex_hull); void set_convex_hull(const TriangleMesh& convex_hull);
void set_select_group_id(const std::string& select_by); void set_select_group_id(const std::string& select_by);
@ -567,11 +571,13 @@ public:
static void register_on_wipe_tower_moved_callback(wxGLCanvas* canvas, void* callback); static void register_on_wipe_tower_moved_callback(wxGLCanvas* canvas, void* callback);
static void register_on_enable_action_buttons_callback(wxGLCanvas* canvas, void* callback); static void register_on_enable_action_buttons_callback(wxGLCanvas* canvas, void* callback);
static void register_on_gizmo_scale_uniformly_callback(wxGLCanvas* canvas, void* callback); static void register_on_gizmo_scale_uniformly_callback(wxGLCanvas* canvas, void* callback);
static void register_on_gizmo_scale_3D_callback(wxGLCanvas* canvas, void* callback);
static void register_on_gizmo_rotate_callback(wxGLCanvas* canvas, void* callback); static void register_on_gizmo_rotate_callback(wxGLCanvas* canvas, void* callback);
static void register_on_gizmo_rotate_3D_callback(wxGLCanvas* canvas, void* callback); static void register_on_gizmo_rotate_3D_callback(wxGLCanvas* canvas, void* callback);
static void register_on_gizmo_flatten_callback(wxGLCanvas* canvas, void* callback); static void register_on_gizmo_flatten_callback(wxGLCanvas* canvas, void* callback);
static void register_on_gizmo_flatten_3D_callback(wxGLCanvas* canvas, void* callback); static void register_on_gizmo_flatten_3D_callback(wxGLCanvas* canvas, void* callback);
static void register_on_update_geometry_info_callback(wxGLCanvas* canvas, void* callback); static void register_on_update_geometry_info_callback(wxGLCanvas* canvas, void* callback);
static void register_on_update_geometry_3D_info_callback(wxGLCanvas* canvas, void* callback);
static void register_action_add_callback(wxGLCanvas* canvas, void* callback); static void register_action_add_callback(wxGLCanvas* canvas, void* callback);
static void register_action_delete_callback(wxGLCanvas* canvas, void* callback); static void register_action_delete_callback(wxGLCanvas* canvas, void* callback);

137
src/slic3r/GUI/GLCanvas3D.cpp
View File

@ -1145,10 +1145,10 @@ bool GLCanvas3D::Gizmos::init(GLCanvas3D& parent)
if (!gizmo->init()) if (!gizmo->init())
return false; return false;
#if !ENABLE_MODELINSTANCE_3D_OFFSET #if !ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
// temporary disable z grabber // temporary disable z grabber
gizmo->disable_grabber(2); gizmo->disable_grabber(2);
#endif // !ENABLE_MODELINSTANCE_3D_OFFSET #endif // !ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
m_gizmos.insert(GizmosMap::value_type(Move, gizmo)); m_gizmos.insert(GizmosMap::value_type(Move, gizmo));
@ -1159,6 +1159,7 @@ bool GLCanvas3D::Gizmos::init(GLCanvas3D& parent)
if (!gizmo->init()) if (!gizmo->init())
return false; return false;
#if !ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
// temporary disable x grabbers // temporary disable x grabbers
gizmo->disable_grabber(0); gizmo->disable_grabber(0);
gizmo->disable_grabber(1); gizmo->disable_grabber(1);
@ -1168,6 +1169,7 @@ bool GLCanvas3D::Gizmos::init(GLCanvas3D& parent)
// temporary disable z grabbers // temporary disable z grabbers
gizmo->disable_grabber(4); gizmo->disable_grabber(4);
gizmo->disable_grabber(5); gizmo->disable_grabber(5);
#endif // !ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
m_gizmos.insert(GizmosMap::value_type(Scale, gizmo)); m_gizmos.insert(GizmosMap::value_type(Scale, gizmo));
@ -1184,11 +1186,11 @@ bool GLCanvas3D::Gizmos::init(GLCanvas3D& parent)
return false; return false;
} }
#if !ENABLE_MODELINSTANCE_3D_ROTATION #if !ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
// temporary disable x and y grabbers // temporary disable x and y grabbers
gizmo->disable_grabber(0); gizmo->disable_grabber(0);
gizmo->disable_grabber(1); gizmo->disable_grabber(1);
#endif // !ENABLE_MODELINSTANCE_3D_ROTATION #endif // !ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
m_gizmos.insert(GizmosMap::value_type(Rotate, gizmo)); m_gizmos.insert(GizmosMap::value_type(Rotate, gizmo));
@ -1419,16 +1421,17 @@ void GLCanvas3D::Gizmos::set_position(const Vec3d& position)
reinterpret_cast<GLGizmoMove3D*>(it->second)->set_position(position); reinterpret_cast<GLGizmoMove3D*>(it->second)->set_position(position);
} }
float GLCanvas3D::Gizmos::get_scale() const #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
Vec3d GLCanvas3D::Gizmos::get_scale() const
{ {
if (!m_enabled) if (!m_enabled)
return 1.0f; return Vec3d::Ones();
GizmosMap::const_iterator it = m_gizmos.find(Scale); GizmosMap::const_iterator it = m_gizmos.find(Scale);
return (it != m_gizmos.end()) ? reinterpret_cast<GLGizmoScale3D*>(it->second)->get_scale_x() : 1.0f; return (it != m_gizmos.end()) ? reinterpret_cast<GLGizmoScale3D*>(it->second)->get_scale() : Vec3d::Ones();
} }
void GLCanvas3D::Gizmos::set_scale(float scale) void GLCanvas3D::Gizmos::set_scale(const Vec3d& scale)
{ {
if (!m_enabled) if (!m_enabled)
return; return;
@ -1438,7 +1441,6 @@ void GLCanvas3D::Gizmos::set_scale(float scale)
reinterpret_cast<GLGizmoScale3D*>(it->second)->set_scale(scale); reinterpret_cast<GLGizmoScale3D*>(it->second)->set_scale(scale);
} }
#if ENABLE_MODELINSTANCE_3D_ROTATION
Vec3d GLCanvas3D::Gizmos::get_rotation() const Vec3d GLCanvas3D::Gizmos::get_rotation() const
{ {
if (!m_enabled) if (!m_enabled)
@ -1467,6 +1469,25 @@ Vec3d GLCanvas3D::Gizmos::get_flattening_rotation() const
return (it != m_gizmos.end()) ? reinterpret_cast<GLGizmoFlatten*>(it->second)->get_flattening_rotation() : Vec3d::Zero(); return (it != m_gizmos.end()) ? reinterpret_cast<GLGizmoFlatten*>(it->second)->get_flattening_rotation() : Vec3d::Zero();
} }
#else #else
float GLCanvas3D::Gizmos::get_scale() const
{
if (!m_enabled)
return 1.0f;
GizmosMap::const_iterator it = m_gizmos.find(Scale);
return (it != m_gizmos.end()) ? reinterpret_cast<GLGizmoScale3D*>(it->second)->get_scale_x() : 1.0f;
}
void GLCanvas3D::Gizmos::set_scale(float scale)
{
if (!m_enabled)
return;
GizmosMap::const_iterator it = m_gizmos.find(Scale);
if (it != m_gizmos.end())
reinterpret_cast<GLGizmoScale3D*>(it->second)->set_scale(scale);
}
float GLCanvas3D::Gizmos::get_angle_z() const float GLCanvas3D::Gizmos::get_angle_z() const
{ {
if (!m_enabled) if (!m_enabled)
@ -1494,7 +1515,7 @@ Vec3d GLCanvas3D::Gizmos::get_flattening_normal() const
GizmosMap::const_iterator it = m_gizmos.find(Flatten); GizmosMap::const_iterator it = m_gizmos.find(Flatten);
return (it != m_gizmos.end()) ? reinterpret_cast<GLGizmoFlatten*>(it->second)->get_flattening_normal() : Vec3d::Zero(); return (it != m_gizmos.end()) ? reinterpret_cast<GLGizmoFlatten*>(it->second)->get_flattening_normal() : Vec3d::Zero();
} }
#endif // ENABLE_MODELINSTANCE_3D_ROTATION #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
void GLCanvas3D::Gizmos::set_flattening_data(const ModelObject* model_object) void GLCanvas3D::Gizmos::set_flattening_data(const ModelObject* model_object)
{ {
@ -2426,17 +2447,15 @@ void GLCanvas3D::update_gizmos_data()
ModelInstance* model_instance = model_object->instances[0]; ModelInstance* model_instance = model_object->instances[0];
if (model_instance != nullptr) if (model_instance != nullptr)
{ {
#if ENABLE_MODELINSTANCE_3D_OFFSET #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
m_gizmos.set_position(model_instance->get_offset()); m_gizmos.set_position(model_instance->get_offset());
#else m_gizmos.set_scale(model_instance->get_scaling_factor());
m_gizmos.set_position(Vec3d(model_instance->offset(0), model_instance->offset(1), 0.0));
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
m_gizmos.set_scale(model_instance->scaling_factor);
#if ENABLE_MODELINSTANCE_3D_ROTATION
m_gizmos.set_rotation(model_instance->get_rotation()); m_gizmos.set_rotation(model_instance->get_rotation());
#else #else
m_gizmos.set_position(Vec3d(model_instance->offset(0), model_instance->offset(1), 0.0));
m_gizmos.set_scale(model_instance->scaling_factor);
m_gizmos.set_angle_z(model_instance->rotation); m_gizmos.set_angle_z(model_instance->rotation);
#endif // ENABLE_MODELINSTANCE_3D_ROTATION #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
m_gizmos.set_flattening_data(model_object); m_gizmos.set_flattening_data(model_object);
} }
} }
@ -2444,12 +2463,13 @@ void GLCanvas3D::update_gizmos_data()
else else
{ {
m_gizmos.set_position(Vec3d::Zero()); m_gizmos.set_position(Vec3d::Zero());
m_gizmos.set_scale(1.0f); #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
#if ENABLE_MODELINSTANCE_3D_ROTATION m_gizmos.set_scale(Vec3d::Ones());
m_gizmos.set_rotation(Vec3d::Zero()); m_gizmos.set_rotation(Vec3d::Zero());
#else #else
m_gizmos.set_scale(1.0f);
m_gizmos.set_angle_z(0.0f); m_gizmos.set_angle_z(0.0f);
#endif // ENABLE_MODELINSTANCE_3D_ROTATION #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
m_gizmos.set_flattening_data(nullptr); m_gizmos.set_flattening_data(nullptr);
} }
} }
@ -2806,13 +2826,13 @@ void GLCanvas3D::register_on_enable_action_buttons_callback(void* callback)
m_on_enable_action_buttons_callback.register_callback(callback); m_on_enable_action_buttons_callback.register_callback(callback);
} }
void GLCanvas3D::register_on_gizmo_scale_uniformly_callback(void* callback) #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
void GLCanvas3D::register_on_gizmo_scale_3D_callback(void* callback)
{ {
if (callback != nullptr) if (callback != nullptr)
m_on_gizmo_scale_uniformly_callback.register_callback(callback); m_on_gizmo_scale_3D_callback.register_callback(callback);
} }
#if ENABLE_MODELINSTANCE_3D_ROTATION
void GLCanvas3D::register_on_gizmo_rotate_3D_callback(void* callback) void GLCanvas3D::register_on_gizmo_rotate_3D_callback(void* callback)
{ {
if (callback != nullptr) if (callback != nullptr)
@ -2824,7 +2844,19 @@ void GLCanvas3D::register_on_gizmo_flatten_3D_callback(void* callback)
if (callback != nullptr) if (callback != nullptr)
m_on_gizmo_flatten_3D_callback.register_callback(callback); m_on_gizmo_flatten_3D_callback.register_callback(callback);
} }
void GLCanvas3D::register_on_update_geometry_3D_info_callback(void* callback)
{
if (callback != nullptr)
m_on_update_geometry_3D_info_callback.register_callback(callback);
}
#else #else
void GLCanvas3D::register_on_gizmo_scale_uniformly_callback(void* callback)
{
if (callback != nullptr)
m_on_gizmo_scale_uniformly_callback.register_callback(callback);
}
void GLCanvas3D::register_on_gizmo_rotate_callback(void* callback) void GLCanvas3D::register_on_gizmo_rotate_callback(void* callback)
{ {
if (callback != nullptr) if (callback != nullptr)
@ -2836,13 +2868,13 @@ void GLCanvas3D::register_on_gizmo_flatten_callback(void* callback)
if (callback != nullptr) if (callback != nullptr)
m_on_gizmo_flatten_callback.register_callback(callback); m_on_gizmo_flatten_callback.register_callback(callback);
} }
#endif // ENABLE_MODELINSTANCE_3D_ROTATION
void GLCanvas3D::register_on_update_geometry_info_callback(void* callback) void GLCanvas3D::register_on_update_geometry_info_callback(void* callback)
{ {
if (callback != nullptr) if (callback != nullptr)
m_on_update_geometry_info_callback.register_callback(callback); m_on_update_geometry_info_callback.register_callback(callback);
} }
#endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
void GLCanvas3D::register_action_add_callback(void* callback) void GLCanvas3D::register_action_add_callback(void* callback)
{ {
@ -3115,27 +3147,30 @@ void GLCanvas3D::on_mouse(wxMouseEvent& evt)
#if ENABLE_GIZMOS_RESET #if ENABLE_GIZMOS_RESET
else if (evt.LeftDClick() && m_gizmos.grabber_contains_mouse()) else if (evt.LeftDClick() && m_gizmos.grabber_contains_mouse())
{ {
#if ENABLE_GIZMOS_RESET
m_mouse.ignore_up_event = true; m_mouse.ignore_up_event = true;
#endif // ENABLE_GIZMOS_RESET
m_gizmos.process_double_click(); m_gizmos.process_double_click();
switch (m_gizmos.get_current_type()) switch (m_gizmos.get_current_type())
{ {
case Gizmos::Scale: case Gizmos::Scale:
{ {
#if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
const Vec3d& scale = m_gizmos.get_scale();
m_on_gizmo_scale_3D_callback.call(scale(0), scale(1), scale(2));
#else
m_on_gizmo_scale_uniformly_callback.call((double)m_gizmos.get_scale()); m_on_gizmo_scale_uniformly_callback.call((double)m_gizmos.get_scale());
#endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
update_scale_values(); update_scale_values();
m_dirty = true; m_dirty = true;
break; break;
} }
case Gizmos::Rotate: case Gizmos::Rotate:
{ {
#if ENABLE_MODELINSTANCE_3D_ROTATION #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
const Vec3d& rotation = m_gizmos.get_rotation(); const Vec3d& rotation = m_gizmos.get_rotation();
m_on_gizmo_rotate_3D_callback.call(rotation(0), rotation(1), rotation(2)); m_on_gizmo_rotate_3D_callback.call(rotation(0), rotation(1), rotation(2));
#else #else
m_on_gizmo_rotate_callback.call((double)m_gizmos.get_angle_z()); m_on_gizmo_rotate_callback.call((double)m_gizmos.get_angle_z());
#endif // ENABLE_MODELINSTANCE_3D_ROTATION #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
update_rotation_values(); update_rotation_values();
m_dirty = true; m_dirty = true;
break; break;
@ -3187,7 +3222,7 @@ void GLCanvas3D::on_mouse(wxMouseEvent& evt)
m_mouse.drag.gizmo_volume_idx = _get_first_selected_volume_id(selected_object_idx); m_mouse.drag.gizmo_volume_idx = _get_first_selected_volume_id(selected_object_idx);
if (m_gizmos.get_current_type() == Gizmos::Flatten) { if (m_gizmos.get_current_type() == Gizmos::Flatten) {
#if ENABLE_MODELINSTANCE_3D_ROTATION #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
// Rotate the object so the normal points downward: // Rotate the object so the normal points downward:
const Vec3d& rotation = m_gizmos.get_flattening_rotation(); const Vec3d& rotation = m_gizmos.get_flattening_rotation();
m_on_gizmo_flatten_3D_callback.call(rotation(0), rotation(1), rotation(2)); m_on_gizmo_flatten_3D_callback.call(rotation(0), rotation(1), rotation(2));
@ -3199,7 +3234,7 @@ void GLCanvas3D::on_mouse(wxMouseEvent& evt)
float angle = acos(clamp(-1.0, 1.0, -normal(2))); float angle = acos(clamp(-1.0, 1.0, -normal(2)));
m_on_gizmo_flatten_callback.call(angle, (float)axis(0), (float)axis(1), (float)axis(2)); m_on_gizmo_flatten_callback.call(angle, (float)axis(0), (float)axis(1), (float)axis(2));
} }
#endif // ENABLE_MODELINSTANCE_3D_ROTATION #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
} }
m_dirty = true; m_dirty = true;
@ -3371,6 +3406,15 @@ void GLCanvas3D::on_mouse(wxMouseEvent& evt)
} }
case Gizmos::Scale: case Gizmos::Scale:
{ {
#if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
// Apply new temporary scale factors
const Vec3d& scale = m_gizmos.get_scale();
for (GLVolume* v : volumes)
{
v->set_scaling_factor(scale);
}
update_scale_values(scale);
#else
// Apply new temporary scale factor // Apply new temporary scale factor
float scale_factor = m_gizmos.get_scale(); float scale_factor = m_gizmos.get_scale();
for (GLVolume* v : volumes) for (GLVolume* v : volumes)
@ -3378,13 +3422,14 @@ void GLCanvas3D::on_mouse(wxMouseEvent& evt)
v->set_scaling_factor((double)scale_factor); v->set_scaling_factor((double)scale_factor);
} }
update_scale_values((double)scale_factor); update_scale_values((double)scale_factor);
#endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
break; break;
} }
case Gizmos::Rotate: case Gizmos::Rotate:
{ {
#if ENABLE_MODELINSTANCE_3D_ROTATION #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
// Apply new temporary rotation // Apply new temporary rotation
Vec3d rotation = m_gizmos.get_rotation(); const Vec3d& rotation = m_gizmos.get_rotation();
for (GLVolume* v : volumes) for (GLVolume* v : volumes)
{ {
v->set_rotation(rotation); v->set_rotation(rotation);
@ -3398,7 +3443,7 @@ void GLCanvas3D::on_mouse(wxMouseEvent& evt)
v->set_rotation((double)angle_z); v->set_rotation((double)angle_z);
} }
update_rotation_value((double)angle_z, Z); update_rotation_value((double)angle_z, Z);
#endif // ENABLE_MODELINSTANCE_3D_ROTATION #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
break; break;
} }
default: default:
@ -3413,7 +3458,12 @@ void GLCanvas3D::on_mouse(wxMouseEvent& evt)
bb.merge(volume->transformed_bounding_box()); bb.merge(volume->transformed_bounding_box());
} }
const Vec3d& size = bb.size(); const Vec3d& size = bb.size();
#if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
const Vec3d& scale = m_gizmos.get_scale();
m_on_update_geometry_3D_info_callback.call(size(0), size(1), size(2), scale(0), scale(1), scale(2));
#else
m_on_update_geometry_info_callback.call(size(0), size(1), size(2), m_gizmos.get_scale()); m_on_update_geometry_info_callback.call(size(0), size(1), size(2), m_gizmos.get_scale());
#endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
} }
m_dirty = true; m_dirty = true;
@ -3539,17 +3589,22 @@ void GLCanvas3D::on_mouse(wxMouseEvent& evt)
} }
case Gizmos::Scale: case Gizmos::Scale:
{ {
#if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
const Vec3d& scale = m_gizmos.get_scale();
m_on_gizmo_scale_3D_callback.call(scale(0), scale(1), scale(2));
#else
m_on_gizmo_scale_uniformly_callback.call((double)m_gizmos.get_scale()); m_on_gizmo_scale_uniformly_callback.call((double)m_gizmos.get_scale());
#endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
break; break;
} }
case Gizmos::Rotate: case Gizmos::Rotate:
{ {
#if ENABLE_MODELINSTANCE_3D_ROTATION #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
const Vec3d& rotation = m_gizmos.get_rotation(); const Vec3d& rotation = m_gizmos.get_rotation();
m_on_gizmo_rotate_3D_callback.call(rotation(0), rotation(1), rotation(2)); m_on_gizmo_rotate_3D_callback.call(rotation(0), rotation(1), rotation(2));
#else #else
m_on_gizmo_rotate_callback.call((double)m_gizmos.get_angle_z()); m_on_gizmo_rotate_callback.call((double)m_gizmos.get_angle_z());
#endif // ENABLE_MODELINSTANCE_3D_ROTATION #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
break; break;
} }
default: default:
@ -3995,15 +4050,17 @@ void GLCanvas3D::_deregister_callbacks()
m_on_instance_moved_callback.deregister_callback(); m_on_instance_moved_callback.deregister_callback();
m_on_wipe_tower_moved_callback.deregister_callback(); m_on_wipe_tower_moved_callback.deregister_callback();
m_on_enable_action_buttons_callback.deregister_callback(); m_on_enable_action_buttons_callback.deregister_callback();
m_on_gizmo_scale_uniformly_callback.deregister_callback(); #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
#if ENABLE_MODELINSTANCE_3D_ROTATION m_on_gizmo_scale_3D_callback.deregister_callback();
m_on_gizmo_rotate_3D_callback.deregister_callback(); m_on_gizmo_rotate_3D_callback.deregister_callback();
m_on_gizmo_flatten_3D_callback.deregister_callback(); m_on_gizmo_flatten_3D_callback.deregister_callback();
m_on_update_geometry_3D_info_callback.deregister_callback();
#else #else
m_on_gizmo_scale_uniformly_callback.deregister_callback();
m_on_gizmo_rotate_callback.deregister_callback(); m_on_gizmo_rotate_callback.deregister_callback();
m_on_gizmo_flatten_callback.deregister_callback(); m_on_gizmo_flatten_callback.deregister_callback();
#endif // ENABLE_MODELINSTANCE_3D_ROTATION
m_on_update_geometry_info_callback.deregister_callback(); m_on_update_geometry_info_callback.deregister_callback();
#endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
m_action_add_callback.deregister_callback(); m_action_add_callback.deregister_callback();
m_action_delete_callback.deregister_callback(); m_action_delete_callback.deregister_callback();
@ -5510,12 +5567,12 @@ void GLCanvas3D::_on_move(const std::vector<int>& volume_idxs)
ModelObject* model_object = m_model->objects[obj_idx]; ModelObject* model_object = m_model->objects[obj_idx];
if (model_object != nullptr) if (model_object != nullptr)
{ {
#if ENABLE_MODELINSTANCE_3D_OFFSET #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
model_object->instances[instance_idx]->set_offset(volume->get_offset()); model_object->instances[instance_idx]->set_offset(volume->get_offset());
#else #else
const Vec3d& offset = volume->get_offset(); const Vec3d& offset = volume->get_offset();
model_object->instances[instance_idx]->offset = Vec2d(offset(0), offset(1)); model_object->instances[instance_idx]->offset = Vec2d(offset(0), offset(1));
#endif // ENABLE_MODELINSTANCE_3D_OFFSET #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
model_object->invalidate_bounding_box(); model_object->invalidate_bounding_box();
update_position_values(); update_position_values();
object_moved = true; object_moved = true;

36
src/slic3r/GUI/GLCanvas3D.hpp
View File

@ -384,22 +384,24 @@ class GLCanvas3D
Vec3d get_position() const; Vec3d get_position() const;
void set_position(const Vec3d& position); void set_position(const Vec3d& position);
#if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
Vec3d get_scale() const;
void set_scale(const Vec3d& scale);
Vec3d get_rotation() const;
void set_rotation(const Vec3d& rotation);
Vec3d get_flattening_rotation() const;
#else
float get_scale() const; float get_scale() const;
void set_scale(float scale); void set_scale(float scale);
#if ENABLE_MODELINSTANCE_3D_ROTATION
Vec3d get_rotation() const;
void set_rotation(const Vec3d& rotation);
#else
float get_angle_z() const; float get_angle_z() const;
void set_angle_z(float angle_z); void set_angle_z(float angle_z);
#endif // ENABLE_MODELINSTANCE_3D_ROTATION
#if ENABLE_MODELINSTANCE_3D_ROTATION
Vec3d get_flattening_rotation() const;
#else
Vec3d get_flattening_normal() const; Vec3d get_flattening_normal() const;
#endif // ENABLE_MODELINSTANCE_3D_ROTATION #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
void set_flattening_data(const ModelObject* model_object); void set_flattening_data(const ModelObject* model_object);
void render_current_gizmo(const BoundingBoxf3& box) const; void render_current_gizmo(const BoundingBoxf3& box) const;
@ -515,15 +517,17 @@ class GLCanvas3D
PerlCallback m_on_instance_moved_callback; PerlCallback m_on_instance_moved_callback;
PerlCallback m_on_wipe_tower_moved_callback; PerlCallback m_on_wipe_tower_moved_callback;
PerlCallback m_on_enable_action_buttons_callback; PerlCallback m_on_enable_action_buttons_callback;
PerlCallback m_on_gizmo_scale_uniformly_callback; #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
#if ENABLE_MODELINSTANCE_3D_ROTATION
PerlCallback m_on_gizmo_rotate_3D_callback; PerlCallback m_on_gizmo_rotate_3D_callback;
PerlCallback m_on_gizmo_flatten_3D_callback; PerlCallback m_on_gizmo_flatten_3D_callback;
PerlCallback m_on_gizmo_scale_3D_callback;
PerlCallback m_on_update_geometry_3D_info_callback;
#else #else
PerlCallback m_on_gizmo_scale_uniformly_callback;
PerlCallback m_on_gizmo_rotate_callback; PerlCallback m_on_gizmo_rotate_callback;
PerlCallback m_on_gizmo_flatten_callback; PerlCallback m_on_gizmo_flatten_callback;
#endif // ENABLE_MODELINSTANCE_3D_ROTATION
PerlCallback m_on_update_geometry_info_callback; PerlCallback m_on_update_geometry_info_callback;
#endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
PerlCallback m_action_add_callback; PerlCallback m_action_add_callback;
PerlCallback m_action_delete_callback; PerlCallback m_action_delete_callback;
@ -645,15 +649,17 @@ public:
void register_on_instance_moved_callback(void* callback); void register_on_instance_moved_callback(void* callback);
void register_on_wipe_tower_moved_callback(void* callback); void register_on_wipe_tower_moved_callback(void* callback);
void register_on_enable_action_buttons_callback(void* callback); void register_on_enable_action_buttons_callback(void* callback);
void register_on_gizmo_scale_uniformly_callback(void* callback); #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
#if ENABLE_MODELINSTANCE_3D_ROTATION void register_on_gizmo_scale_3D_callback(void* callback);
void register_on_gizmo_rotate_3D_callback(void* callback); void register_on_gizmo_rotate_3D_callback(void* callback);
void register_on_gizmo_flatten_3D_callback(void* callback); void register_on_gizmo_flatten_3D_callback(void* callback);
void register_on_update_geometry_3D_info_callback(void* callback);
#else #else
void register_on_gizmo_scale_uniformly_callback(void* callback);
void register_on_gizmo_rotate_callback(void* callback); void register_on_gizmo_rotate_callback(void* callback);
void register_on_gizmo_flatten_callback(void* callback); void register_on_gizmo_flatten_callback(void* callback);
#endif // ENABLE_MODELINSTANCE_3D_ROTATION
void register_on_update_geometry_info_callback(void* callback); void register_on_update_geometry_info_callback(void* callback);
#endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
void register_action_add_callback(void* callback); void register_action_add_callback(void* callback);
void register_action_delete_callback(void* callback); void register_action_delete_callback(void* callback);

22
src/slic3r/GUI/GLCanvas3DManager.cpp
View File

@ -692,14 +692,14 @@ void GLCanvas3DManager::register_on_enable_action_buttons_callback(wxGLCanvas* c
it->second->register_on_enable_action_buttons_callback(callback); it->second->register_on_enable_action_buttons_callback(callback);
} }
void GLCanvas3DManager::register_on_gizmo_scale_uniformly_callback(wxGLCanvas* canvas, void* callback) #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
void GLCanvas3DManager::register_on_gizmo_scale_3D_callback(wxGLCanvas* canvas, void* callback)
{ {
CanvasesMap::iterator it = _get_canvas(canvas); CanvasesMap::iterator it = _get_canvas(canvas);
if (it != m_canvases.end()) if (it != m_canvases.end())
it->second->register_on_gizmo_scale_uniformly_callback(callback); it->second->register_on_gizmo_scale_3D_callback(callback);
} }
#if ENABLE_MODELINSTANCE_3D_ROTATION
void GLCanvas3DManager::register_on_gizmo_rotate_3D_callback(wxGLCanvas* canvas, void* callback) void GLCanvas3DManager::register_on_gizmo_rotate_3D_callback(wxGLCanvas* canvas, void* callback)
{ {
CanvasesMap::iterator it = _get_canvas(canvas); CanvasesMap::iterator it = _get_canvas(canvas);
@ -713,7 +713,21 @@ void GLCanvas3DManager::register_on_gizmo_flatten_3D_callback(wxGLCanvas* canvas
if (it != m_canvases.end()) if (it != m_canvases.end())
it->second->register_on_gizmo_flatten_3D_callback(callback); it->second->register_on_gizmo_flatten_3D_callback(callback);
} }
void GLCanvas3DManager::register_on_update_geometry_3D_info_callback(wxGLCanvas* canvas, void* callback)
{
CanvasesMap::iterator it = _get_canvas(canvas);
if (it != m_canvases.end())
it->second->register_on_update_geometry_3D_info_callback(callback);
}
#else #else
void GLCanvas3DManager::register_on_gizmo_scale_uniformly_callback(wxGLCanvas* canvas, void* callback)
{
CanvasesMap::iterator it = _get_canvas(canvas);
if (it != m_canvases.end())
it->second->register_on_gizmo_scale_uniformly_callback(callback);
}
void GLCanvas3DManager::register_on_gizmo_rotate_callback(wxGLCanvas* canvas, void* callback) void GLCanvas3DManager::register_on_gizmo_rotate_callback(wxGLCanvas* canvas, void* callback)
{ {
CanvasesMap::iterator it = _get_canvas(canvas); CanvasesMap::iterator it = _get_canvas(canvas);
@ -727,7 +741,6 @@ void GLCanvas3DManager::register_on_gizmo_flatten_callback(wxGLCanvas* canvas, v
if (it != m_canvases.end()) if (it != m_canvases.end())
it->second->register_on_gizmo_flatten_callback(callback); it->second->register_on_gizmo_flatten_callback(callback);
} }
#endif // ENABLE_MODELINSTANCE_3D_ROTATION
void GLCanvas3DManager::register_on_update_geometry_info_callback(wxGLCanvas* canvas, void* callback) void GLCanvas3DManager::register_on_update_geometry_info_callback(wxGLCanvas* canvas, void* callback)
{ {
@ -735,6 +748,7 @@ void GLCanvas3DManager::register_on_update_geometry_info_callback(wxGLCanvas* ca
if (it != m_canvases.end()) if (it != m_canvases.end())
it->second->register_on_update_geometry_info_callback(callback); it->second->register_on_update_geometry_info_callback(callback);
} }
#endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
void GLCanvas3DManager::register_action_add_callback(wxGLCanvas* canvas, void* callback) void GLCanvas3DManager::register_action_add_callback(wxGLCanvas* canvas, void* callback)
{ {

8
src/slic3r/GUI/GLCanvas3DManager.hpp
View File

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

202
src/slic3r/GUI/GLGizmo.cpp
View File

@ -336,10 +336,9 @@ const unsigned int GLGizmoRotate::AngleResolution = 64;
const unsigned int GLGizmoRotate::ScaleStepsCount = 72; const unsigned int GLGizmoRotate::ScaleStepsCount = 72;
const float GLGizmoRotate::ScaleStepRad = 2.0f * (float)PI / GLGizmoRotate::ScaleStepsCount; const float GLGizmoRotate::ScaleStepRad = 2.0f * (float)PI / GLGizmoRotate::ScaleStepsCount;
const unsigned int GLGizmoRotate::ScaleLongEvery = 2; const unsigned int GLGizmoRotate::ScaleLongEvery = 2;
const float GLGizmoRotate::ScaleLongTooth = 2.0f; const float GLGizmoRotate::ScaleLongTooth = 0.1f; // in percent of radius
const float GLGizmoRotate::ScaleShortTooth = 1.0f;
const unsigned int GLGizmoRotate::SnapRegionsCount = 8; const unsigned int GLGizmoRotate::SnapRegionsCount = 8;
const float GLGizmoRotate::GrabberOffset = 5.0f; const float GLGizmoRotate::GrabberOffset = 0.15f; // in percent of radius
GLGizmoRotate::GLGizmoRotate(GLCanvas3D& parent, GLGizmoRotate::Axis axis) GLGizmoRotate::GLGizmoRotate(GLCanvas3D& parent, GLGizmoRotate::Axis axis)
: GLGizmoBase(parent) : GLGizmoBase(parent)
@ -347,6 +346,10 @@ GLGizmoRotate::GLGizmoRotate(GLCanvas3D& parent, GLGizmoRotate::Axis axis)
, m_angle(0.0) , m_angle(0.0)
, m_center(0.0, 0.0, 0.0) , m_center(0.0, 0.0, 0.0)
, m_radius(0.0f) , m_radius(0.0f)
, m_snap_coarse_in_radius(0.0f)
, m_snap_coarse_out_radius(0.0f)
, m_snap_fine_in_radius(0.0f)
, m_snap_fine_out_radius(0.0f)
{ {
} }
@ -368,6 +371,10 @@ void GLGizmoRotate::on_start_dragging(const BoundingBoxf3& box)
{ {
m_center = box.center(); m_center = box.center();
m_radius = Offset + box.radius(); m_radius = Offset + box.radius();
m_snap_coarse_in_radius = m_radius / 3.0f;
m_snap_coarse_out_radius = 2.0f * m_snap_coarse_in_radius;
m_snap_fine_in_radius = m_radius;
m_snap_fine_out_radius = m_snap_fine_in_radius + m_radius * ScaleLongTooth;
} }
void GLGizmoRotate::on_update(const Linef3& mouse_ray) void GLGizmoRotate::on_update(const Linef3& mouse_ray)
@ -383,20 +390,16 @@ void GLGizmoRotate::on_update(const Linef3& mouse_ray)
double len = mouse_pos.norm(); double len = mouse_pos.norm();
// snap to snap region // snap to coarse snap region
double in_radius = (double)m_radius / 3.0; if ((m_snap_coarse_in_radius <= len) && (len <= m_snap_coarse_out_radius))
double out_radius = 2.0 * (double)in_radius;
if ((in_radius <= len) && (len <= out_radius))
{ {
double step = 2.0 * (double)PI / (double)SnapRegionsCount; double step = 2.0 * (double)PI / (double)SnapRegionsCount;
theta = step * (double)std::round(theta / step); theta = step * (double)std::round(theta / step);
} }
else else
{ {
// snap to scale // snap to fine snap region (scale)
in_radius = (double)m_radius; if ((m_snap_fine_in_radius <= len) && (len <= m_snap_fine_out_radius))
out_radius = in_radius + (double)ScaleLongTooth;
if ((in_radius <= len) && (len <= out_radius))
{ {
double step = 2.0 * (double)PI / (double)ScaleStepsCount; double step = 2.0 * (double)PI / (double)ScaleStepsCount;
theta = step * (double)std::round(theta / step); theta = step * (double)std::round(theta / step);
@ -420,6 +423,10 @@ void GLGizmoRotate::on_render(const BoundingBoxf3& box) const
{ {
m_center = box.center(); m_center = box.center();
m_radius = Offset + box.radius(); m_radius = Offset + box.radius();
m_snap_coarse_in_radius = m_radius / 3.0f;
m_snap_coarse_out_radius = 2.0f * m_snap_coarse_in_radius;
m_snap_fine_in_radius = m_radius;
m_snap_fine_out_radius = m_radius * (1.0f + ScaleLongTooth);
} }
::glEnable(GL_DEPTH_TEST); ::glEnable(GL_DEPTH_TEST);
@ -477,8 +484,8 @@ void GLGizmoRotate::render_circle() const
void GLGizmoRotate::render_scale() const void GLGizmoRotate::render_scale() const
{ {
float out_radius_long = m_radius + ScaleLongTooth; float out_radius_long = m_snap_fine_out_radius;
float out_radius_short = m_radius + ScaleShortTooth; float out_radius_short = m_radius * (1.0f + 0.5f * ScaleLongTooth);
::glBegin(GL_LINES); ::glBegin(GL_LINES);
for (unsigned int i = 0; i < ScaleStepsCount; ++i) for (unsigned int i = 0; i < ScaleStepsCount; ++i)
@ -527,14 +534,14 @@ void GLGizmoRotate::render_reference_radius() const
{ {
::glBegin(GL_LINES); ::glBegin(GL_LINES);
::glVertex3f(0.0f, 0.0f, 0.0f); ::glVertex3f(0.0f, 0.0f, 0.0f);
::glVertex3f((GLfloat)(m_radius + GrabberOffset), 0.0f, 0.0f); ::glVertex3f((GLfloat)(m_radius * (1.0f + GrabberOffset)), 0.0f, 0.0f);
::glEnd(); ::glEnd();
} }
void GLGizmoRotate::render_angle() const void GLGizmoRotate::render_angle() const
{ {
float step_angle = (float)m_angle / AngleResolution; float step_angle = (float)m_angle / AngleResolution;
float ex_radius = m_radius + GrabberOffset; float ex_radius = m_radius * (1.0f + GrabberOffset);
::glBegin(GL_LINE_STRIP); ::glBegin(GL_LINE_STRIP);
for (unsigned int i = 0; i <= AngleResolution; ++i) for (unsigned int i = 0; i <= AngleResolution; ++i)
@ -550,7 +557,7 @@ void GLGizmoRotate::render_angle() const
void GLGizmoRotate::render_grabber(const BoundingBoxf3& box) const void GLGizmoRotate::render_grabber(const BoundingBoxf3& box) const
{ {
double grabber_radius = (double)(m_radius + GrabberOffset); double grabber_radius = (double)m_radius * (1.0 + (double)GrabberOffset);
m_grabbers[0].center = Vec3d(::cos(m_angle) * grabber_radius, ::sin(m_angle) * grabber_radius, 0.0); m_grabbers[0].center = Vec3d(::cos(m_angle) * grabber_radius, ::sin(m_angle) * grabber_radius, 0.0);
m_grabbers[0].angles(2) = m_angle; m_grabbers[0].angles(2) = m_angle;
@ -762,13 +769,7 @@ void GLGizmoScale3D::on_update(const Linef3& mouse_ray)
#if ENABLE_GIZMOS_RESET #if ENABLE_GIZMOS_RESET
void GLGizmoScale3D::on_process_double_click() void GLGizmoScale3D::on_process_double_click()
{ {
if ((m_hover_id == 0) || (m_hover_id == 1)) if (m_hover_id >= 6)
m_scale(0) = 1.0;
else if ((m_hover_id == 2) || (m_hover_id == 3))
m_scale(1) = 1.0;
else if ((m_hover_id == 4) || (m_hover_id == 5))
m_scale(2) = 1.0;
else if (m_hover_id >= 6)
m_scale = Vec3d::Ones(); m_scale = Vec3d::Ones();
} }
#endif // ENABLE_GIZMOS_RESET #endif // ENABLE_GIZMOS_RESET
@ -980,8 +981,11 @@ void GLGizmoScale3D::do_scale_y(const Linef3& mouse_ray)
double ratio = calc_ratio(2, mouse_ray, m_starting_box.center()); double ratio = calc_ratio(2, mouse_ray, m_starting_box.center());
if (ratio > 0.0) if (ratio > 0.0)
m_scale(0) = m_starting_scale(1) * ratio; // << this is temporary #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
// m_scale(1) = m_starting_scale(1) * ratio; m_scale(1) = m_starting_scale(1) * ratio;
#else
m_scale(0) = m_starting_scale(1) * ratio;
#endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
} }
void GLGizmoScale3D::do_scale_z(const Linef3& mouse_ray) void GLGizmoScale3D::do_scale_z(const Linef3& mouse_ray)
@ -989,8 +993,11 @@ void GLGizmoScale3D::do_scale_z(const Linef3& mouse_ray)
double ratio = calc_ratio(1, mouse_ray, m_starting_box.center()); double ratio = calc_ratio(1, mouse_ray, m_starting_box.center());
if (ratio > 0.0) if (ratio > 0.0)
#if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
m_scale(2) = m_starting_scale(2) * ratio;
#else
m_scale(0) = m_starting_scale(2) * ratio; // << this is temporary m_scale(0) = m_starting_scale(2) * ratio; // << this is temporary
// m_scale(2) = m_starting_scale(2) * ratio; #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
} }
void GLGizmoScale3D::do_scale_uniform(const Linef3& mouse_ray) void GLGizmoScale3D::do_scale_uniform(const Linef3& mouse_ray)
@ -1250,32 +1257,18 @@ void GLGizmoFlatten::on_render(const BoundingBoxf3& box) const
else else
::glColor4f(0.9f, 0.9f, 0.9f, 0.5f); ::glColor4f(0.9f, 0.9f, 0.9f, 0.5f);
#if ENABLE_MODELINSTANCE_3D_OFFSET #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
#if ENABLE_MODELINSTANCE_3D_ROTATION
for (const InstanceData& inst : m_instances) { for (const InstanceData& inst : m_instances) {
Vec3d position = inst.position + dragged_offset; Transform3d m = inst.matrix;
#else m.pretranslate(dragged_offset);
for (Vec3d offset : m_instances_positions) { ::glPushMatrix();
offset += dragged_offset; ::glMultMatrixd(m.data());
#endif // ENABLE_MODELINSTANCE_3D_ROTATION
#else #else
for (Vec2d offset : m_instances_positions) { for (Vec2d offset : m_instances_positions) {
offset += to_2d(dragged_offset); offset += to_2d(dragged_offset);
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
::glPushMatrix(); ::glPushMatrix();
#if ENABLE_MODELINSTANCE_3D_OFFSET
#if ENABLE_MODELINSTANCE_3D_ROTATION
::glTranslated(position(0), position(1), position(2));
::glRotated(inst.rotation(2) * 180.0 / (double)PI, 0.0, 0.0, 1.0);
::glRotated(inst.rotation(1) * 180.0 / (double)PI, 0.0, 1.0, 0.0);
::glRotated(inst.rotation(0) * 180.0 / (double)PI, 1.0, 0.0, 0.0);
::glScaled(inst.scaling_factor, inst.scaling_factor, inst.scaling_factor);
#else
::glTranslated(offset(0), offset(1), offset(2));
#endif // ENABLE_MODELINSTANCE_3D_ROTATION
#else
::glTranslatef((GLfloat)offset(0), (GLfloat)offset(1), 0.0f); ::glTranslatef((GLfloat)offset(0), (GLfloat)offset(1), 0.0f);
#endif // ENABLE_MODELINSTANCE_3D_OFFSET #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
::glBegin(GL_POLYGON); ::glBegin(GL_POLYGON);
for (const Vec3d& vertex : m_planes[i].vertices) for (const Vec3d& vertex : m_planes[i].vertices)
::glVertex3f((GLfloat)vertex(0), (GLfloat)vertex(1), (GLfloat)vertex(2)); ::glVertex3f((GLfloat)vertex(0), (GLfloat)vertex(1), (GLfloat)vertex(2));
@ -1294,29 +1287,15 @@ void GLGizmoFlatten::on_render_for_picking(const BoundingBoxf3& box) const
for (unsigned int i = 0; i < m_planes.size(); ++i) for (unsigned int i = 0; i < m_planes.size(); ++i)
{ {
::glColor3f(1.0f, 1.0f, picking_color_component(i)); ::glColor3f(1.0f, 1.0f, picking_color_component(i));
#if ENABLE_MODELINSTANCE_3D_OFFSET #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
#if ENABLE_MODELINSTANCE_3D_ROTATION
for (const InstanceData& inst : m_instances) { for (const InstanceData& inst : m_instances) {
#else ::glPushMatrix();
for (const Vec3d& offset : m_instances_positions) { ::glMultMatrixd(inst.matrix.data());
#endif // ENABLE_MODELINSTANCE_3D_ROTATION
#else #else
for (const Vec2d& offset : m_instances_positions) { for (const Vec2d& offset : m_instances_positions) {
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
::glPushMatrix(); ::glPushMatrix();
#if ENABLE_MODELINSTANCE_3D_OFFSET
#if ENABLE_MODELINSTANCE_3D_ROTATION
::glTranslated(inst.position(0), inst.position(1), inst.position(2));
::glRotated(inst.rotation(2) * 180.0 / (double)PI, 0.0, 0.0, 1.0);
::glRotated(inst.rotation(1) * 180.0 / (double)PI, 0.0, 1.0, 0.0);
::glRotated(inst.rotation(0) * 180.0 / (double)PI, 1.0, 0.0, 0.0);
::glScaled(inst.scaling_factor, inst.scaling_factor, inst.scaling_factor);
#else
::glTranslated(offset(0), offset(1), offset(2));
#endif // ENABLE_MODELINSTANCE_3D_ROTATION
#else
::glTranslatef((GLfloat)offset(0), (GLfloat)offset(1), 0.0f); ::glTranslatef((GLfloat)offset(0), (GLfloat)offset(1), 0.0f);
#endif // ENABLE_MODELINSTANCE_3D_OFFSET #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
::glBegin(GL_POLYGON); ::glBegin(GL_POLYGON);
for (const Vec3d& vertex : m_planes[i].vertices) for (const Vec3d& vertex : m_planes[i].vertices)
::glVertex3f((GLfloat)vertex(0), (GLfloat)vertex(1), (GLfloat)vertex(2)); ::glVertex3f((GLfloat)vertex(0), (GLfloat)vertex(1), (GLfloat)vertex(2));
@ -1332,21 +1311,17 @@ void GLGizmoFlatten::set_flattening_data(const ModelObject* model_object)
// ...and save the updated positions of the object instances: // ...and save the updated positions of the object instances:
if (m_model_object && !m_model_object->instances.empty()) { if (m_model_object && !m_model_object->instances.empty()) {
#if ENABLE_MODELINSTANCE_3D_ROTATION #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
m_instances.clear(); m_instances.clear();
#else #else
m_instances_positions.clear(); m_instances_positions.clear();
#endif // ENABLE_MODELINSTANCE_3D_ROTATION #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
for (const auto* instance : m_model_object->instances) for (const auto* instance : m_model_object->instances)
#if ENABLE_MODELINSTANCE_3D_OFFSET #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
#if ENABLE_MODELINSTANCE_3D_ROTATION m_instances.emplace_back(instance->world_matrix());
m_instances.emplace_back(instance->get_offset(), instance->get_rotation(), instance->scaling_factor);
#else
m_instances_positions.emplace_back(instance->get_offset());
#endif // ENABLE_MODELINSTANCE_3D_ROTATION
#else #else
m_instances_positions.emplace_back(instance->offset); m_instances_positions.emplace_back(instance->offset);
#endif // ENABLE_MODELINSTANCE_3D_OFFSET #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
} }
if (is_plane_update_necessary()) if (is_plane_update_necessary())
@ -1358,11 +1333,15 @@ void GLGizmoFlatten::update_planes()
TriangleMesh ch; TriangleMesh ch;
for (const ModelVolume* vol : m_model_object->volumes) for (const ModelVolume* vol : m_model_object->volumes)
ch.merge(vol->get_convex_hull()); ch.merge(vol->get_convex_hull());
ch = ch.convex_hull_3d(); ch = ch.convex_hull_3d();
#if !ENABLE_MODELINSTANCE_3D_ROTATION #if !ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
ch.scale(m_model_object->instances.front()->scaling_factor); ch.scale(m_model_object->instances.front()->scaling_factor);
ch.rotate_z(m_model_object->instances.front()->rotation); ch.rotate_z(m_model_object->instances.front()->rotation);
#endif // !ENABLE_MODELINSTANCE_3D_ROTATION #endif // !ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
const Vec3d& bb_size = ch.bounding_box().size();
double min_bb_face_area = std::min(bb_size(0) * bb_size(1), std::min(bb_size(0) * bb_size(2), bb_size(1) * bb_size(2)));
m_planes.clear(); m_planes.clear();
@ -1392,7 +1371,7 @@ void GLGizmoFlatten::update_planes()
if (std::abs(this_normal(0) - (*normal_ptr)(0)) < 0.001 && std::abs(this_normal(1) - (*normal_ptr)(1)) < 0.001 && std::abs(this_normal(2) - (*normal_ptr)(2)) < 0.001) { if (std::abs(this_normal(0) - (*normal_ptr)(0)) < 0.001 && std::abs(this_normal(1) - (*normal_ptr)(1)) < 0.001 && std::abs(this_normal(2) - (*normal_ptr)(2)) < 0.001) {
stl_vertex* first_vertex = ch.stl.facet_start[facet_idx].vertex; stl_vertex* first_vertex = ch.stl.facet_start[facet_idx].vertex;
for (int j=0; j<3; ++j) for (int j=0; j<3; ++j)
m_planes.back().vertices.emplace_back(first_vertex[j](0), first_vertex[j](1), first_vertex[j](2)); m_planes.back().vertices.emplace_back((double)first_vertex[j](0), (double)first_vertex[j](1), (double)first_vertex[j](2));
facet_visited[facet_idx] = true; facet_visited[facet_idx] = true;
for (int j = 0; j < 3; ++ j) { for (int j = 0; j < 3; ++ j) {
@ -1406,49 +1385,63 @@ void GLGizmoFlatten::update_planes()
// if this is a just a very small triangle, remove it to speed up further calculations (it would be rejected anyway): // if this is a just a very small triangle, remove it to speed up further calculations (it would be rejected anyway):
if (m_planes.back().vertices.size() == 3 && if (m_planes.back().vertices.size() == 3 &&
(m_planes.back().vertices[0] - m_planes.back().vertices[1]).norm() < 1.f ((m_planes.back().vertices[0] - m_planes.back().vertices[1]).norm() < 1.0
|| (m_planes.back().vertices[0] - m_planes.back().vertices[2]).norm() < 1.f) || (m_planes.back().vertices[0] - m_planes.back().vertices[2]).norm() < 1.0
|| (m_planes.back().vertices[1] - m_planes.back().vertices[2]).norm() < 1.0))
m_planes.pop_back(); m_planes.pop_back();
} }
const float minimal_area = 0.01f * (float)min_bb_face_area;
// Now we'll go through all the polygons, transform the points into xy plane to process them: // Now we'll go through all the polygons, transform the points into xy plane to process them:
for (unsigned int polygon_id=0; polygon_id < m_planes.size(); ++polygon_id) { for (unsigned int polygon_id=0; polygon_id < m_planes.size(); ++polygon_id) {
Pointf3s& polygon = m_planes[polygon_id].vertices; Pointf3s& polygon = m_planes[polygon_id].vertices;
const Vec3d& normal = m_planes[polygon_id].normal; const Vec3d& normal = m_planes[polygon_id].normal;
// We are going to rotate about z and y to flatten the plane // We are going to rotate about z and y to flatten the plane
float angle_z = 0.f; Eigen::Quaterniond q;
float angle_y = 0.f;
if (std::abs(normal(1)) > 0.001)
angle_z = -atan2(normal(1), normal(0)); // angle to rotate so that normal ends up in xz-plane
if (std::abs(normal(0)*cos(angle_z) - normal(1)*sin(angle_z)) > 0.001)
angle_y = -atan2(normal(0)*cos(angle_z) - normal(1)*sin(angle_z), normal(2)); // angle to rotate to make normal point upwards
else {
// In case it already was in z-direction, we must ensure it is not the wrong way:
angle_y = normal(2) > 0.f ? 0.f : -PI;
}
// Rotate all points to the xy plane:
Transform3d m = Transform3d::Identity(); Transform3d m = Transform3d::Identity();
m.rotate(Eigen::AngleAxisd((double)angle_y, Vec3d::UnitY())); m.matrix().block(0, 0, 3, 3) = q.setFromTwoVectors(normal, Vec3d::UnitZ()).toRotationMatrix();
m.rotate(Eigen::AngleAxisd((double)angle_z, Vec3d::UnitZ()));
polygon = transform(polygon, m); polygon = transform(polygon, m);
polygon = Slic3r::Geometry::convex_hull(polygon); // To remove the inner points polygon = Slic3r::Geometry::convex_hull(polygon); // To remove the inner points
// We will calculate area of the polygon and discard ones that are too small // We will calculate area of the polygons and discard ones that are too small
// The limit is more forgiving in case the normal is in the direction of the coordinate axes // The limit is more forgiving in case the normal is in the direction of the coordinate axes
const float minimal_area = (std::abs(normal(0)) > 0.999f || std::abs(normal(1)) > 0.999f || std::abs(normal(2)) > 0.999f) ? 1.f : 20.f; float area_threshold = (std::abs(normal(0)) > 0.999f || std::abs(normal(1)) > 0.999f || std::abs(normal(2)) > 0.999f) ? minimal_area : 10.0f * minimal_area;
float& area = m_planes[polygon_id].area; float& area = m_planes[polygon_id].area;
area = 0.f; area = 0.f;
for (unsigned int i = 0; i < polygon.size(); i++) // Shoelace formula for (unsigned int i = 0; i < polygon.size(); i++) // Shoelace formula
area += polygon[i](0)*polygon[i + 1 < polygon.size() ? i + 1 : 0](1) - polygon[i + 1 < polygon.size() ? i + 1 : 0](0)*polygon[i](1); area += polygon[i](0)*polygon[i + 1 < polygon.size() ? i + 1 : 0](1) - polygon[i + 1 < polygon.size() ? i + 1 : 0](0)*polygon[i](1);
area = std::abs(area / 2.f); area = 0.5f * std::abs(area);
if (area < minimal_area) { if (area < area_threshold) {
m_planes.erase(m_planes.begin()+(polygon_id--)); m_planes.erase(m_planes.begin()+(polygon_id--));
continue; continue;
} }
// We check the inner angles and discard polygons with angles smaller than the following threshold
const double angle_threshold = ::cos(10.0 * (double)PI / 180.0);
bool discard = false;
for (unsigned int i = 0; i < polygon.size(); ++i)
{
const Vec3d& prec = polygon[(i == 0) ? polygon.size() - 1 : i - 1];
const Vec3d& curr = polygon[i];
const Vec3d& next = polygon[(i == polygon.size() - 1) ? 0 : i + 1];
if ((prec - curr).normalized().dot((next - curr).normalized()) > angle_threshold)
{
discard = true;
break;
}
}
if (discard)
{
m_planes.erase(m_planes.begin() + (polygon_id--));
continue;
}
// We will shrink the polygon a little bit so it does not touch the object edges: // We will shrink the polygon a little bit so it does not touch the object edges:
Vec3d centroid = std::accumulate(polygon.begin(), polygon.end(), Vec3d(0.0, 0.0, 0.0)); Vec3d centroid = std::accumulate(polygon.begin(), polygon.end(), Vec3d(0.0, 0.0, 0.0));
centroid /= (double)polygon.size(); centroid /= (double)polygon.size();
@ -1511,10 +1504,10 @@ void GLGizmoFlatten::update_planes()
m_source_data.bounding_boxes.clear(); m_source_data.bounding_boxes.clear();
for (const auto& vol : m_model_object->volumes) for (const auto& vol : m_model_object->volumes)
m_source_data.bounding_boxes.push_back(vol->get_convex_hull().bounding_box()); m_source_data.bounding_boxes.push_back(vol->get_convex_hull().bounding_box());
#if !ENABLE_MODELINSTANCE_3D_ROTATION #if !ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
m_source_data.scaling_factor = m_model_object->instances.front()->scaling_factor; m_source_data.scaling_factor = m_model_object->instances.front()->scaling_factor;
m_source_data.rotation = m_model_object->instances.front()->rotation; m_source_data.rotation = m_model_object->instances.front()->rotation;
#endif // !ENABLE_MODELINSTANCE_3D_ROTATION #endif // !ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
const float* first_vertex = m_model_object->volumes.front()->get_convex_hull().first_vertex(); const float* first_vertex = m_model_object->volumes.front()->get_convex_hull().first_vertex();
m_source_data.mesh_first_point = Vec3d((double)first_vertex[0], (double)first_vertex[1], (double)first_vertex[2]); m_source_data.mesh_first_point = Vec3d((double)first_vertex[0], (double)first_vertex[1], (double)first_vertex[2]);
} }
@ -1526,13 +1519,13 @@ bool GLGizmoFlatten::is_plane_update_necessary() const
if (m_state != On || !m_model_object || m_model_object->instances.empty()) if (m_state != On || !m_model_object || m_model_object->instances.empty())
return false; return false;
#if ENABLE_MODELINSTANCE_3D_ROTATION #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
if (m_model_object->volumes.size() != m_source_data.bounding_boxes.size()) if (m_model_object->volumes.size() != m_source_data.bounding_boxes.size())
#else #else
if (m_model_object->volumes.size() != m_source_data.bounding_boxes.size() if (m_model_object->volumes.size() != m_source_data.bounding_boxes.size()
|| m_model_object->instances.front()->scaling_factor != m_source_data.scaling_factor || m_model_object->instances.front()->scaling_factor != m_source_data.scaling_factor
|| m_model_object->instances.front()->rotation != m_source_data.rotation) || m_model_object->instances.front()->rotation != m_source_data.rotation)
#endif // ENABLE_MODELINSTANCE_3D_ROTATION #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
return true; return true;
// now compare the bounding boxes: // now compare the bounding boxes:
@ -1548,12 +1541,13 @@ bool GLGizmoFlatten::is_plane_update_necessary() const
return false; return false;
} }
#if ENABLE_MODELINSTANCE_3D_ROTATION #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
Vec3d GLGizmoFlatten::get_flattening_rotation() const Vec3d GLGizmoFlatten::get_flattening_rotation() const
{ {
// calculates the rotations in model space // calculates the rotations in model space, taking in account the scaling factors
Eigen::Matrix<double, 3, 3, Eigen::DontAlign> m = m_model_object->instances.front()->world_matrix(true, true).matrix().block(0, 0, 3, 3).inverse().transpose();
Eigen::Quaterniond q; Eigen::Quaterniond q;
Vec3d angles = q.setFromTwoVectors(m_normal, -Vec3d::UnitZ()).toRotationMatrix().eulerAngles(2, 1, 0); Vec3d angles = q.setFromTwoVectors(m * m_normal, -Vec3d::UnitZ()).toRotationMatrix().eulerAngles(2, 1, 0);
m_normal = Vec3d::Zero(); m_normal = Vec3d::Zero();
return Vec3d(angles(2), angles(1), angles(0)); return Vec3d(angles(2), angles(1), angles(0));
} }
@ -1563,7 +1557,7 @@ Vec3d GLGizmoFlatten::get_flattening_normal() const {
m_normal = Vec3d::Zero(); m_normal = Vec3d::Zero();
return normal.normalized(); return normal.normalized();
} }
#endif // ENABLE_MODELINSTANCE_3D_ROTATION #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
} // namespace GUI } // namespace GUI
} // namespace Slic3r } // namespace Slic3r

38
src/slic3r/GUI/GLGizmo.hpp
View File

@ -133,7 +133,6 @@ class GLGizmoRotate : public GLGizmoBase
static const float ScaleStepRad; static const float ScaleStepRad;
static const unsigned int ScaleLongEvery; static const unsigned int ScaleLongEvery;
static const float ScaleLongTooth; static const float ScaleLongTooth;
static const float ScaleShortTooth;
static const unsigned int SnapRegionsCount; static const unsigned int SnapRegionsCount;
static const float GrabberOffset; static const float GrabberOffset;
@ -152,6 +151,11 @@ private:
mutable Vec3d m_center; mutable Vec3d m_center;
mutable float m_radius; mutable float m_radius;
mutable float m_snap_coarse_in_radius;
mutable float m_snap_coarse_out_radius;
mutable float m_snap_fine_in_radius;
mutable float m_snap_fine_out_radius;
public: public:
GLGizmoRotate(GLCanvas3D& parent, Axis axis); GLGizmoRotate(GLCanvas3D& parent, Axis axis);
@ -188,7 +192,7 @@ class GLGizmoRotate3D : public GLGizmoBase
public: public:
explicit GLGizmoRotate3D(GLCanvas3D& parent); explicit GLGizmoRotate3D(GLCanvas3D& parent);
#if ENABLE_MODELINSTANCE_3D_ROTATION #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
Vec3d get_rotation() const { return Vec3d(m_gizmos[X].get_angle(), m_gizmos[Y].get_angle(), m_gizmos[Z].get_angle()); } Vec3d get_rotation() const { return Vec3d(m_gizmos[X].get_angle(), m_gizmos[Y].get_angle(), m_gizmos[Z].get_angle()); }
void set_rotation(const Vec3d& rotation) { m_gizmos[X].set_angle(rotation(0)); m_gizmos[Y].set_angle(rotation(1)); m_gizmos[Z].set_angle(rotation(2)); } void set_rotation(const Vec3d& rotation) { m_gizmos[X].set_angle(rotation(0)); m_gizmos[Y].set_angle(rotation(1)); m_gizmos[Z].set_angle(rotation(2)); }
#else #else
@ -200,7 +204,7 @@ public:
double get_angle_z() const { return m_gizmos[Z].get_angle(); } double get_angle_z() const { return m_gizmos[Z].get_angle(); }
void set_angle_z(double angle) { m_gizmos[Z].set_angle(angle); } void set_angle_z(double angle) { m_gizmos[Z].set_angle(angle); }
#endif // ENABLE_MODELINSTANCE_3D_ROTATION #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
protected: protected:
virtual bool on_init(); virtual bool on_init();
@ -271,6 +275,10 @@ class GLGizmoScale3D : public GLGizmoBase
public: public:
explicit GLGizmoScale3D(GLCanvas3D& parent); explicit GLGizmoScale3D(GLCanvas3D& parent);
#if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
const Vec3d& get_scale() const { return m_scale; }
void set_scale(const Vec3d& scale) { m_starting_scale = scale; }
#else
double get_scale_x() const { return m_scale(0); } double get_scale_x() const { return m_scale(0); }
void set_scale_x(double scale) { m_starting_scale(0) = scale; } void set_scale_x(double scale) { m_starting_scale(0) = scale; }
@ -281,6 +289,7 @@ public:
void set_scale_z(double scale) { m_starting_scale(2) = scale; } void set_scale_z(double scale) { m_starting_scale(2) = scale; }
void set_scale(double scale) { m_starting_scale = scale * Vec3d::Ones(); } void set_scale(double scale) { m_starting_scale = scale * Vec3d::Ones(); }
#endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
protected: protected:
virtual bool on_init(); virtual bool on_init();
@ -345,10 +354,10 @@ private:
}; };
struct SourceDataSummary { struct SourceDataSummary {
std::vector<BoundingBoxf3> bounding_boxes; // bounding boxes of convex hulls of individual volumes std::vector<BoundingBoxf3> bounding_boxes; // bounding boxes of convex hulls of individual volumes
#if !ENABLE_MODELINSTANCE_3D_ROTATION #if !ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
float scaling_factor; float scaling_factor;
float rotation; float rotation;
#endif // !ENABLE_MODELINSTANCE_3D_ROTATION #endif // !ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
Vec3d mesh_first_point; Vec3d mesh_first_point;
}; };
@ -356,23 +365,16 @@ private:
SourceDataSummary m_source_data; SourceDataSummary m_source_data;
std::vector<PlaneData> m_planes; std::vector<PlaneData> m_planes;
#if ENABLE_MODELINSTANCE_3D_OFFSET #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
#if ENABLE_MODELINSTANCE_3D_ROTATION
struct InstanceData struct InstanceData
{ {
Vec3d position; Transform3d matrix;
Vec3d rotation; InstanceData(const Transform3d& matrix) : matrix(matrix) {}
double scaling_factor;
InstanceData(const Vec3d& position, const Vec3d& rotation, double scaling_factor) : position(position), rotation(rotation), scaling_factor(scaling_factor) {}
}; };
std::vector<InstanceData> m_instances; std::vector<InstanceData> m_instances;
#else
Pointf3s m_instances_positions;
#endif // ENABLE_MODELINSTANCE_3D_ROTATION
#else #else
std::vector<Vec2d> m_instances_positions; std::vector<Vec2d> m_instances_positions;
#endif // ENABLE_MODELINSTANCE_3D_OFFSET #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
Vec3d m_starting_center; Vec3d m_starting_center;
const ModelObject* m_model_object = nullptr; const ModelObject* m_model_object = nullptr;
@ -383,11 +385,11 @@ public:
explicit GLGizmoFlatten(GLCanvas3D& parent); explicit GLGizmoFlatten(GLCanvas3D& parent);
void set_flattening_data(const ModelObject* model_object); void set_flattening_data(const ModelObject* model_object);
#if ENABLE_MODELINSTANCE_3D_ROTATION #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
Vec3d get_flattening_rotation() const; Vec3d get_flattening_rotation() const;
#else #else
Vec3d get_flattening_normal() const; Vec3d get_flattening_normal() const;
#endif // ENABLE_MODELINSTANCE_3D_ROTATION #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
protected: protected:
virtual bool on_init(); virtual bool on_init();

75
src/slic3r/GUI/GUI_ObjectParts.cpp
View File

@ -1221,6 +1221,12 @@ void load_part( ModelObject* model_object,
} }
for ( auto object : model.objects) { for ( auto object : model.objects) {
Vec3d delta = Vec3d::Zero();
if (model_object->origin_translation != Vec3d::Zero())
{
object->center_around_origin();
delta = model_object->origin_translation - object->origin_translation;
}
for (auto volume : object->volumes) { for (auto volume : object->volumes) {
auto new_volume = model_object->add_volume(*volume); auto new_volume = model_object->add_volume(*volume);
new_volume->set_type(is_modifier ? ModelVolume::PARAMETER_MODIFIER : ModelVolume::MODEL_PART); new_volume->set_type(is_modifier ? ModelVolume::PARAMETER_MODIFIER : ModelVolume::MODEL_PART);
@ -1229,10 +1235,9 @@ void load_part( ModelObject* model_object,
part_names.Add(new_volume->name); part_names.Add(new_volume->name);
// apply the same translation we applied to the object if (delta != Vec3d::Zero())
new_volume->mesh.translate( model_object->origin_translation(0), new_volume->mesh.translate((float)delta(0), (float)delta(1), (float)delta(2));
model_object->origin_translation(1),
model_object->origin_translation(2) );
// set a default extruder value, since user can't add it manually // set a default extruder value, since user can't add it manually
new_volume->config.set_key_value("extruder", new ConfigOptionInt(0)); new_volume->config.set_key_value("extruder", new ConfigOptionInt(0));
@ -1447,12 +1452,12 @@ bool is_splittable_object(const bool split_part)
return false; return false;
TriangleMeshPtrs meshptrs = volume->mesh.split(); TriangleMeshPtrs meshptrs = volume->mesh.split();
if (meshptrs.size() <= 1) { bool splittable = meshptrs.size() > 1;
delete meshptrs.front(); for (TriangleMesh* m : meshptrs)
return false; {
delete m;
} }
return splittable;
return true;
} }
void on_btn_split(const bool split_part) void on_btn_split(const bool split_part)
@ -1746,6 +1751,18 @@ void update_scale_values()
auto instance = (*m_objects)[m_selected_object_id]->instances.front(); auto instance = (*m_objects)[m_selected_object_id]->instances.front();
auto size = (*m_objects)[m_selected_object_id]->instance_bounding_box(0).size(); auto size = (*m_objects)[m_selected_object_id]->instance_bounding_box(0).size();
#if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
if (g_is_percent_scale) {
og->set_value("scale_x", int(instance->get_scaling_factor(X) * 100));
og->set_value("scale_y", int(instance->get_scaling_factor(Y) * 100));
og->set_value("scale_z", int(instance->get_scaling_factor(Z) * 100));
}
else {
og->set_value("scale_x", int(instance->get_scaling_factor(X) * size(0) + 0.5));
og->set_value("scale_y", int(instance->get_scaling_factor(Y) * size(1) + 0.5));
og->set_value("scale_z", int(instance->get_scaling_factor(Z) * size(2) + 0.5));
}
#else
if (g_is_percent_scale) { if (g_is_percent_scale) {
auto scale = instance->scaling_factor * 100.0; auto scale = instance->scaling_factor * 100.0;
og->set_value("scale_x", int(scale)); og->set_value("scale_x", int(scale));
@ -1757,6 +1774,7 @@ void update_scale_values()
og->set_value("scale_y", int(instance->scaling_factor * size(1) + 0.5)); og->set_value("scale_y", int(instance->scaling_factor * size(1) + 0.5));
og->set_value("scale_z", int(instance->scaling_factor * size(2) + 0.5)); og->set_value("scale_z", int(instance->scaling_factor * size(2) + 0.5));
} }
#endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
} }
void update_position_values() void update_position_values()
@ -1764,7 +1782,7 @@ void update_position_values()
auto og = get_optgroup(ogFrequentlyObjectSettings); auto og = get_optgroup(ogFrequentlyObjectSettings);
auto instance = (*m_objects)[m_selected_object_id]->instances.front(); auto instance = (*m_objects)[m_selected_object_id]->instances.front();
#if ENABLE_MODELINSTANCE_3D_OFFSET #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
og->set_value("position_x", int(instance->get_offset(X))); og->set_value("position_x", int(instance->get_offset(X)));
og->set_value("position_y", int(instance->get_offset(Y))); og->set_value("position_y", int(instance->get_offset(Y)));
og->set_value("position_z", int(instance->get_offset(Z))); og->set_value("position_z", int(instance->get_offset(Z)));
@ -1772,7 +1790,7 @@ void update_position_values()
og->set_value("position_x", int(instance->offset(0))); og->set_value("position_x", int(instance->offset(0)));
og->set_value("position_y", int(instance->offset(1))); og->set_value("position_y", int(instance->offset(1)));
og->set_value("position_z", 0); og->set_value("position_z", 0);
#endif // ENABLE_MODELINSTANCE_3D_OFFSET #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
} }
void update_position_values(const Vec3d& position) void update_position_values(const Vec3d& position)
@ -1784,6 +1802,24 @@ void update_position_values(const Vec3d& position)
og->set_value("position_z", int(position(2))); og->set_value("position_z", int(position(2)));
} }
#if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
void update_scale_values(const Vec3d& scaling_factor)
{
auto og = get_optgroup(ogFrequentlyObjectSettings);
// this is temporary
// to be able to update the values as size
// we need to store somewhere the original size
// or have it passed as parameter
if (!g_is_percent_scale)
og->set_value("scale_unit", _("%"));
auto scale = scaling_factor * 100.0;
og->set_value("scale_x", int(scale(0)));
og->set_value("scale_y", int(scale(1)));
og->set_value("scale_z", int(scale(2)));
}
#else
void update_scale_values(double scaling_factor) void update_scale_values(double scaling_factor)
{ {
auto og = get_optgroup(ogFrequentlyObjectSettings); auto og = get_optgroup(ogFrequentlyObjectSettings);
@ -1800,10 +1836,11 @@ void update_scale_values(double scaling_factor)
og->set_value("scale_y", int(scale)); og->set_value("scale_y", int(scale));
og->set_value("scale_z", int(scale)); og->set_value("scale_z", int(scale));
} }
#endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
void update_rotation_values() void update_rotation_values()
{ {
#if ENABLE_MODELINSTANCE_3D_ROTATION #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
update_rotation_value((*m_objects)[m_selected_object_id]->instances.front()->get_rotation()); update_rotation_value((*m_objects)[m_selected_object_id]->instances.front()->get_rotation());
#else #else
auto og = get_optgroup(ogFrequentlyObjectSettings); auto og = get_optgroup(ogFrequentlyObjectSettings);
@ -1811,7 +1848,7 @@ void update_rotation_values()
og->set_value("rotation_x", 0); og->set_value("rotation_x", 0);
og->set_value("rotation_y", 0); og->set_value("rotation_y", 0);
og->set_value("rotation_z", int(Geometry::rad2deg(instance->rotation))); og->set_value("rotation_z", int(Geometry::rad2deg(instance->rotation)));
#endif // ENABLE_MODELINSTANCE_3D_ROTATION #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
} }
void update_rotation_value(double angle, Axis axis) void update_rotation_value(double angle, Axis axis)
@ -1838,18 +1875,18 @@ void update_rotation_value(double angle, Axis axis)
} }
} }
og->set_value(axis_str, int(Geometry::rad2deg(angle))); og->set_value(axis_str, round_nearest(int(Geometry::rad2deg(angle)), 0));
} }
#if ENABLE_MODELINSTANCE_3D_ROTATION #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
void update_rotation_value(const Vec3d& rotation) void update_rotation_value(const Vec3d& rotation)
{ {
auto og = get_optgroup(ogFrequentlyObjectSettings); auto og = get_optgroup(ogFrequentlyObjectSettings);
og->set_value("rotation_x", int(Geometry::rad2deg(rotation(0)))); og->set_value("rotation_x", int(round_nearest(Geometry::rad2deg(rotation(0)), 0)));
og->set_value("rotation_y", int(Geometry::rad2deg(rotation(1)))); og->set_value("rotation_y", int(round_nearest(Geometry::rad2deg(rotation(1)), 0)));
og->set_value("rotation_z", int(Geometry::rad2deg(rotation(2)))); og->set_value("rotation_z", int(round_nearest(Geometry::rad2deg(rotation(2)), 0)));
} }
#endif // ENABLE_MODELINSTANCE_3D_ROTATION #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
void set_uniform_scaling(const bool uniform_scale) void set_uniform_scaling(const bool uniform_scale)
{ {

8
src/slic3r/GUI/GUI_ObjectParts.hpp
View File

@ -119,14 +119,18 @@ void update_position_values();
void update_position_values(const Vec3d& position); void update_position_values(const Vec3d& position);
// update scale values after scale unit changing or "gizmos" // update scale values after scale unit changing or "gizmos"
void update_scale_values(); void update_scale_values();
#if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
void update_scale_values(const Vec3d& scaling_factor);
#else
void update_scale_values(double scaling_factor); void update_scale_values(double scaling_factor);
#endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
// update rotation values object selection changing // update rotation values object selection changing
void update_rotation_values(); void update_rotation_values();
// update rotation value after "gizmos" // update rotation value after "gizmos"
void update_rotation_value(double angle, Axis axis); void update_rotation_value(double angle, Axis axis);
#if ENABLE_MODELINSTANCE_3D_ROTATION #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
void update_rotation_value(const Vec3d& rotation); void update_rotation_value(const Vec3d& rotation);
#endif // ENABLE_MODELINSTANCE_3D_ROTATION #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
void set_uniform_scaling(const bool uniform_scale); void set_uniform_scaling(const bool uniform_scale);
void on_begin_drag(wxDataViewEvent &event); void on_begin_drag(wxDataViewEvent &event);

2
src/slic3r/GUI/callback.hpp
View File

@ -22,6 +22,8 @@ public:
void call(double, double) const {} void call(double, double) const {}
void call(double, double, double) const {} void call(double, double, double) const {}
void call(double, double, double, double) const {} void call(double, double, double, double) const {}
void call(double, double, double, double, double) const {}
void call(double, double, double, double, double, double) const {}
void call(bool b) const {} void call(bool b) const {}
}; };

20
xs/src/callback.cpp
View File

@ -149,6 +149,26 @@ void PerlCallback::call(double a, double b, double c, double d) const
LEAVE; LEAVE;
} }
void PerlCallback::call(double a, double b, double c, double d, double e, double f) const
{
if (!m_callback)
return;
dSP;
ENTER;
SAVETMPS;
PUSHMARK(SP);
XPUSHs(sv_2mortal(newSVnv(a)));
XPUSHs(sv_2mortal(newSVnv(b)));
XPUSHs(sv_2mortal(newSVnv(c)));
XPUSHs(sv_2mortal(newSVnv(d)));
XPUSHs(sv_2mortal(newSVnv(e)));
XPUSHs(sv_2mortal(newSVnv(f)));
PUTBACK;
perl_call_sv(SvRV((SV*)m_callback), G_DISCARD);
FREETMPS;
LEAVE;
}
void PerlCallback::call(bool b) const void PerlCallback::call(bool b) const
{ {
call(b ? 1 : 0); call(b ? 1 : 0);

1
xs/src/callback.hpp
View File

@ -22,6 +22,7 @@ public:
void call(double a, double b) const; void call(double a, double b) const;
void call(double a, double b, double c) const; void call(double a, double b, double c) const;
void call(double a, double b, double c, double d) const; void call(double a, double b, double c, double d) const;
void call(double a, double b, double c, double d, double e, double f) const;
void call(bool b) const; void call(bool b) const;
private: private:
void *m_callback; void *m_callback;

14
xs/xsp/GUI_3DScene.xsp
View File

@ -644,6 +644,13 @@ register_on_gizmo_scale_uniformly_callback(canvas, callback)
CODE: CODE:
_3DScene::register_on_gizmo_scale_uniformly_callback((wxGLCanvas*)wxPli_sv_2_object(aTHX_ canvas, "Wx::GLCanvas"), (void*)callback); _3DScene::register_on_gizmo_scale_uniformly_callback((wxGLCanvas*)wxPli_sv_2_object(aTHX_ canvas, "Wx::GLCanvas"), (void*)callback);
void
register_on_gizmo_scale_3D_callback(canvas, callback)
SV *canvas;
SV *callback;
CODE:
_3DScene::register_on_gizmo_scale_3D_callback((wxGLCanvas*)wxPli_sv_2_object(aTHX_ canvas, "Wx::GLCanvas"), (void*)callback);
void void
register_on_gizmo_rotate_callback(canvas, callback) register_on_gizmo_rotate_callback(canvas, callback)
SV *canvas; SV *canvas;
@ -679,6 +686,13 @@ register_on_update_geometry_info_callback(canvas, callback)
CODE: CODE:
_3DScene::register_on_update_geometry_info_callback((wxGLCanvas*)wxPli_sv_2_object(aTHX_ canvas, "Wx::GLCanvas"), (void*)callback); _3DScene::register_on_update_geometry_info_callback((wxGLCanvas*)wxPli_sv_2_object(aTHX_ canvas, "Wx::GLCanvas"), (void*)callback);
void
register_on_update_geometry_3D_info_callback(canvas, callback)
SV *canvas;
SV *callback;
CODE:
_3DScene::register_on_update_geometry_3D_info_callback((wxGLCanvas*)wxPli_sv_2_object(aTHX_ canvas, "Wx::GLCanvas"), (void*)callback);
void void
register_action_add_callback(canvas, callback) register_action_add_callback(canvas, callback)
SV *canvas; SV *canvas;

50
xs/xsp/Model.xsp
View File

@ -295,46 +295,52 @@ ModelMaterial::attributes()
Ref<ModelObject> object() Ref<ModelObject> object()
%code%{ RETVAL = THIS->get_object(); %}; %code%{ RETVAL = THIS->get_object(); %};
#if ENABLE_MODELINSTANCE_3D_ROTATION #if ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
double rotation() Vec3d* rotation()
%code%{ RETVAL = THIS->get_rotation(Z); %}; %code%{ RETVAL = new Vec3d(THIS->get_rotation(X), THIS->get_rotation(Y), THIS->get_rotation(Z)); %};
#else
double rotation() Vec3d* scaling_factor()
%code%{ RETVAL = THIS->rotation; %}; %code%{ RETVAL = new Vec3d(THIS->get_scaling_factor(X), THIS->get_scaling_factor(Y), THIS->get_scaling_factor(Z)); %};
#endif // ENABLE_MODELINSTANCE_3D_ROTATION
double scaling_factor()
%code%{ RETVAL = THIS->scaling_factor; %};
#if ENABLE_MODELINSTANCE_3D_OFFSET
Vec2d* offset() Vec2d* offset()
%code%{ RETVAL = new Vec2d(THIS->get_offset(X), THIS->get_offset(Y)); %}; %code%{ RETVAL = new Vec2d(THIS->get_offset(X), THIS->get_offset(Y)); %};
#else
Ref<Vec2d> offset()
%code%{ RETVAL = &THIS->offset; %};
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
#if ENABLE_MODELINSTANCE_3D_ROTATION
void set_rotation(double val) void set_rotation(double val)
%code%{ THIS->set_rotation(Z, val); THIS->get_object()->invalidate_bounding_box(); %}; %code%{ THIS->set_rotation(Z, val); THIS->get_object()->invalidate_bounding_box(); %};
void set_rotations(Vec3d *rotation) void set_rotations(Vec3d *rotation)
%code%{ THIS->set_rotation(*rotation); THIS->get_object()->invalidate_bounding_box(); %}; %code%{ THIS->set_rotation(*rotation); THIS->get_object()->invalidate_bounding_box(); %};
#else
void set_rotation(double val)
%code%{ THIS->rotation = val; THIS->get_object()->invalidate_bounding_box(); %};
#endif // ENABLE_MODELINSTANCE_3D_ROTATION
void set_scaling_factor(double val) void set_scaling_factor(double val)
%code%{ THIS->scaling_factor = val; THIS->get_object()->invalidate_bounding_box(); %}; %code%{ THIS->set_scaling_factor(X, val); THIS->set_scaling_factor(Y, val); THIS->set_scaling_factor(Z, val); THIS->get_object()->invalidate_bounding_box(); %};
#if ENABLE_MODELINSTANCE_3D_OFFSET
void set_scaling_factors(Vec3d *scale)
%code%{ THIS->set_scaling_factor(*scale); THIS->get_object()->invalidate_bounding_box(); %};
void set_offset(Vec2d *offset) void set_offset(Vec2d *offset)
%code%{ %code%{
THIS->set_offset(X, (*offset)(0)); THIS->set_offset(X, (*offset)(0));
THIS->set_offset(Y, (*offset)(1)); THIS->set_offset(Y, (*offset)(1));
%}; %};
#else #else
double rotation()
%code%{ RETVAL = THIS->rotation; %};
double scaling_factor()
%code%{ RETVAL = THIS->scaling_factor; %};
Ref<Vec2d> offset()
%code%{ RETVAL = &THIS->offset; %};
void set_rotation(double val)
%code%{ THIS->rotation = val; THIS->get_object()->invalidate_bounding_box(); %};
void set_scaling_factor(double val)
%code%{ THIS->scaling_factor = val; THIS->get_object()->invalidate_bounding_box(); %};
void set_offset(Vec2d *offset) void set_offset(Vec2d *offset)
%code%{ THIS->offset = *offset; %}; %code%{ THIS->offset = *offset; %};
#endif // ENABLE_MODELINSTANCE_3D_OFFSET #endif // ENABLE_MODELINSTANCE_3D_FULL_TRANSFORM
void transform_mesh(TriangleMesh* mesh, bool dont_translate = false) const; void transform_mesh(TriangleMesh* mesh, bool dont_translate = false) const;
void transform_polygon(Polygon* polygon) const; void transform_polygon(Polygon* polygon) const;