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

Code cleanup

Browse Source
This commit is contained in:
Enrico Turri 2018-09-13 16:08:19 +02:00
parent af19713a27
commit 3faaff85d5
14 changed files with 2 additions and 164 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
xs/src/libslic3r/Format/3mf.cpp
View File

@ -1252,17 +1252,13 @@ namespace Slic3r {
// we extract from the given matrix only the values currently used
// translation
//################################################################################################################################
#if ENABLE_MODELINSTANCE_3D_OFFSET
Vec3d offset(transform(0, 3), transform(1, 3), transform(2, 3));
#else
//################################################################################################################################
double offset_x = transform(0, 3);
double offset_y = transform(1, 3);
double offset_z = transform(2, 3);
//################################################################################################################################
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
//################################################################################################################################
// scale
double sx = ::sqrt(sqr(transform(0, 0)) + sqr(transform(1, 0)) + sqr(transform(2, 0)));
@ -1295,16 +1291,12 @@ namespace Slic3r {
double angle_z = (rotation.axis() == Vec3d::UnitZ()) ? rotation.angle() : -rotation.angle();
//################################################################################################################################
#if ENABLE_MODELINSTANCE_3D_OFFSET
instance.set_offset(offset);
#else
//################################################################################################################################
instance.offset(0) = offset_x;
instance.offset(1) = offset_y;
//################################################################################################################################
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
//################################################################################################################################
instance.scaling_factor = sx;
instance.rotation = angle_z;
}

30
xs/src/libslic3r/Format/AMF.cpp
View File

@ -29,16 +29,12 @@
// VERSION NUMBERS
// 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.
//################################################################################################################################
#if ENABLE_MODELINSTANCE_3D_OFFSET
// 2 : Added z component of offset.
const unsigned int VERSION_AMF = 2;
#else
//################################################################################################################################
const unsigned int VERSION_AMF = 1;
//################################################################################################################################
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
//################################################################################################################################
const char* SLIC3RPE_AMF_VERSION = "slic3rpe_amf_version";
const char* SLIC3R_CONFIG_TYPE = "slic3rpe_config";
@ -128,39 +124,31 @@ struct AMFParserContext
NODE_TYPE_INSTANCE, // amf/constellation/instance
NODE_TYPE_DELTAX, // amf/constellation/instance/deltax
NODE_TYPE_DELTAY, // amf/constellation/instance/deltay
//################################################################################################################################
#if ENABLE_MODELINSTANCE_3D_OFFSET
NODE_TYPE_DELTAZ, // amf/constellation/instance/deltaz
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
//################################################################################################################################
NODE_TYPE_RZ, // amf/constellation/instance/rz
NODE_TYPE_SCALE, // amf/constellation/instance/scale
NODE_TYPE_METADATA, // anywhere under amf/*/metadata
};
struct Instance {
//################################################################################################################################
#if ENABLE_MODELINSTANCE_3D_OFFSET
Instance() : deltax_set(false), deltay_set(false), deltaz_set(false), rz_set(false), scale_set(false) {}
#else
//################################################################################################################################
Instance() : deltax_set(false), deltay_set(false), rz_set(false), scale_set(false) {}
//################################################################################################################################
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
//################################################################################################################################
// Shift in the X axis.
float deltax;
bool deltax_set;
// Shift in the Y axis.
float deltay;
bool deltay_set;
//################################################################################################################################
#if ENABLE_MODELINSTANCE_3D_OFFSET
// Shift in the Z axis.
float deltaz;
bool deltaz_set;
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
//################################################################################################################################
// Rotation around the Z axis.
float rz;
bool rz_set;
@ -283,12 +271,10 @@ void AMFParserContext::startElement(const char *name, const char **atts)
node_type_new = NODE_TYPE_DELTAX;
else if (strcmp(name, "deltay") == 0)
node_type_new = NODE_TYPE_DELTAY;
//################################################################################################################################
#if ENABLE_MODELINSTANCE_3D_OFFSET
else if (strcmp(name, "deltaz") == 0)
node_type_new = NODE_TYPE_DELTAZ;
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
//################################################################################################################################
else if (strcmp(name, "rz") == 0)
node_type_new = NODE_TYPE_RZ;
else if (strcmp(name, "scale") == 0)
@ -349,7 +335,6 @@ void AMFParserContext::characters(const XML_Char *s, int len)
{
switch (m_path.size()) {
case 4:
//################################################################################################################################
#if ENABLE_MODELINSTANCE_3D_OFFSET
if (m_path.back() == NODE_TYPE_DELTAX ||
m_path.back() == NODE_TYPE_DELTAY ||
@ -357,11 +342,8 @@ void AMFParserContext::characters(const XML_Char *s, int len)
m_path.back() == NODE_TYPE_RZ ||
m_path.back() == NODE_TYPE_SCALE)
#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)
//################################################################################################################################
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
//################################################################################################################################
m_value[0].append(s, len);
break;
case 6:
@ -401,7 +383,6 @@ void AMFParserContext::endElement(const char * /* name */)
m_instance->deltay_set = true;
m_value[0].clear();
break;
//################################################################################################################################
#if ENABLE_MODELINSTANCE_3D_OFFSET
case NODE_TYPE_DELTAZ:
assert(m_instance);
@ -410,7 +391,6 @@ void AMFParserContext::endElement(const char * /* name */)
m_value[0].clear();
break;
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
//################################################################################################################################
case NODE_TYPE_RZ:
assert(m_instance);
m_instance->rz = float(atof(m_value[0].c_str()));
@ -555,16 +535,12 @@ void AMFParserContext::endDocument()
for (const Instance &instance : object.second.instances)
if (instance.deltax_set && instance.deltay_set) {
ModelInstance *mi = m_model.objects[object.second.idx]->add_instance();
//################################################################################################################################
#if ENABLE_MODELINSTANCE_3D_OFFSET
mi->set_offset(Vec3d((double)instance.deltax, (double)instance.deltay, (double)instance.deltaz));
#else
//################################################################################################################################
mi->offset(0) = instance.deltax;
mi->offset(1) = instance.deltay;
//################################################################################################################################
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
//################################################################################################################################
mi->rotation = instance.rz_set ? instance.rz : 0.f;
mi->scaling_factor = instance.scale_set ? instance.scale : 1.f;
}
@ -865,27 +841,21 @@ bool store_amf(const char *path, Model *model, Print* print, bool export_print_c
" <instance objectid=\"" PRINTF_ZU "\">\n"
" <deltax>%lf</deltax>\n"
" <deltay>%lf</deltay>\n"
//################################################################################################################################
#if ENABLE_MODELINSTANCE_3D_OFFSET
" <deltaz>%lf</deltaz>\n"
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
//################################################################################################################################
" <rz>%lf</rz>\n"
" <scale>%lf</scale>\n"
" </instance>\n",
object_id,
//################################################################################################################################
#if ENABLE_MODELINSTANCE_3D_OFFSET
instance->get_offset(X),
instance->get_offset(Y),
instance->get_offset(Z),
#else
//################################################################################################################################
instance->offset(0),
instance->offset(1),
//################################################################################################################################
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
//################################################################################################################################
instance->rotation,
instance->scaling_factor);
//FIXME missing instance->scaling_factor

12
xs/src/libslic3r/Format/PRUS.cpp
View File

@ -166,15 +166,11 @@ bool load_prus(const char *path, Model *model)
float trafo[3][4] = { 0 };
double instance_rotation = 0.;
double instance_scaling_factor = 1.f;
//################################################################################################################################
#if ENABLE_MODELINSTANCE_3D_OFFSET
Vec3d instance_offset = Vec3d::Zero();
#else
//################################################################################################################################
Vec2d instance_offset(0., 0.);
//################################################################################################################################
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
//################################################################################################################################
bool trafo_set = false;
unsigned int group_id = (unsigned int)-1;
unsigned int extruder_id = (unsigned int)-1;
@ -215,16 +211,12 @@ bool load_prus(const char *path, Model *model)
for (size_t c = 0; c < 3; ++ c)
trafo[r][c] += mat_trafo(r, c);
}
//################################################################################################################################
#if ENABLE_MODELINSTANCE_3D_OFFSET
instance_offset = Vec3d((double)(position[0] - zero[0]), (double)(position[1] - zero[1]), (double)(position[2] - zero[2]));
#else
//################################################################################################################################
instance_offset(0) = position[0] - zero[0];
instance_offset(1) = position[1] - zero[1];
//################################################################################################################################
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
//################################################################################################################################
trafo[2][3] = position[2] / instance_scaling_factor;
trafo_set = true;
}
@ -376,15 +368,11 @@ bool load_prus(const char *path, Model *model)
ModelInstance *instance = model_object->add_instance();
instance->rotation = instance_rotation;
instance->scaling_factor = instance_scaling_factor;
//################################################################################################################################
#if ENABLE_MODELINSTANCE_3D_OFFSET
instance->set_offset(instance_offset);
#else
//################################################################################################################################
instance->offset = instance_offset;
//################################################################################################################################
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
//################################################################################################################################
++num_models;
if (group_id != (size_t)-1)
group_to_model_object[group_id] = model_object;

38
xs/src/libslic3r/Model.cpp
View File

@ -242,27 +242,19 @@ void Model::center_instances_around_point(const Vec2d &point)
for (size_t i = 0; i < o->instances.size(); ++ i)
bb.merge(o->instance_bounding_box(i, false));
//################################################################################################################################
#if ENABLE_MODELINSTANCE_3D_OFFSET
Vec2d shift2 = point - to_2d(bb.center());
Vec3d shift3 = Vec3d(shift2(0), shift2(1), 0.0);
#else
//################################################################################################################################
Vec2d shift = point - 0.5 * to_2d(bb.size()) - to_2d(bb.min);
//################################################################################################################################
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
//################################################################################################################################
for (ModelObject *o : this->objects) {
for (ModelInstance *i : o->instances)
//################################################################################################################################
#if ENABLE_MODELINSTANCE_3D_OFFSET
i->set_offset(i->get_offset() + shift3);
#else
//################################################################################################################################
i->offset += shift;
//################################################################################################################################
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
//################################################################################################################################
o->invalidate_bounding_box();
}
}
@ -328,16 +320,12 @@ bool Model::arrange_objects(coordf_t dist, const BoundingBoxf* bb)
size_t idx = 0;
for (ModelObject *o : this->objects) {
for (ModelInstance *i : o->instances) {
//################################################################################################################################
#if ENABLE_MODELINSTANCE_3D_OFFSET
Vec2d offset_xy = positions[idx] - instance_centers[idx];
i->set_offset(Vec3d(offset_xy(0), offset_xy(1), i->get_offset(Z)));
#else
//################################################################################################################################
i->offset = positions[idx] - instance_centers[idx];
//################################################################################################################################
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
//################################################################################################################################
++idx;
}
o->invalidate_bounding_box();
@ -362,15 +350,11 @@ void Model::duplicate(size_t copies_num, coordf_t dist, const BoundingBoxf* bb)
for (const ModelInstance *i : instances) {
for (const Vec2d &pos : positions) {
ModelInstance *instance = o->add_instance(*i);
//################################################################################################################################
#if ENABLE_MODELINSTANCE_3D_OFFSET
instance->set_offset(instance->get_offset() + Vec3d(pos(0), pos(1), 0.0));
#else
//################################################################################################################################
instance->offset += pos;
//################################################################################################################################
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
//################################################################################################################################
}
}
o->invalidate_bounding_box();
@ -400,29 +384,21 @@ void Model::duplicate_objects_grid(size_t x, size_t y, coordf_t dist)
ModelObject* object = this->objects.front();
object->clear_instances();
//################################################################################################################################
#if ENABLE_MODELINSTANCE_3D_OFFSET
Vec3d ext_size = object->bounding_box().size() + dist * Vec3d::Ones();
#else
//################################################################################################################################
Vec3d size = object->bounding_box().size();
//################################################################################################################################
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
//################################################################################################################################
for (size_t x_copy = 1; x_copy <= x; ++x_copy) {
for (size_t y_copy = 1; y_copy <= y; ++y_copy) {
ModelInstance* instance = object->add_instance();
//################################################################################################################################
#if ENABLE_MODELINSTANCE_3D_OFFSET
instance->set_offset(Vec3d(ext_size(0) * (double)(x_copy - 1), ext_size(1) * (double)(y_copy - 1), 0.0));
#else
//################################################################################################################################
instance->offset(0) = (size(0) + dist) * (x_copy - 1);
instance->offset(1) = (size(1) + dist) * (y_copy - 1);
//################################################################################################################################
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
//################################################################################################################################
}
}
}
@ -726,27 +702,21 @@ void ModelObject::center_around_origin()
this->translate(shift);
this->origin_translation += shift;
//################################################################################################################################
#if ENABLE_MODELINSTANCE_3D_OFFSET
// set z to zero, translation in z has already been done within the mesh
shift(2) = 0.0;
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
//################################################################################################################################
if (!this->instances.empty()) {
for (ModelInstance *i : this->instances) {
// apply rotation and scaling to vector as well before translating instance,
// in order to leave final position unaltered
//################################################################################################################################
#if ENABLE_MODELINSTANCE_3D_OFFSET
i->set_offset(i->get_offset() + i->transform_vector(-shift, true));
#else
//################################################################################################################################
Vec3d i_shift = i->world_matrix(true) * shift;
i->offset -= to_2d(i_shift);
//################################################################################################################################
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
//################################################################################################################################
}
this->invalidate_bounding_box();
}
@ -1069,17 +1039,13 @@ BoundingBoxf3 ModelInstance::transform_mesh_bounding_box(const TriangleMesh* mes
}
// Translate the bounding box.
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.max.data()) += this->offset;
//################################################################################################################################
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
//################################################################################################################################
}
}
return bbox;
@ -1106,15 +1072,11 @@ Transform3d ModelInstance::world_matrix(bool dont_translate, bool dont_rotate, b
Transform3d m = Transform3d::Identity();
if (!dont_translate)
//################################################################################################################################
#if ENABLE_MODELINSTANCE_3D_OFFSET
m.translate(m_offset);
#else
//################################################################################################################################
m.translate(Vec3d(offset(0), offset(1), 0.0));
//################################################################################################################################
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
//################################################################################################################################
if (!dont_rotate)
m.rotate(Eigen::AngleAxisd(rotation, Vec3d::UnitZ()));

14
xs/src/libslic3r/Model.hpp
View File

@ -224,41 +224,31 @@ public:
friend class ModelObject;
//################################################################################################################################
#if ENABLE_MODELINSTANCE_3D_OFFSET
private:
Vec3d m_offset; // in unscaled coordinates
public:
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
//################################################################################################################################
double rotation; // Rotation around the Z axis, in radians around mesh center point
double scaling_factor;
//################################################################################################################################
#if !ENABLE_MODELINSTANCE_3D_OFFSET
//################################################################################################################################
Vec2d offset; // in unscaled coordinates
//################################################################################################################################
#endif // !ENABLE_MODELINSTANCE_3D_OFFSET
//################################################################################################################################
// 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;
ModelObject* get_object() const { return this->object; }
//################################################################################################################################
#if ENABLE_MODELINSTANCE_3D_OFFSET
const Vec3d& get_offset() const { return m_offset; }
double get_offset(Axis axis) const { return m_offset(axis); }
void set_offset(const Vec3d& offset) { m_offset = offset; }
void set_offset(Axis axis, double offset) { m_offset(axis) = offset; }
// void add_to_offset(const Vec3d& shift) { m_offset += shift; }
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
//################################################################################################################################
// To be called on an external mesh
void transform_mesh(TriangleMesh* mesh, bool dont_translate = false) const;
@ -279,19 +269,15 @@ private:
// Parent object, owning this instance.
ModelObject* object;
//################################################################################################################################
#if ENABLE_MODELINSTANCE_3D_OFFSET
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) {}
#else
//################################################################################################################################
ModelInstance(ModelObject *object) : rotation(0), scaling_factor(1), offset(Vec2d::Zero()), object(object), print_volume_state(PVS_Inside) {}
ModelInstance(ModelObject *object, const ModelInstance &other) :
rotation(other.rotation), scaling_factor(other.scaling_factor), offset(other.offset), object(object), print_volume_state(PVS_Inside) {}
//################################################################################################################################
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
//################################################################################################################################
};

