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

Merge remote-tracking branch 'origin/dev' into sla_base_pool

Browse Source
This commit is contained in:
tamasmeszaros 2018-08-28 15:17:35 +02:00
commit 055e90602e
4 changed files with 103 additions and 429 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -87,8 +87,6 @@ const char* INVALID_OBJECT_TYPES[] =
"other" "other"
}; };
typedef Eigen::Matrix<float, 4, 4, Eigen::RowMajor> Matrix4x4;
const char* get_attribute_value_charptr(const char** attributes, unsigned int attributes_size, const char* attribute_key) const char* get_attribute_value_charptr(const char** attributes, unsigned int attributes_size, const char* attribute_key)
{ {
if ((attributes == nullptr) || (attributes_size == 0) || (attributes_size % 2 != 0) || (attribute_key == nullptr)) if ((attributes == nullptr) || (attributes_size == 0) || (attributes_size % 2 != 0) || (attribute_key == nullptr))
@ -121,11 +119,11 @@ int get_attribute_value_int(const char** attributes, unsigned int attributes_siz
return (text != nullptr) ? ::atoi(text) : 0; return (text != nullptr) ? ::atoi(text) : 0;
} }
Matrix4x4 get_matrix_from_string(const std::string& mat_str) Slic3r::Transform3d get_transform_from_string(const std::string& mat_str)
{ {
if (mat_str.empty()) if (mat_str.empty())
// empty string means default identity matrix // empty string means default identity matrix
return Matrix4x4::Identity(); return Slic3r::Transform3d::Identity();
std::vector<std::string> mat_elements_str; std::vector<std::string> mat_elements_str;
boost::split(mat_elements_str, mat_str, boost::is_any_of(" "), boost::token_compress_on); boost::split(mat_elements_str, mat_str, boost::is_any_of(" "), boost::token_compress_on);
@ -133,9 +131,9 @@ Matrix4x4 get_matrix_from_string(const std::string& mat_str)
unsigned int size = (unsigned int)mat_elements_str.size(); unsigned int size = (unsigned int)mat_elements_str.size();
if (size != 12) if (size != 12)
// invalid data, return identity matrix // invalid data, return identity matrix
return Matrix4x4::Identity(); return Slic3r::Transform3d::Identity();
Matrix4x4 ret = Matrix4x4::Identity(); Slic3r::Transform3d ret = Slic3r::Transform3d::Identity();
unsigned int i = 0; unsigned int i = 0;
// matrices are stored into 3mf files as 4x3 // matrices are stored into 3mf files as 4x3
// we need to transpose them // we need to transpose them
@ -143,7 +141,7 @@ Matrix4x4 get_matrix_from_string(const std::string& mat_str)
{ {
for (unsigned int r = 0; r < 3; ++r) for (unsigned int r = 0; r < 3; ++r)
{ {
ret(r, c) = (float)::atof(mat_elements_str[i++].c_str()); ret(r, c) = ::atof(mat_elements_str[i++].c_str());
} }
} }
return ret; return ret;
@ -209,17 +207,17 @@ namespace Slic3r {
struct Component struct Component
{ {
int object_id; int object_id;
Matrix4x4 matrix; Transform3d transform;
explicit Component(int object_id) explicit Component(int object_id)
: object_id(object_id) : object_id(object_id)
, matrix(Matrix4x4::Identity()) , transform(Transform3d::Identity())
{ {
} }
Component(int object_id, const Matrix4x4& matrix) Component(int object_id, const Transform3d& transform)
: object_id(object_id) : object_id(object_id)
, matrix(matrix) , transform(transform)
{ {
} }
}; };
@ -273,11 +271,11 @@ namespace Slic3r {
struct Instance struct Instance
{ {
ModelInstance* instance; ModelInstance* instance;
Matrix4x4 matrix; Transform3d transform;
Instance(ModelInstance* instance, const Matrix4x4& matrix) Instance(ModelInstance* instance, const Transform3d& transform)
: instance(instance) : instance(instance)
, matrix(matrix) , transform(transform)
{ {
} }
}; };
@ -405,9 +403,9 @@ namespace Slic3r {
bool _handle_start_metadata(const char** attributes, unsigned int num_attributes); bool _handle_start_metadata(const char** attributes, unsigned int num_attributes);
bool _handle_end_metadata(); bool _handle_end_metadata();
bool _create_object_instance(int object_id, const Matrix4x4& matrix, unsigned int recur_counter); bool _create_object_instance(int object_id, const Transform3d& transform, unsigned int recur_counter);
void _apply_transform(ModelInstance& instance, const Matrix4x4& matrix); void _apply_transform(ModelInstance& instance, const Transform3d& transform);
bool _handle_start_config(const char** attributes, unsigned int num_attributes); bool _handle_start_config(const char** attributes, unsigned int num_attributes);
bool _handle_end_config(); bool _handle_end_config();
@ -934,8 +932,8 @@ namespace Slic3r {
ModelObject* object = instance.instance->get_object(); ModelObject* object = instance.instance->get_object();
if (object != nullptr) if (object != nullptr)
{ {
// apply the matrix to the instance // apply the transform to the instance
_apply_transform(*instance.instance, instance.matrix); _apply_transform(*instance.instance, instance.transform);
} }
} }
} }
@ -1119,7 +1117,7 @@ namespace Slic3r {
bool _3MF_Importer::_handle_start_component(const char** attributes, unsigned int num_attributes) bool _3MF_Importer::_handle_start_component(const char** attributes, unsigned int num_attributes)
{ {
int object_id = get_attribute_value_int(attributes, num_attributes, OBJECTID_ATTR); int object_id = get_attribute_value_int(attributes, num_attributes, OBJECTID_ATTR);
Matrix4x4 matrix = get_matrix_from_string(get_attribute_value_string(attributes, num_attributes, TRANSFORM_ATTR)); Transform3d transform = get_transform_from_string(get_attribute_value_string(attributes, num_attributes, TRANSFORM_ATTR));
IdToModelObjectMap::iterator object_item = m_objects.find(object_id); IdToModelObjectMap::iterator object_item = m_objects.find(object_id);
if (object_item == m_objects.end()) if (object_item == m_objects.end())
@ -1132,7 +1130,7 @@ namespace Slic3r {
} }
} }
m_curr_object.components.emplace_back(object_id, matrix); m_curr_object.components.emplace_back(object_id, transform);
return true; return true;
} }
@ -1165,9 +1163,9 @@ namespace Slic3r {
// see specifications // see specifications
int object_id = get_attribute_value_int(attributes, num_attributes, OBJECTID_ATTR); int object_id = get_attribute_value_int(attributes, num_attributes, OBJECTID_ATTR);
Matrix4x4 matrix = get_matrix_from_string(get_attribute_value_string(attributes, num_attributes, TRANSFORM_ATTR)); Transform3d transform = get_transform_from_string(get_attribute_value_string(attributes, num_attributes, TRANSFORM_ATTR));
return _create_object_instance(object_id, matrix, 1); return _create_object_instance(object_id, transform, 1);
} }
bool _3MF_Importer::_handle_end_item() bool _3MF_Importer::_handle_end_item()
@ -1195,7 +1193,7 @@ namespace Slic3r {
return true; return true;
} }
bool _3MF_Importer::_create_object_instance(int object_id, const Matrix4x4& matrix, unsigned int recur_counter) bool _3MF_Importer::_create_object_instance(int object_id, const Transform3d& transform, unsigned int recur_counter)
{ {
static const unsigned int MAX_RECURSIONS = 10; static const unsigned int MAX_RECURSIONS = 10;
@ -1232,7 +1230,7 @@ namespace Slic3r {
return false; return false;
} }
m_instances.emplace_back(instance, matrix); m_instances.emplace_back(instance, transform);
} }
} }
else else
@ -1240,7 +1238,7 @@ namespace Slic3r {
// recursively process nested components // recursively process nested components
for (const Component& component : it->second) for (const Component& component : it->second)
{ {
if (!_create_object_instance(component.object_id, matrix * component.matrix, recur_counter + 1)) if (!_create_object_instance(component.object_id, transform * component.transform, recur_counter + 1))
return false; return false;
} }
} }
@ -1248,20 +1246,20 @@ namespace Slic3r {
return true; return true;
} }
void _3MF_Importer::_apply_transform(ModelInstance& instance, const Matrix4x4& matrix) void _3MF_Importer::_apply_transform(ModelInstance& instance, const Transform3d& transform)
{ {
// slic3r ModelInstance cannot be transformed using a matrix // slic3r ModelInstance cannot be transformed using a matrix
// we extract from the given matrix only the values currently used // we extract from the given matrix only the values currently used
// translation // translation
double offset_x = (double)matrix(0, 3); double offset_x = transform(0, 3);
double offset_y = (double)matrix(1, 3); double offset_y = transform(1, 3);
double offset_z = (double)matrix(2, 3); double offset_z = transform(2, 3);
// scale // scale
double sx = ::sqrt(sqr((double)matrix(0, 0)) + sqr((double)matrix(1, 0)) + sqr((double)matrix(2, 0))); double sx = ::sqrt(sqr(transform(0, 0)) + sqr(transform(1, 0)) + sqr(transform(2, 0)));
double sy = ::sqrt(sqr((double)matrix(0, 1)) + sqr((double)matrix(1, 1)) + sqr((double)matrix(2, 1))); double sy = ::sqrt(sqr(transform(0, 1)) + sqr(transform(1, 1)) + sqr(transform(2, 1)));
double sz = ::sqrt(sqr((double)matrix(0, 2)) + sqr((double)matrix(1, 2)) + sqr((double)matrix(2, 2))); double sz = ::sqrt(sqr(transform(0, 2)) + sqr(transform(1, 2)) + sqr(transform(2, 2)));
// invalid scale value, return // invalid scale value, return
if ((sx == 0.0) || (sy == 0.0) || (sz == 0.0)) if ((sx == 0.0) || (sy == 0.0) || (sz == 0.0))
@ -1271,86 +1269,23 @@ namespace Slic3r {
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;
#if 0 // use quaternions
// rotations (extracted using quaternion)
double inv_sx = 1.0 / sx;
double inv_sy = 1.0 / sy;
double inv_sz = 1.0 / sz;
Eigen::Matrix<double, 3, 3, Eigen::RowMajor> m3x3;
m3x3 << (double)matrix(0, 0) * inv_sx, (double)matrix(0, 1) * inv_sy, (double)matrix(0, 2) * inv_sz,
(double)matrix(1, 0) * inv_sx, (double)matrix(1, 1) * inv_sy, (double)matrix(1, 2) * inv_sz,
(double)matrix(2, 0) * inv_sx, (double)matrix(2, 1) * inv_sy, (double)matrix(2, 2) * inv_sz;
double qw = 0.5 * ::sqrt(std::max(0.0, 1.0 + m3x3(0, 0) + m3x3(1, 1) + m3x3(2, 2)));
double qx = 0.5 * ::sqrt(std::max(0.0, 1.0 + m3x3(0, 0) - m3x3(1, 1) - m3x3(2, 2)));
double qy = 0.5 * ::sqrt(std::max(0.0, 1.0 - m3x3(0, 0) + m3x3(1, 1) - m3x3(2, 2)));
double qz = 0.5 * ::sqrt(std::max(0.0, 1.0 - m3x3(0, 0) - m3x3(1, 1) + m3x3(2, 2)));
double q_magnitude = ::sqrt(sqr(qw) + sqr(qx) + sqr(qy) + sqr(qz));
// invalid length, return
if (q_magnitude == 0.0)
return;
double inv_q_magnitude = 1.0 / q_magnitude;
qw *= inv_q_magnitude;
qx *= inv_q_magnitude;
qy *= inv_q_magnitude;
qz *= inv_q_magnitude;
double test = qx * qy + qz * qw;
double angle_x, angle_y, angle_z;
if (test > 0.499)
{
// singularity at north pole
angle_x = 0.0;
angle_y = 2.0 * ::atan2(qx, qw);
angle_z = 0.5 * PI;
}
else if (test < -0.499)
{
// singularity at south pole
angle_x = 0.0;
angle_y = -2.0 * ::atan2(qx, qw);
angle_z = -0.5 * PI;
}
else
{
angle_x = ::atan2(2.0 * qx * qw - 2.0 * qy * qz, 1.0 - 2.0 * sqr(qx) - 2.0 * sqr(qz));
angle_y = ::atan2(2.0 * qy * qw - 2.0 * qx * qz, 1.0 - 2.0 * sqr(qy) - 2.0 * sqr(qz));
angle_z = ::asin(2.0 * qx * qy + 2.0 * qz * qw);
if (angle_x < 0.0)
angle_x += 2.0 * PI;
if (angle_y < 0.0)
angle_y += 2.0 * PI;
if (angle_z < 0.0)
angle_z += 2.0 * PI;
}
#else // use eigen library
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::Matrix3d m3x3;
m3x3 << (double)matrix(0, 0) * inv_sx, (double)matrix(0, 1) * inv_sy, (double)matrix(0, 2) * inv_sz, m3x3 << transform(0, 0) * inv_sx, transform(0, 1) * inv_sy, transform(0, 2) * inv_sz,
(double)matrix(1, 0) * inv_sx, (double)matrix(1, 1) * inv_sy, (double)matrix(1, 2) * inv_sz, transform(1, 0) * inv_sx, transform(1, 1) * inv_sy, transform(1, 2) * inv_sz,
(double)matrix(2, 0) * inv_sx, (double)matrix(2, 1) * inv_sy, (double)matrix(2, 2) * inv_sz; transform(2, 0) * inv_sx, transform(2, 1) * inv_sy, transform(2, 2) * inv_sz;
Eigen::AngleAxisd rotation; Eigen::AngleAxisd rotation;
rotation.fromRotationMatrix(m3x3); rotation.fromRotationMatrix(m3x3);
// invalid rotation axis, we currently handle only rotations around Z axis // invalid rotation axis, we currently handle only rotations around Z axis
if ((rotation.angle() != 0.0) && (rotation.axis() != Eigen::Vector3d::UnitZ()) && (rotation.axis() != -Eigen::Vector3d::UnitZ())) if ((rotation.angle() != 0.0) && (rotation.axis() != Vec3d::UnitZ()) && (rotation.axis() != -Vec3d::UnitZ()))
return; return;
double angle_z = (rotation.axis() == Eigen::Vector3d::UnitZ()) ? rotation.angle() : -rotation.angle(); double angle_z = (rotation.axis() == Vec3d::UnitZ()) ? rotation.angle() : -rotation.angle();
#endif
instance.offset(0) = offset_x; instance.offset(0) = offset_x;
instance.offset(1) = offset_y; instance.offset(1) = offset_y;
@ -1548,11 +1483,11 @@ namespace Slic3r {
struct BuildItem struct BuildItem
{ {
unsigned int id; unsigned int id;
Matrix4x4 matrix; Transform3d transform;
BuildItem(unsigned int id, const Matrix4x4& matrix) BuildItem(unsigned int id, const Transform3d& transform)
: id(id) : id(id)
, matrix(matrix) , transform(transform)
{ {
} }
}; };
@ -1801,9 +1736,11 @@ namespace Slic3r {
stream << " </" << COMPONENTS_TAG << ">\n"; stream << " </" << COMPONENTS_TAG << ">\n";
} }
Eigen::Affine3f transform; Transform3d t = Transform3d::Identity();
transform = Eigen::Translation3f((float)instance->offset(0), (float)instance->offset(1), 0.0f) * Eigen::AngleAxisf((float)instance->rotation, Eigen::Vector3f::UnitZ()) * Eigen::Scaling((float)instance->scaling_factor); t.translate(Vec3d(instance->offset(0), instance->offset(1), 0.0));
build_items.emplace_back(instance_id, transform.matrix()); t.rotate(Eigen::AngleAxisd(instance->rotation, Vec3d::UnitZ()));
t.scale(instance->scaling_factor);
build_items.emplace_back(instance_id, t);
stream << " </" << OBJECT_TAG << ">\n"; stream << " </" << OBJECT_TAG << ">\n";
@ -1904,7 +1841,7 @@ namespace Slic3r {
{ {
for (unsigned r = 0; r < 3; ++r) for (unsigned r = 0; r < 3; ++r)
{ {
stream << item.matrix(r, c); stream << item.transform(r, c);
if ((r != 2) || (c != 3)) if ((r != 2) || (c != 3))
stream << " "; stream << " ";
} }

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

@ -1134,11 +1134,7 @@ GLCanvas3D::Gizmos::~Gizmos()
bool GLCanvas3D::Gizmos::init(GLCanvas3D& parent) bool GLCanvas3D::Gizmos::init(GLCanvas3D& parent)
{ {
#if ENABLE_GIZMOS_3D
GLGizmoBase* gizmo = new GLGizmoScale3D(parent); GLGizmoBase* gizmo = new GLGizmoScale3D(parent);
#else
GLGizmoBase* gizmo = new GLGizmoScale(parent);
#endif // ENABLE_GIZMOS_3D
if (gizmo == nullptr) if (gizmo == nullptr)
return false; return false;
@ -1147,11 +1143,7 @@ bool GLCanvas3D::Gizmos::init(GLCanvas3D& parent)
m_gizmos.insert(GizmosMap::value_type(Scale, gizmo)); m_gizmos.insert(GizmosMap::value_type(Scale, gizmo));
#if ENABLE_GIZMOS_3D
gizmo = new GLGizmoRotate3D(parent); gizmo = new GLGizmoRotate3D(parent);
#else
gizmo = new GLGizmoRotate(parent, GLGizmoRotate::Z);
#endif // ENABLE_GIZMOS_3D
if (gizmo == nullptr) if (gizmo == nullptr)
{ {
_reset(); _reset();
@ -1379,11 +1371,7 @@ float GLCanvas3D::Gizmos::get_scale() const
return 1.0f; return 1.0f;
GizmosMap::const_iterator it = m_gizmos.find(Scale); GizmosMap::const_iterator it = m_gizmos.find(Scale);
#if ENABLE_GIZMOS_3D
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_x() : 1.0f;
#else
return (it != m_gizmos.end()) ? reinterpret_cast<GLGizmoScale*>(it->second)->get_scale() : 1.0f;
#endif // ENABLE_GIZMOS_3D
} }
void GLCanvas3D::Gizmos::set_scale(float scale) void GLCanvas3D::Gizmos::set_scale(float scale)
@ -1393,11 +1381,7 @@ void GLCanvas3D::Gizmos::set_scale(float scale)
GizmosMap::const_iterator it = m_gizmos.find(Scale); GizmosMap::const_iterator it = m_gizmos.find(Scale);
if (it != m_gizmos.end()) if (it != m_gizmos.end())
#if ENABLE_GIZMOS_3D
reinterpret_cast<GLGizmoScale3D*>(it->second)->set_scale(scale); reinterpret_cast<GLGizmoScale3D*>(it->second)->set_scale(scale);
#else
reinterpret_cast<GLGizmoScale*>(it->second)->set_scale(scale);
#endif // ENABLE_GIZMOS_3D
} }
float GLCanvas3D::Gizmos::get_angle_z() const float GLCanvas3D::Gizmos::get_angle_z() const
@ -1406,11 +1390,7 @@ float GLCanvas3D::Gizmos::get_angle_z() const
return 0.0f; return 0.0f;
GizmosMap::const_iterator it = m_gizmos.find(Rotate); GizmosMap::const_iterator it = m_gizmos.find(Rotate);
#if ENABLE_GIZMOS_3D
return (it != m_gizmos.end()) ? reinterpret_cast<GLGizmoRotate3D*>(it->second)->get_angle_z() : 0.0f; return (it != m_gizmos.end()) ? reinterpret_cast<GLGizmoRotate3D*>(it->second)->get_angle_z() : 0.0f;
#else
return (it != m_gizmos.end()) ? reinterpret_cast<GLGizmoRotate*>(it->second)->get_angle() : 0.0f;
#endif // ENABLE_GIZMOS_3D
} }
void GLCanvas3D::Gizmos::set_angle_z(float angle_z) void GLCanvas3D::Gizmos::set_angle_z(float angle_z)
@ -1420,11 +1400,7 @@ void GLCanvas3D::Gizmos::set_angle_z(float angle_z)
GizmosMap::const_iterator it = m_gizmos.find(Rotate); GizmosMap::const_iterator it = m_gizmos.find(Rotate);
if (it != m_gizmos.end()) if (it != m_gizmos.end())
#if ENABLE_GIZMOS_3D reinterpret_cast<GLGizmoRotate3D*>(it->second)->set_angle_z(angle_z);
reinterpret_cast<GLGizmoRotate3D*>(it->second)->set_angle_z(angle_z);
#else
reinterpret_cast<GLGizmoRotate*>(it->second)->set_angle(angle_z);
#endif // ENABLE_GIZMOS_3D
} }
Vec3d GLCanvas3D::Gizmos::get_flattening_normal() const Vec3d GLCanvas3D::Gizmos::get_flattening_normal() const
@ -2487,10 +2463,12 @@ void GLCanvas3D::reload_scene(bool force)
// 1st call to reset if no objects left // 1st call to reset if no objects left
update_gizmos_data(); update_gizmos_data();
update_volumes_selection(m_objects_selections); update_volumes_selection(m_objects_selections);
// 2nd call to restore if something selected // 2nd call to restore selection, if any
if (!m_objects_selections.empty()) if (!m_objects_selections.empty())
update_gizmos_data(); update_gizmos_data();
m_gizmos.refresh();
if (m_config->has("nozzle_diameter")) if (m_config->has("nozzle_diameter"))
{ {
// Should the wipe tower be visualized ? // Should the wipe tower be visualized ?

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

@ -26,10 +26,8 @@ const float GLGizmoBase::Grabber::HalfSize = 2.0f;
const float GLGizmoBase::Grabber::DraggingScaleFactor = 1.25f; const float GLGizmoBase::Grabber::DraggingScaleFactor = 1.25f;
GLGizmoBase::Grabber::Grabber() GLGizmoBase::Grabber::Grabber()
: center(0.0, 0.0, 0.0) : center(Vec3d::Zero())
, angle_x(0.0f) , angles(Vec3d::Zero())
, angle_y(0.0f)
, angle_z(0.0f)
, dragging(false) , dragging(false)
{ {
color[0] = 1.0f; color[0] = 1.0f;
@ -49,29 +47,14 @@ void GLGizmoBase::Grabber::render(bool hover) const
else else
::memcpy((void*)render_color, (const void*)color, 3 * sizeof(float)); ::memcpy((void*)render_color, (const void*)color, 3 * sizeof(float));
#if ENABLE_GIZMOS_3D
render(render_color, true); render(render_color, true);
#else
render(render_color);
#endif // ENABLE_GIZMOS_3D
} }
#if ENABLE_GIZMOS_3D
void GLGizmoBase::Grabber::render(const float* render_color, bool use_lighting) const void GLGizmoBase::Grabber::render(const float* render_color, bool use_lighting) const
#else
void GLGizmoBase::Grabber::render(const float* render_color) const
#endif // ENABLE_GIZMOS_3D
{ {
float half_size = dragging ? HalfSize * DraggingScaleFactor : HalfSize; float half_size = dragging ? HalfSize * DraggingScaleFactor : HalfSize;
#if ENABLE_GIZMOS_3D
if (use_lighting) if (use_lighting)
::glEnable(GL_LIGHTING); ::glEnable(GL_LIGHTING);
#else
float min_x = -half_size;
float max_x = +half_size;
float min_y = -half_size;
float max_y = +half_size;
#endif // !ENABLE_GIZMOS_3D
::glColor3f((GLfloat)render_color[0], (GLfloat)render_color[1], (GLfloat)render_color[2]); ::glColor3f((GLfloat)render_color[0], (GLfloat)render_color[1], (GLfloat)render_color[2]);
@ -79,11 +62,10 @@ void GLGizmoBase::Grabber::render(const float* render_color) const
::glTranslatef((GLfloat)center(0), (GLfloat)center(1), (GLfloat)center(2)); ::glTranslatef((GLfloat)center(0), (GLfloat)center(1), (GLfloat)center(2));
float rad_to_deg = 180.0f / (GLfloat)PI; float rad_to_deg = 180.0f / (GLfloat)PI;
::glRotatef((GLfloat)angle_x * rad_to_deg, 1.0f, 0.0f, 0.0f); ::glRotatef((GLfloat)angles(0) * rad_to_deg, 1.0f, 0.0f, 0.0f);
::glRotatef((GLfloat)angle_y * rad_to_deg, 0.0f, 1.0f, 0.0f); ::glRotatef((GLfloat)angles(1) * rad_to_deg, 0.0f, 1.0f, 0.0f);
::glRotatef((GLfloat)angle_z * rad_to_deg, 0.0f, 0.0f, 1.0f); ::glRotatef((GLfloat)angles(2) * rad_to_deg, 0.0f, 0.0f, 1.0f);
#if ENABLE_GIZMOS_3D
// face min x // face min x
::glPushMatrix(); ::glPushMatrix();
::glTranslatef(-(GLfloat)half_size, 0.0f, 0.0f); ::glTranslatef(-(GLfloat)half_size, 0.0f, 0.0f);
@ -124,28 +106,13 @@ void GLGizmoBase::Grabber::render(const float* render_color) const
::glTranslatef(0.0f, 0.0f, (GLfloat)half_size); ::glTranslatef(0.0f, 0.0f, (GLfloat)half_size);
render_face(half_size); render_face(half_size);
::glPopMatrix(); ::glPopMatrix();
#else
::glDisable(GL_CULL_FACE);
::glBegin(GL_TRIANGLES);
::glVertex3f((GLfloat)min_x, (GLfloat)min_y, 0.0f);
::glVertex3f((GLfloat)max_x, (GLfloat)min_y, 0.0f);
::glVertex3f((GLfloat)max_x, (GLfloat)max_y, 0.0f);
::glVertex3f((GLfloat)max_x, (GLfloat)max_y, 0.0f);
::glVertex3f((GLfloat)min_x, (GLfloat)max_y, 0.0f);
::glVertex3f((GLfloat)min_x, (GLfloat)min_y, 0.0f);
::glEnd();
::glEnable(GL_CULL_FACE);
#endif // ENABLE_GIZMOS_3D
::glPopMatrix(); ::glPopMatrix();
#if ENABLE_GIZMOS_3D
if (use_lighting) if (use_lighting)
::glDisable(GL_LIGHTING); ::glDisable(GL_LIGHTING);
#endif // ENABLE_GIZMOS_3D
} }
#if ENABLE_GIZMOS_3D
void GLGizmoBase::Grabber::render_face(float half_size) const void GLGizmoBase::Grabber::render_face(float half_size) const
{ {
::glBegin(GL_TRIANGLES); ::glBegin(GL_TRIANGLES);
@ -158,7 +125,6 @@ void GLGizmoBase::Grabber::render_face(float half_size) const
::glVertex3f(-(GLfloat)half_size, -(GLfloat)half_size, 0.0f); ::glVertex3f(-(GLfloat)half_size, -(GLfloat)half_size, 0.0f);
::glEnd(); ::glEnd();
} }
#endif // ENABLE_GIZMOS_3D
GLGizmoBase::GLGizmoBase(GLCanvas3D& parent) GLGizmoBase::GLGizmoBase(GLCanvas3D& parent)
: m_parent(parent) : m_parent(parent)
@ -265,41 +231,24 @@ const float GLGizmoRotate::GrabberOffset = 5.0f;
GLGizmoRotate::GLGizmoRotate(GLCanvas3D& parent, GLGizmoRotate::Axis axis) GLGizmoRotate::GLGizmoRotate(GLCanvas3D& parent, GLGizmoRotate::Axis axis)
: GLGizmoBase(parent) : GLGizmoBase(parent)
, m_axis(axis) , m_axis(axis)
, m_angle(0.0f) , 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_keep_initial_values(false) , m_keep_initial_values(false)
{ {
} }
void GLGizmoRotate::set_angle(float angle) void GLGizmoRotate::set_angle(double angle)
{ {
if (std::abs(angle - 2.0f * PI) < EPSILON) if (std::abs(angle - 2.0 * (double)PI) < EPSILON)
angle = 0.0f; angle = 0.0;
m_angle = angle; m_angle = angle;
} }
bool GLGizmoRotate::on_init() bool GLGizmoRotate::on_init()
{ {
#if !ENABLE_GIZMOS_3D
std::string path = resources_dir() + "/icons/overlay/";
std::string filename = path + "rotate_off.png";
if (!m_textures[Off].load_from_file(filename, false))
return false;
filename = path + "rotate_hover.png";
if (!m_textures[Hover].load_from_file(filename, false))
return false;
filename = path + "rotate_on.png";
if (!m_textures[On].load_from_file(filename, false))
return false;
#endif // !ENABLE_GIZMOS_3D
m_grabbers.push_back(Grabber()); m_grabbers.push_back(Grabber());
return true; return true;
} }
@ -339,7 +288,7 @@ void GLGizmoRotate::on_update(const Linef3& mouse_ray)
if (theta == 2.0 * (double)PI) if (theta == 2.0 * (double)PI)
theta = 0.0; theta = 0.0;
m_angle = (float)theta; m_angle = theta;
} }
void GLGizmoRotate::on_render(const BoundingBoxf3& box) const void GLGizmoRotate::on_render(const BoundingBoxf3& box) const
@ -347,55 +296,33 @@ void GLGizmoRotate::on_render(const BoundingBoxf3& box) const
if (m_grabbers[0].dragging) if (m_grabbers[0].dragging)
set_tooltip(format(m_angle * 180.0f / (float)PI, 4)); set_tooltip(format(m_angle * 180.0f / (float)PI, 4));
#if ENABLE_GIZMOS_3D
::glEnable(GL_DEPTH_TEST); ::glEnable(GL_DEPTH_TEST);
#else
::glDisable(GL_DEPTH_TEST);
#endif // ENABLE_GIZMOS_3D
if (!m_keep_initial_values) if (!m_keep_initial_values)
{ {
m_center = box.center(); m_center = box.center();
#if !ENABLE_GIZMOS_3D
const Vec3d& size = box.size();
m_center(2) = 0.0;
#endif // !ENABLE_GIZMOS_3D
#if ENABLE_GIZMOS_3D
m_radius = Offset + box.radius(); m_radius = Offset + box.radius();
#else
m_radius = Offset + ::sqrt(sqr(0.5f * (float)size(0)) + sqr(0.5f * (float)size(1)));
#endif // ENABLE_GIZMOS_3D
m_keep_initial_values = true; m_keep_initial_values = true;
} }
::glPushMatrix(); ::glPushMatrix();
transform_to_local(); transform_to_local();
#if ENABLE_GIZMOS_3D
::glLineWidth((m_hover_id != -1) ? 2.0f : 1.5f); ::glLineWidth((m_hover_id != -1) ? 2.0f : 1.5f);
::glColor3fv((m_hover_id != -1) ? m_drag_color : m_highlight_color); ::glColor3fv((m_hover_id != -1) ? m_drag_color : m_highlight_color);
#else
::glLineWidth(2.0f);
::glColor3fv(m_drag_color);
#endif // ENABLE_GIZMOS_3D
render_circle(); render_circle();
#if ENABLE_GIZMOS_3D
if (m_hover_id != -1) if (m_hover_id != -1)
{ {
#endif // ENABLE_GIZMOS_3D
render_scale(); render_scale();
render_snap_radii(); render_snap_radii();
render_reference_radius(); render_reference_radius();
#if ENABLE_GIZMOS_3D
} }
#endif // ENABLE_GIZMOS_3D
::glColor3fv(m_highlight_color); ::glColor3fv(m_highlight_color);
#if ENABLE_GIZMOS_3D
if (m_hover_id != -1) if (m_hover_id != -1)
#endif // ENABLE_GIZMOS_3D
render_angle(); render_angle();
render_grabber(); render_grabber();
@ -491,7 +418,7 @@ void GLGizmoRotate::render_reference_radius() const
void GLGizmoRotate::render_angle() const void GLGizmoRotate::render_angle() const
{ {
float step_angle = m_angle / AngleResolution; float step_angle = (float)m_angle / AngleResolution;
float ex_radius = m_radius + GrabberOffset; float ex_radius = m_radius + GrabberOffset;
::glBegin(GL_LINE_STRIP); ::glBegin(GL_LINE_STRIP);
@ -508,15 +435,11 @@ void GLGizmoRotate::render_angle() const
void GLGizmoRotate::render_grabber() const void GLGizmoRotate::render_grabber() const
{ {
float grabber_radius = m_radius + GrabberOffset; double grabber_radius = (double)(m_radius + 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].angle_z = m_angle; m_grabbers[0].angles(2) = m_angle;
#if ENABLE_GIZMOS_3D
::glColor3fv((m_hover_id != -1) ? m_drag_color : m_highlight_color); ::glColor3fv((m_hover_id != -1) ? m_drag_color : m_highlight_color);
#else
::glColor3fv(m_drag_color);
#endif // ENABLE_GIZMOS_3D
::glBegin(GL_LINES); ::glBegin(GL_LINES);
::glVertex3f(0.0f, 0.0f, 0.0f); ::glVertex3f(0.0f, 0.0f, 0.0f);
@ -584,17 +507,7 @@ Vec3d GLGizmoRotate::mouse_position_in_local_plane(const Linef3& mouse_ray) cons
m.translate(-m_center); m.translate(-m_center);
Eigen::Matrix<double, 3, 2> world_ray; return transform(mouse_ray, m).intersect_plane(0.0);
Eigen::Matrix<double, 3, 2> local_ray;
world_ray(0, 0) = mouse_ray.a(0);
world_ray(1, 0) = mouse_ray.a(1);
world_ray(2, 0) = mouse_ray.a(2);
world_ray(0, 1) = mouse_ray.b(0);
world_ray(1, 1) = mouse_ray.b(1);
world_ray(2, 1) = mouse_ray.b(2);
local_ray = m * world_ray.colwise().homogeneous();
return Linef3(Vec3d(local_ray(0, 0), local_ray(1, 0), local_ray(2, 0)), Vec3d(local_ray(0, 1), local_ray(1, 1), local_ray(2, 1))).intersect_plane(0.0);
} }
GLGizmoRotate3D::GLGizmoRotate3D(GLCanvas3D& parent) GLGizmoRotate3D::GLGizmoRotate3D(GLCanvas3D& parent)
@ -698,116 +611,13 @@ void GLGizmoRotate3D::on_render(const BoundingBoxf3& box) const
m_z.render(box); m_z.render(box);
} }
const float GLGizmoScale::Offset = 5.0f;
GLGizmoScale::GLGizmoScale(GLCanvas3D& parent)
: GLGizmoBase(parent)
, m_scale(1.0f)
, m_starting_scale(1.0f)
{
}
bool GLGizmoScale::on_init()
{
std::string path = resources_dir() + "/icons/overlay/";
std::string filename = path + "scale_off.png";
if (!m_textures[Off].load_from_file(filename, false))
return false;
filename = path + "scale_hover.png";
if (!m_textures[Hover].load_from_file(filename, false))
return false;
filename = path + "scale_on.png";
if (!m_textures[On].load_from_file(filename, false))
return false;
for (unsigned int i = 0; i < 4; ++i)
{
m_grabbers.push_back(Grabber());
}
return true;
}
void GLGizmoScale::on_start_dragging()
{
if (m_hover_id != -1)
m_starting_drag_position = to_2d(m_grabbers[m_hover_id].center);
}
void GLGizmoScale::on_update(const Linef3& mouse_ray)
{
Vec2d mouse_pos = to_2d(mouse_ray.intersect_plane(0.0));
Vec2d center(0.5 * (m_grabbers[1].center(0) + m_grabbers[0].center(0)), 0.5 * (m_grabbers[3].center(1) + m_grabbers[0].center(1)));
double orig_len = (m_starting_drag_position - center).norm();
double new_len = (mouse_pos - center).norm();
double ratio = (orig_len != 0.0) ? new_len / orig_len : 1.0;
m_scale = m_starting_scale * (float)ratio;
}
void GLGizmoScale::on_render(const BoundingBoxf3& box) const
{
if (m_grabbers[0].dragging || m_grabbers[1].dragging || m_grabbers[2].dragging || m_grabbers[3].dragging)
set_tooltip(format(100.0f * m_scale, 4) + "%");
::glDisable(GL_DEPTH_TEST);
double min_x = box.min(0) - (double)Offset;
double max_x = box.max(0) + (double)Offset;
double min_y = box.min(1) - (double)Offset;
double max_y = box.max(1) + (double)Offset;
m_grabbers[0].center = Vec3d(min_x, min_y, 0.0);
m_grabbers[1].center = Vec3d(max_x, min_y, 0.0);
m_grabbers[2].center = Vec3d(max_x, max_y, 0.0);
m_grabbers[3].center = Vec3d(min_x, max_y, 0.0);
::glLineWidth(2.0f);
::glColor3fv(m_drag_color);
// draw outline
::glBegin(GL_LINE_LOOP);
for (unsigned int i = 0; i < 4; ++i)
{
::glVertex3f((GLfloat)m_grabbers[i].center(0), (GLfloat)m_grabbers[i].center(1), 0.0f);
}
::glEnd();
// draw grabbers
for (unsigned int i = 0; i < 4; ++i)
{
::memcpy((void*)m_grabbers[i].color, (const void*)m_highlight_color, 3 * sizeof(float));
}
render_grabbers();
}
void GLGizmoScale::on_render_for_picking(const BoundingBoxf3& box) const
{
::glDisable(GL_DEPTH_TEST);
for (unsigned int i = 0; i < 4; ++i)
{
m_grabbers[i].color[0] = 1.0f;
m_grabbers[i].color[1] = 1.0f;
m_grabbers[i].color[2] = picking_color_component(i);
}
render_grabbers_for_picking();
}
const float GLGizmoScale3D::Offset = 5.0f; const float GLGizmoScale3D::Offset = 5.0f;
GLGizmoScale3D::GLGizmoScale3D(GLCanvas3D& parent) GLGizmoScale3D::GLGizmoScale3D(GLCanvas3D& parent)
: GLGizmoBase(parent) : GLGizmoBase(parent)
, m_scale_x(1.0f) , m_scale(Vec3d::Ones())
, m_scale_y(1.0f) , m_starting_scale(Vec3d::Ones())
, m_scale_z(1.0f) , m_starting_center(Vec3d::Zero())
, m_starting_scale_x(1.0f)
, m_starting_scale_y(1.0f)
, m_starting_scale_z(1.0f)
{ {
} }
@ -832,15 +642,15 @@ bool GLGizmoScale3D::on_init()
m_grabbers.push_back(Grabber()); m_grabbers.push_back(Grabber());
} }
float half_pi = 0.5f * (float)PI; double half_pi = 0.5 * (double)PI;
// x axis // x axis
m_grabbers[0].angle_y = half_pi; m_grabbers[0].angles(1) = half_pi;
m_grabbers[1].angle_y = half_pi; m_grabbers[1].angles(1) = half_pi;
// y axis // y axis
m_grabbers[2].angle_x = half_pi; m_grabbers[2].angles(0) = half_pi;
m_grabbers[3].angle_x = half_pi; m_grabbers[3].angles(0) = half_pi;
return true; return true;
} }
@ -869,16 +679,16 @@ void GLGizmoScale3D::on_update(const Linef3& mouse_ray)
void GLGizmoScale3D::on_render(const BoundingBoxf3& box) const void GLGizmoScale3D::on_render(const BoundingBoxf3& box) const
{ {
if (m_grabbers[0].dragging || m_grabbers[1].dragging) if (m_grabbers[0].dragging || m_grabbers[1].dragging)
set_tooltip("X: " + format(100.0f * m_scale_x, 4) + "%"); set_tooltip("X: " + format(100.0f * m_scale(0), 4) + "%");
else if (m_grabbers[2].dragging || m_grabbers[3].dragging) else if (m_grabbers[2].dragging || m_grabbers[3].dragging)
set_tooltip("Y: " + format(100.0f * m_scale_y, 4) + "%"); set_tooltip("Y: " + format(100.0f * m_scale(1), 4) + "%");
else if (m_grabbers[4].dragging || m_grabbers[5].dragging) else if (m_grabbers[4].dragging || m_grabbers[5].dragging)
set_tooltip("Z: " + format(100.0f * m_scale_z, 4) + "%"); set_tooltip("Z: " + format(100.0f * m_scale(2), 4) + "%");
else if (m_grabbers[6].dragging || m_grabbers[7].dragging || m_grabbers[8].dragging || m_grabbers[9].dragging) else if (m_grabbers[6].dragging || m_grabbers[7].dragging || m_grabbers[8].dragging || m_grabbers[9].dragging)
{ {
std::string tooltip = "X: " + format(100.0f * m_scale_x, 4) + "%\n"; std::string tooltip = "X: " + format(100.0f * m_scale(0), 4) + "%\n";
tooltip += "Y: " + format(100.0f * m_scale_y, 4) + "%\n"; tooltip += "Y: " + format(100.0f * m_scale(1), 4) + "%\n";
tooltip += "Z: " + format(100.0f * m_scale_z, 4) + "%"; tooltip += "Z: " + format(100.0f * m_scale(2), 4) + "%";
set_tooltip(tooltip); set_tooltip(tooltip);
} }
@ -1025,7 +835,7 @@ void GLGizmoScale3D::do_scale_x(const Linef3& mouse_ray)
double ratio = calc_ratio(1, mouse_ray, m_starting_center); double ratio = calc_ratio(1, mouse_ray, m_starting_center);
if (ratio > 0.0) if (ratio > 0.0)
m_scale_x = m_starting_scale_x * (float)ratio; m_scale(0) = m_starting_scale(0) * ratio;
} }
void GLGizmoScale3D::do_scale_y(const Linef3& mouse_ray) void GLGizmoScale3D::do_scale_y(const Linef3& mouse_ray)
@ -1033,8 +843,8 @@ void GLGizmoScale3D::do_scale_y(const Linef3& mouse_ray)
double ratio = calc_ratio(2, mouse_ray, m_starting_center); double ratio = calc_ratio(2, mouse_ray, m_starting_center);
if (ratio > 0.0) if (ratio > 0.0)
m_scale_x = m_starting_scale_y * (float)ratio; // << this is temporary m_scale(0) = m_starting_scale(1) * ratio; // << this is temporary
// m_scale_y = m_starting_scale_y * (float)ratio; // m_scale(1) = m_starting_scale(1) * ratio;
} }
void GLGizmoScale3D::do_scale_z(const Linef3& mouse_ray) void GLGizmoScale3D::do_scale_z(const Linef3& mouse_ray)
@ -1042,8 +852,8 @@ void GLGizmoScale3D::do_scale_z(const Linef3& mouse_ray)
double ratio = calc_ratio(1, mouse_ray, m_starting_center); double ratio = calc_ratio(1, mouse_ray, m_starting_center);
if (ratio > 0.0) if (ratio > 0.0)
m_scale_x = m_starting_scale_z * (float)ratio; // << this is temporary m_scale(0) = m_starting_scale(2) * ratio; // << this is temporary
// m_scale_z = m_starting_scale_z * (float)ratio; // m_scale(2) = m_starting_scale(2) * ratio;
} }
void GLGizmoScale3D::do_scale_uniform(const Linef3& mouse_ray) void GLGizmoScale3D::do_scale_uniform(const Linef3& mouse_ray)
@ -1053,11 +863,7 @@ void GLGizmoScale3D::do_scale_uniform(const Linef3& mouse_ray)
double ratio = calc_ratio(0, mouse_ray, center); double ratio = calc_ratio(0, mouse_ray, center);
if (ratio > 0.0) if (ratio > 0.0)
{ m_scale = m_starting_scale * ratio;
m_scale_x = m_starting_scale_x * (float)ratio;
m_scale_y = m_starting_scale_y * (float)ratio;
m_scale_z = m_starting_scale_z * (float)ratio;
}
} }
double GLGizmoScale3D::calc_ratio(unsigned int preferred_plane_id, const Linef3& mouse_ray, const Vec3d& center) const double GLGizmoScale3D::calc_ratio(unsigned int preferred_plane_id, const Linef3& mouse_ray, const Vec3d& center) const

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