12
xs/src/libslic3r/ModelArrange.hpp
View File

@ -517,17 +517,13 @@ ShapeData2D projectModelFromTop(const Slic3r::Model &model) {
if(item.vertexCount() > 3) {
item.rotation(objinst->rotation);
item.translation( {
//################################################################################################################################
#if ENABLE_MODELINSTANCE_3D_OFFSET
ClipperLib::cInt(objinst->get_offset(X) / SCALING_FACTOR),
ClipperLib::cInt(objinst->get_offset(Y) / SCALING_FACTOR)
#else
//################################################################################################################################
ClipperLib::cInt(objinst->offset(0)/SCALING_FACTOR),
ClipperLib::cInt(objinst->offset(1)/SCALING_FACTOR)
//################################################################################################################################
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
//################################################################################################################################
});
ret.emplace_back(objinst, item);
}
@ -664,27 +660,19 @@ void applyResult(
// appropriately
auto off = item.translation();
Radians rot = item.rotation();
//################################################################################################################################
#if ENABLE_MODELINSTANCE_3D_OFFSET
Vec3d foff(off.X*SCALING_FACTOR + batch_offset, off.Y*SCALING_FACTOR, 0.0);
#else
//################################################################################################################################
Vec2d foff(off.X*SCALING_FACTOR + batch_offset, off.Y*SCALING_FACTOR);
//################################################################################################################################
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
//################################################################################################################################
// write the tranformation data into the model instance
inst_ptr->rotation = rot;
//################################################################################################################################
#if ENABLE_MODELINSTANCE_3D_OFFSET
inst_ptr->set_offset(foff);
#else
//################################################################################################################################
inst_ptr->offset = foff;
//################################################################################################################################
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
//################################################################################################################################
}
}

4
xs/src/libslic3r/PrintObject.cpp
View File

@ -102,7 +102,6 @@ bool PrintObject::reload_model_instances()
copies.reserve(this->_model_object->instances.size());
for (const ModelInstance *mi : this->_model_object->instances)
{
//################################################################################################################################
#if ENABLE_MODELINSTANCE_3D_OFFSET
if (mi->is_printable())
{
@ -110,12 +109,9 @@ bool PrintObject::reload_model_instances()
copies.emplace_back(Point::new_scale(offset(0), offset(1)));
}
#else
//################################################################################################################################
if (mi->is_printable())
copies.emplace_back(Point::new_scale(mi->offset(0), mi->offset(1)));
//################################################################################################################################
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
//################################################################################################################################
}
return this->set_copies(copies);
}

2
xs/src/libslic3r/libslic3r.h
View File

@ -13,9 +13,7 @@
#include <vector>
#include <boost/thread.hpp>
//################################################################################################################################
#include "Technologies.hpp"
//################################################################################################################################
#define SLIC3R_FORK_NAME "Slic3r Prusa Edition"
#define SLIC3R_VERSION "1.41.0"

4
xs/src/slic3r/GUI/3DScene.cpp
View File

@ -684,15 +684,11 @@ std::vector<int> GLVolumeCollection::load_object(
}
v.is_modifier = model_volume->modifier;
v.shader_outside_printer_detection_enabled = !model_volume->modifier;
//################################################################################################################################
#if ENABLE_MODELINSTANCE_3D_OFFSET
v.set_offset(instance->get_offset());
#else
//################################################################################################################################
v.set_offset(Vec3d(instance->offset(0), instance->offset(1), 0.0));
//################################################################################################################################
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
//################################################################################################################################
v.set_rotation(instance->rotation);
v.set_scaling_factor(instance->scaling_factor);
}