@ -7,8 +7,6 @@
#include <vector> #include <vector>
#define ENABLE_GIZMOS_3D 1
namespace Slic3r { namespace Slic3r {
class BoundingBoxf3; class BoundingBoxf3;
@ -28,30 +26,18 @@ protected:
static const float DraggingScaleFactor; static const float DraggingScaleFactor;
Vec3d center; Vec3d center;
float angle_x; Vec3d angles;
float angle_y;
float angle_z;
float color[3]; float color[3];
bool dragging; bool dragging;
Grabber(); Grabber();
void render(bool hover) const; void render(bool hover) const;
#if ENABLE_GIZMOS_3D
void render_for_picking() const { render(color, false); } void render_for_picking() const { render(color, false); }
#else
void render_for_picking() const { render(color); }
#endif // ENABLE_GIZMOS_3D
private: private:
#if ENABLE_GIZMOS_3D
void render(const float* render_color, bool use_lighting) const; void render(const float* render_color, bool use_lighting) const;
#else
void render(const float* render_color) const;
#endif // ENABLE_GIZMOS_3D
#if ENABLE_GIZMOS_3D
void render_face(float half_size) const; void render_face(float half_size) const;
#endif // ENABLE_GIZMOS_3D
}; };
public: public:
@ -146,7 +132,7 @@ public:
private: private:
Axis m_axis; Axis m_axis;
float m_angle; double m_angle;
mutable Vec3d m_center; mutable Vec3d m_center;
mutable float m_radius; mutable float m_radius;
@ -155,8 +141,8 @@ private:
public: public:
GLGizmoRotate(GLCanvas3D& parent, Axis axis); GLGizmoRotate(GLCanvas3D& parent, Axis axis);
float get_angle() const { return m_angle; } double get_angle() const { return m_angle; }
void set_angle(float angle); void set_angle(double angle);
protected: protected:
virtual bool on_init(); virtual bool on_init();
@ -188,14 +174,14 @@ class GLGizmoRotate3D : public GLGizmoBase
public: public:
explicit GLGizmoRotate3D(GLCanvas3D& parent); explicit GLGizmoRotate3D(GLCanvas3D& parent);
float get_angle_x() const { return m_x.get_angle(); } double get_angle_x() const { return m_x.get_angle(); }
void set_angle_x(float angle) { m_x.set_angle(angle); } void set_angle_x(double angle) { m_x.set_angle(angle); }
float get_angle_y() const { return m_y.get_angle(); } double get_angle_y() const { return m_y.get_angle(); }
void set_angle_y(float angle) { m_y.set_angle(angle); } void set_angle_y(double angle) { m_y.set_angle(angle); }
float get_angle_z() const { return m_z.get_angle(); } double get_angle_z() const { return m_z.get_angle(); }
void set_angle_z(float angle) { m_z.set_angle(angle); } void set_angle_z(double angle) { m_z.set_angle(angle); }
protected: protected:
virtual bool on_init(); virtual bool on_init();
@ -234,64 +220,31 @@ protected:
} }
}; };
class GLGizmoScale : public GLGizmoBase
{
static const float Offset;
float m_scale;
float m_starting_scale;
Vec2d m_starting_drag_position;
public:
explicit GLGizmoScale(GLCanvas3D& parent);
float get_scale() const { return m_scale; }
void set_scale(float scale) { m_starting_scale = scale; }
protected:
virtual bool on_init();
virtual void on_start_dragging();
virtual void on_update(const Linef3& mouse_ray);
virtual void on_render(const BoundingBoxf3& box) const;
virtual void on_render_for_picking(const BoundingBoxf3& box) const;
};
class GLGizmoScale3D : public GLGizmoBase class GLGizmoScale3D : public GLGizmoBase
{ {
static const float Offset; static const float Offset;
mutable BoundingBoxf3 m_box; mutable BoundingBoxf3 m_box;
float m_scale_x; Vec3d m_scale;
float m_scale_y;
float m_scale_z;
float m_starting_scale_x;
float m_starting_scale_y;
float m_starting_scale_z;
Vec3d m_starting_scale;
Vec3d m_starting_drag_position; Vec3d m_starting_drag_position;
Vec3d m_starting_center; Vec3d m_starting_center;
public: public:
explicit GLGizmoScale3D(GLCanvas3D& parent); explicit GLGizmoScale3D(GLCanvas3D& parent);
float get_scale_x() const { return m_scale_x; } double get_scale_x() const { return m_scale(0); }
void set_scale_x(float scale) { m_starting_scale_x = scale; } void set_scale_x(double scale) { m_starting_scale(0) = scale; }
float get_scale_y() const { return m_scale_y; } double get_scale_y() const { return m_scale(1); }
void set_scale_y(float scale) { m_starting_scale_y = scale; } void set_scale_y(double scale) { m_starting_scale(1) = scale; }
float get_scale_z() const { return m_scale_z; } double get_scale_z() const { return m_scale(2); }
void set_scale_z(float scale) { m_starting_scale_z = scale; } void set_scale_z(double scale) { m_starting_scale(2) = scale; }
void set_scale(float scale) void set_scale(double scale) { m_starting_scale = scale * Vec3d::Ones(); }
{
m_starting_scale_x = scale;
m_starting_scale_y = scale;
m_starting_scale_z = scale;
}
protected: protected:
virtual bool on_init(); virtual bool on_init();