10
xs/src/slic3r/GUI/GLCanvas3D.cpp
View File

@ -1140,8 +1140,10 @@ bool GLCanvas3D::Gizmos::init(GLCanvas3D& parent)
if (!gizmo->init())
return false;
#if !ENABLE_MODELINSTANCE_3D_OFFSET
// temporary disable z grabber
gizmo->disable_grabber(2);
#endif // !ENABLE_MODELINSTANCE_3D_OFFSET
m_gizmos.insert(GizmosMap::value_type(Move, gizmo));
@ -2375,15 +2377,11 @@ void GLCanvas3D::update_gizmos_data()
ModelInstance* model_instance = model_object->instances[0];
if (model_instance != nullptr)
{
//################################################################################################################################
#if ENABLE_MODELINSTANCE_3D_OFFSET
m_gizmos.set_position(model_instance->get_offset());
#else
//################################################################################################################################
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);
m_gizmos.set_angle_z(model_instance->rotation);
m_gizmos.set_flattening_data(model_object);
@ -5363,16 +5361,12 @@ void GLCanvas3D::_on_move(const std::vector<int>& volume_idxs)
ModelObject* model_object = m_model->objects[obj_idx];
if (model_object != nullptr)
{
//################################################################################################################################
#if ENABLE_MODELINSTANCE_3D_OFFSET
model_object->instances[instance_idx]->set_offset(volume->get_offset());
#else
//################################################################################################################################
const Vec3d& offset = volume->get_offset();
model_object->instances[instance_idx]->offset = Vec2d(offset(0), offset(1));
//################################################################################################################################
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
//################################################################################################################################
model_object->invalidate_bounding_box();
update_position_values();
object_moved = true;

20
xs/src/slic3r/GUI/GLGizmo.cpp
View File

@ -1233,27 +1233,19 @@ void GLGizmoFlatten::on_render(const BoundingBoxf3& box) const
else
::glColor4f(0.9f, 0.9f, 0.9f, 0.5f);
//################################################################################################################################
#if ENABLE_MODELINSTANCE_3D_OFFSET
for (Vec3d offset : m_instances_positions) {
offset += dragged_offset;
#else
//################################################################################################################################
for (Vec2d offset : m_instances_positions) {
offset += to_2d(dragged_offset);
//################################################################################################################################
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
//################################################################################################################################
::glPushMatrix();
//################################################################################################################################
#if ENABLE_MODELINSTANCE_3D_OFFSET
::glTranslated(offset(0), offset(1), offset(2));
#else
//################################################################################################################################
::glTranslatef((GLfloat)offset(0), (GLfloat)offset(1), 0.0f);
//################################################################################################################################
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
//################################################################################################################################
::glBegin(GL_POLYGON);
for (const Vec3d& vertex : m_planes[i].vertices)
::glVertex3f((GLfloat)vertex(0), (GLfloat)vertex(1), (GLfloat)vertex(2));
@ -1272,25 +1264,17 @@ void GLGizmoFlatten::on_render_for_picking(const BoundingBoxf3& box) const
for (unsigned int i = 0; i < m_planes.size(); ++i)
{
::glColor3f(1.0f, 1.0f, picking_color_component(i));
//################################################################################################################################
#if ENABLE_MODELINSTANCE_3D_OFFSET
for (const Vec3d& offset : m_instances_positions) {
#else
//################################################################################################################################
for (const Vec2d& offset : m_instances_positions) {
//################################################################################################################################
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
//################################################################################################################################
::glPushMatrix();
//################################################################################################################################
#if ENABLE_MODELINSTANCE_3D_OFFSET
::glTranslated(offset(0), offset(1), offset(2));
#else
//################################################################################################################################
::glTranslatef((GLfloat)offset(0), (GLfloat)offset(1), 0.0f);
//################################################################################################################################
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
//################################################################################################################################
::glBegin(GL_POLYGON);
for (const Vec3d& vertex : m_planes[i].vertices)
::glVertex3f((GLfloat)vertex(0), (GLfloat)vertex(1), (GLfloat)vertex(2));
@ -1308,15 +1292,11 @@ void GLGizmoFlatten::set_flattening_data(const ModelObject* model_object)
if (m_model_object && !m_model_object->instances.empty()) {
m_instances_positions.clear();
for (const auto* instance : m_model_object->instances)
//################################################################################################################################
#if ENABLE_MODELINSTANCE_3D_OFFSET
m_instances_positions.emplace_back(instance->get_offset());
#else
//################################################################################################################################
m_instances_positions.emplace_back(instance->offset);
//################################################################################################################################
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
//################################################################################################################################
}
if (is_plane_update_necessary())

4
xs/src/slic3r/GUI/GLGizmo.hpp
View File

@ -328,15 +328,11 @@ private:
SourceDataSummary m_source_data;
std::vector<PlaneData> m_planes;
//################################################################################################################################
#if ENABLE_MODELINSTANCE_3D_OFFSET
Pointf3s m_instances_positions;
#else
//################################################################################################################################
std::vector<Vec2d> m_instances_positions;
//################################################################################################################################
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
//################################################################################################################################
Vec3d m_starting_center;
const ModelObject* m_model_object = nullptr;

4
xs/src/slic3r/GUI/GUI_ObjectParts.cpp
View File

@ -1564,19 +1564,15 @@ void update_position_values()
auto og = get_optgroup(ogFrequentlyObjectSettings);
auto instance = (*m_objects)[m_selected_object_id]->instances.front();
//################################################################################################################################
#if ENABLE_MODELINSTANCE_3D_OFFSET
og->set_value("position_x", int(instance->get_offset(X)));
og->set_value("position_y", int(instance->get_offset(Y)));
og->set_value("position_z", int(instance->get_offset(Z)));
#else
//################################################################################################################################
og->set_value("position_x", int(instance->offset(0)));
og->set_value("position_y", int(instance->offset(1)));
og->set_value("position_z", 0);
//################################################################################################################################
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
//################################################################################################################################
}
void update_position_values(const Vec3d& position)

4
xs/xsp/Model.xsp
View File

@ -358,7 +358,6 @@ ModelMaterial::attributes()
%code%{ RETVAL = THIS->rotation; %};
double scaling_factor()
%code%{ RETVAL = THIS->scaling_factor; %};
//################################################################################################################################
#if ENABLE_MODELINSTANCE_3D_OFFSET
Vec2d* offset()
%code%{ RETVAL = new Vec2d(THIS->get_offset(X), THIS->get_offset(Y)); %};
@ -366,13 +365,11 @@ ModelMaterial::attributes()
Ref<Vec2d> offset()
%code%{ RETVAL = &THIS->offset; %};
#endif // ENABLE_MODELINSTANCE_3D_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(); %};
//################################################################################################################################
#if ENABLE_MODELINSTANCE_3D_OFFSET
void set_offset(Vec2d *offset)
%code%{
@ -383,7 +380,6 @@ ModelMaterial::attributes()
void set_offset(Vec2d *offset)
%code%{ THIS->offset = *offset; %};
#endif // ENABLE_MODELINSTANCE_3D_OFFSET
//################################################################################################################################
void transform_mesh(TriangleMesh* mesh, bool dont_translate = false) const;
void transform_polygon(Polygon* polygon) const;