3D-printing/OrcaSlicer
1
0
Fork 0
mirror of https://github.com/SoftFever/OrcaSlicer.git synced 2025-07-11 16:57:53 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Merge branch 'et_canvas_gui_refactoring' of https://github.com/prusa3d/Slic3r

Browse source
This commit is contained in:
Enrico Turri 2019-04-08 09:09:12 +02:00
commit a688493d91
27 changed files with 2357 additions and 2158 deletions
Download patch file Download diff file Expand all files Collapse all files

3
src/slic3r/CMakeLists.txt
View file

@ -30,6 +30,9 @@ set(SLIC3R_GUI_SOURCES
GUI/GLCanvas3DManager.cpp GUI/GLCanvas3DManager.cpp
GUI/Selection.hpp GUI/Selection.hpp
GUI/Selection.cpp GUI/Selection.cpp
GUI/Gizmos/GLGizmos.hpp
GUI/Gizmos/GLGizmosManager.cpp
GUI/Gizmos/GLGizmosManager.hpp
GUI/Gizmos/GLGizmoBase.cpp GUI/Gizmos/GLGizmoBase.cpp
GUI/Gizmos/GLGizmoBase.hpp GUI/Gizmos/GLGizmoBase.hpp
GUI/Gizmos/GLGizmoMove.cpp GUI/Gizmos/GLGizmoMove.cpp

9
src/slic3r/GUI/3DBed.cpp
View file

@ -495,11 +495,11 @@ void Bed3D::render_prusa(const std::string &key, bool bottom) const
// use anisotropic filter if graphic card allows // use anisotropic filter if graphic card allows
GLfloat max_anisotropy = 0.0f; GLfloat max_anisotropy = 0.0f;
if (glewIsSupported("GL_EXT_texture_filter_anisotropic")) if (glewIsSupported("GL_EXT_texture_filter_anisotropic"))
::glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &max_anisotropy); glsafe(::glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &max_anisotropy));
// use higher resolution images if graphic card allows // use higher resolution images if graphic card allows
GLint max_tex_size; GLint max_tex_size;
::glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max_tex_size); glsafe(::glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max_tex_size));
// clamp or the texture generation becomes too slow // clamp or the texture generation becomes too slow
max_tex_size = std::min(max_tex_size, 8192); max_tex_size = std::min(max_tex_size, 8192);
@ -621,7 +621,6 @@ void Bed3D::render_prusa_shader(bool transparent) const
m_shader.stop_using(); m_shader.stop_using();
} }
} }
#else #else
void Bed3D::render_prusa(const std::string &key, float theta, bool useVBOs) const void Bed3D::render_prusa(const std::string &key, float theta, bool useVBOs) const
{ {
@ -629,7 +628,7 @@ void Bed3D::render_prusa(const std::string &key, float theta, bool useVBOs) cons
// use higher resolution images if graphic card allows // use higher resolution images if graphic card allows
GLint max_tex_size; GLint max_tex_size;
::glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max_tex_size); glsafe(::glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max_tex_size));
// temporary set to lowest resolution // temporary set to lowest resolution
max_tex_size = 2048; max_tex_size = 2048;
@ -644,7 +643,7 @@ void Bed3D::render_prusa(const std::string &key, float theta, bool useVBOs) cons
// use anisotropic filter if graphic card allows // use anisotropic filter if graphic card allows
GLfloat max_anisotropy = 0.0f; GLfloat max_anisotropy = 0.0f;
if (glewIsSupported("GL_EXT_texture_filter_anisotropic")) if (glewIsSupported("GL_EXT_texture_filter_anisotropic"))
::glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &max_anisotropy); glsafe(::glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &max_anisotropy));
std::string filename = tex_path + "_top.png"; std::string filename = tex_path + "_top.png";
if ((m_top_texture.get_id() == 0) || (m_top_texture.get_source() != filename)) if ((m_top_texture.get_id() == 0) || (m_top_texture.get_source() != filename))

148
src/slic3r/GUI/3DScene.cpp
View file

@ -41,6 +41,7 @@ void glAssertRecentCallImpl(const char *file_name, unsigned int line, const char
switch (err) { switch (err) {
case GL_INVALID_ENUM: sErr = "Invalid Enum"; break; case GL_INVALID_ENUM: sErr = "Invalid Enum"; break;
case GL_INVALID_VALUE: sErr = "Invalid Value"; break; case GL_INVALID_VALUE: sErr = "Invalid Value"; break;
// be aware that GL_INVALID_OPERATION is generated if glGetError is executed between the execution of glBegin and the corresponding execution of glEnd
case GL_INVALID_OPERATION: sErr = "Invalid Operation"; break; case GL_INVALID_OPERATION: sErr = "Invalid Operation"; break;
case GL_STACK_OVERFLOW: sErr = "Stack Overflow"; break; case GL_STACK_OVERFLOW: sErr = "Stack Overflow"; break;
case GL_STACK_UNDERFLOW: sErr = "Stack Underflow"; break; case GL_STACK_UNDERFLOW: sErr = "Stack Underflow"; break;
@ -98,25 +99,25 @@ void GLIndexedVertexArray::finalize_geometry(bool use_VBOs)
if (use_VBOs) { if (use_VBOs) {
if (! empty()) { if (! empty()) {
glsafe(glGenBuffers(1, &this->vertices_and_normals_interleaved_VBO_id)); glsafe(::glGenBuffers(1, &this->vertices_and_normals_interleaved_VBO_id));
glsafe(glBindBuffer(GL_ARRAY_BUFFER, this->vertices_and_normals_interleaved_VBO_id)); glsafe(::glBindBuffer(GL_ARRAY_BUFFER, this->vertices_and_normals_interleaved_VBO_id));
glsafe(glBufferData(GL_ARRAY_BUFFER, this->vertices_and_normals_interleaved.size() * 4, this->vertices_and_normals_interleaved.data(), GL_STATIC_DRAW)); glsafe(::glBufferData(GL_ARRAY_BUFFER, this->vertices_and_normals_interleaved.size() * 4, this->vertices_and_normals_interleaved.data(), GL_STATIC_DRAW));
glsafe(glBindBuffer(GL_ARRAY_BUFFER, 0)); glsafe(::glBindBuffer(GL_ARRAY_BUFFER, 0));
this->vertices_and_normals_interleaved.clear(); this->vertices_and_normals_interleaved.clear();
} }
if (! this->triangle_indices.empty()) { if (! this->triangle_indices.empty()) {
glsafe(glGenBuffers(1, &this->triangle_indices_VBO_id)); glsafe(::glGenBuffers(1, &this->triangle_indices_VBO_id));
glsafe(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, this->triangle_indices_VBO_id)); glsafe(::glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, this->triangle_indices_VBO_id));
glsafe(glBufferData(GL_ELEMENT_ARRAY_BUFFER, this->triangle_indices.size() * 4, this->triangle_indices.data(), GL_STATIC_DRAW)); glsafe(::glBufferData(GL_ELEMENT_ARRAY_BUFFER, this->triangle_indices.size() * 4, this->triangle_indices.data(), GL_STATIC_DRAW));
this->triangle_indices.clear(); this->triangle_indices.clear();
} }
if (! this->quad_indices.empty()) { if (! this->quad_indices.empty()) {
glsafe(glGenBuffers(1, &this->quad_indices_VBO_id)); glsafe(::glGenBuffers(1, &this->quad_indices_VBO_id));
glsafe(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, this->quad_indices_VBO_id)); glsafe(::glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, this->quad_indices_VBO_id));
glsafe(glBufferData(GL_ELEMENT_ARRAY_BUFFER, this->quad_indices.size() * 4, this->quad_indices.data(), GL_STATIC_DRAW)); glsafe(::glBufferData(GL_ELEMENT_ARRAY_BUFFER, this->quad_indices.size() * 4, this->quad_indices.data(), GL_STATIC_DRAW));
this->quad_indices.clear(); this->quad_indices.clear();
} }
glsafe(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0)); glsafe(::glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0));
} }
this->shrink_to_fit(); this->shrink_to_fit();
} }
@ -124,15 +125,15 @@ void GLIndexedVertexArray::finalize_geometry(bool use_VBOs)
void GLIndexedVertexArray::release_geometry() void GLIndexedVertexArray::release_geometry()
{ {
if (this->vertices_and_normals_interleaved_VBO_id) { if (this->vertices_and_normals_interleaved_VBO_id) {
glsafe(glDeleteBuffers(1, &this->vertices_and_normals_interleaved_VBO_id)); glsafe(::glDeleteBuffers(1, &this->vertices_and_normals_interleaved_VBO_id));
this->vertices_and_normals_interleaved_VBO_id = 0; this->vertices_and_normals_interleaved_VBO_id = 0;
} }
if (this->triangle_indices_VBO_id) { if (this->triangle_indices_VBO_id) {
glsafe(glDeleteBuffers(1, &this->triangle_indices_VBO_id)); glsafe(::glDeleteBuffers(1, &this->triangle_indices_VBO_id));
this->triangle_indices_VBO_id = 0; this->triangle_indices_VBO_id = 0;
} }
if (this->quad_indices_VBO_id) { if (this->quad_indices_VBO_id) {
glsafe(glDeleteBuffers(1, &this->quad_indices_VBO_id)); glsafe(::glDeleteBuffers(1, &this->quad_indices_VBO_id));
this->quad_indices_VBO_id = 0; this->quad_indices_VBO_id = 0;
} }
this->clear(); this->clear();
@ -142,42 +143,42 @@ void GLIndexedVertexArray::release_geometry()
void GLIndexedVertexArray::render() const void GLIndexedVertexArray::render() const
{ {
if (this->vertices_and_normals_interleaved_VBO_id) { if (this->vertices_and_normals_interleaved_VBO_id) {
glsafe(glBindBuffer(GL_ARRAY_BUFFER, this->vertices_and_normals_interleaved_VBO_id)); glsafe(::glBindBuffer(GL_ARRAY_BUFFER, this->vertices_and_normals_interleaved_VBO_id));
glsafe(glVertexPointer(3, GL_FLOAT, 6 * sizeof(float), (const void*)(3 * sizeof(float)))); glsafe(::glVertexPointer(3, GL_FLOAT, 6 * sizeof(float), (const void*)(3 * sizeof(float))));
glsafe(glNormalPointer(GL_FLOAT, 6 * sizeof(float), nullptr)); glsafe(::glNormalPointer(GL_FLOAT, 6 * sizeof(float), nullptr));
} else { } else {
glsafe(glVertexPointer(3, GL_FLOAT, 6 * sizeof(float), this->vertices_and_normals_interleaved.data() + 3)); glsafe(::glVertexPointer(3, GL_FLOAT, 6 * sizeof(float), this->vertices_and_normals_interleaved.data() + 3));
glsafe(glNormalPointer(GL_FLOAT, 6 * sizeof(float), this->vertices_and_normals_interleaved.data())); glsafe(::glNormalPointer(GL_FLOAT, 6 * sizeof(float), this->vertices_and_normals_interleaved.data()));
} }
glsafe(glEnableClientState(GL_VERTEX_ARRAY)); glsafe(::glEnableClientState(GL_VERTEX_ARRAY));
glsafe(glEnableClientState(GL_NORMAL_ARRAY)); glsafe(::glEnableClientState(GL_NORMAL_ARRAY));
if (this->indexed()) { if (this->indexed()) {
if (this->vertices_and_normals_interleaved_VBO_id) { if (this->vertices_and_normals_interleaved_VBO_id) {
// Render using the Vertex Buffer Objects. // Render using the Vertex Buffer Objects.
if (this->triangle_indices_size > 0) { if (this->triangle_indices_size > 0) {
glsafe(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, this->triangle_indices_VBO_id)); glsafe(::glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, this->triangle_indices_VBO_id));
glsafe(glDrawElements(GL_TRIANGLES, GLsizei(this->triangle_indices_size), GL_UNSIGNED_INT, nullptr)); glsafe(::glDrawElements(GL_TRIANGLES, GLsizei(this->triangle_indices_size), GL_UNSIGNED_INT, nullptr));
} }
if (this->quad_indices_size > 0) { if (this->quad_indices_size > 0) {
glsafe(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, this->quad_indices_VBO_id)); glsafe(::glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, this->quad_indices_VBO_id));
glsafe(glDrawElements(GL_QUADS, GLsizei(this->quad_indices_size), GL_UNSIGNED_INT, nullptr)); glsafe(::glDrawElements(GL_QUADS, GLsizei(this->quad_indices_size), GL_UNSIGNED_INT, nullptr));
} }
glsafe(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0)); glsafe(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0));
} else { } else {
// Render in an immediate mode. // Render in an immediate mode.
if (! this->triangle_indices.empty()) if (! this->triangle_indices.empty())
glsafe(glDrawElements(GL_TRIANGLES, GLsizei(this->triangle_indices_size), GL_UNSIGNED_INT, this->triangle_indices.data())); glsafe(::glDrawElements(GL_TRIANGLES, GLsizei(this->triangle_indices_size), GL_UNSIGNED_INT, this->triangle_indices.data()));
if (! this->quad_indices.empty()) if (! this->quad_indices.empty())
glsafe(glDrawElements(GL_QUADS, GLsizei(this->quad_indices_size), GL_UNSIGNED_INT, this->quad_indices.data())); glsafe(::glDrawElements(GL_QUADS, GLsizei(this->quad_indices_size), GL_UNSIGNED_INT, this->quad_indices.data()));
} }
} else } else
glsafe(glDrawArrays(GL_TRIANGLES, 0, GLsizei(this->vertices_and_normals_interleaved_size / 6))); glsafe(::glDrawArrays(GL_TRIANGLES, 0, GLsizei(this->vertices_and_normals_interleaved_size / 6)));
if (this->vertices_and_normals_interleaved_VBO_id) if (this->vertices_and_normals_interleaved_VBO_id)
glsafe(glBindBuffer(GL_ARRAY_BUFFER, 0)); glsafe(::glBindBuffer(GL_ARRAY_BUFFER, 0));
glsafe(glDisableClientState(GL_VERTEX_ARRAY)); glsafe(::glDisableClientState(GL_VERTEX_ARRAY));
glsafe(glDisableClientState(GL_NORMAL_ARRAY)); glsafe(::glDisableClientState(GL_NORMAL_ARRAY));
} }
void GLIndexedVertexArray::render( void GLIndexedVertexArray::render(
@ -190,35 +191,35 @@ void GLIndexedVertexArray::render(
if (this->vertices_and_normals_interleaved_VBO_id) { if (this->vertices_and_normals_interleaved_VBO_id) {
// Render using the Vertex Buffer Objects. // Render using the Vertex Buffer Objects.
glsafe(glBindBuffer(GL_ARRAY_BUFFER, this->vertices_and_normals_interleaved_VBO_id)); glsafe(::glBindBuffer(GL_ARRAY_BUFFER, this->vertices_and_normals_interleaved_VBO_id));
glsafe(glVertexPointer(3, GL_FLOAT, 6 * sizeof(float), (const void*)(3 * sizeof(float)))); glsafe(::glVertexPointer(3, GL_FLOAT, 6 * sizeof(float), (const void*)(3 * sizeof(float))));
glsafe(glNormalPointer(GL_FLOAT, 6 * sizeof(float), nullptr)); glsafe(::glNormalPointer(GL_FLOAT, 6 * sizeof(float), nullptr));
glsafe(glEnableClientState(GL_VERTEX_ARRAY)); glsafe(::glEnableClientState(GL_VERTEX_ARRAY));
glsafe(glEnableClientState(GL_NORMAL_ARRAY)); glsafe(::glEnableClientState(GL_NORMAL_ARRAY));
if (this->triangle_indices_size > 0) { if (this->triangle_indices_size > 0) {
glsafe(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, this->triangle_indices_VBO_id)); glsafe(::glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, this->triangle_indices_VBO_id));
glsafe(glDrawElements(GL_TRIANGLES, GLsizei(std::min(this->triangle_indices_size, tverts_range.second - tverts_range.first)), GL_UNSIGNED_INT, (const void*)(tverts_range.first * 4))); glsafe(::glDrawElements(GL_TRIANGLES, GLsizei(std::min(this->triangle_indices_size, tverts_range.second - tverts_range.first)), GL_UNSIGNED_INT, (const void*)(tverts_range.first * 4)));
} }
if (this->quad_indices_size > 0) { if (this->quad_indices_size > 0) {
glsafe(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, this->quad_indices_VBO_id)); glsafe(::glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, this->quad_indices_VBO_id));
glsafe(glDrawElements(GL_QUADS, GLsizei(std::min(this->quad_indices_size, qverts_range.second - qverts_range.first)), GL_UNSIGNED_INT, (const void*)(qverts_range.first * 4))); glsafe(::glDrawElements(GL_QUADS, GLsizei(std::min(this->quad_indices_size, qverts_range.second - qverts_range.first)), GL_UNSIGNED_INT, (const void*)(qverts_range.first * 4)));
} }
glsafe(glBindBuffer(GL_ARRAY_BUFFER, 0)); glsafe(::glBindBuffer(GL_ARRAY_BUFFER, 0));
glsafe(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0)); glsafe(::glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0));
} else { } else {
// Render in an immediate mode. // Render in an immediate mode.
glsafe(glVertexPointer(3, GL_FLOAT, 6 * sizeof(float), this->vertices_and_normals_interleaved.data() + 3)); glsafe(::glVertexPointer(3, GL_FLOAT, 6 * sizeof(float), this->vertices_and_normals_interleaved.data() + 3));
glsafe(glNormalPointer(GL_FLOAT, 6 * sizeof(float), this->vertices_and_normals_interleaved.data())); glsafe(::glNormalPointer(GL_FLOAT, 6 * sizeof(float), this->vertices_and_normals_interleaved.data()));
glsafe(glEnableClientState(GL_VERTEX_ARRAY)); glsafe(::glEnableClientState(GL_VERTEX_ARRAY));
glsafe(glEnableClientState(GL_NORMAL_ARRAY)); glsafe(::glEnableClientState(GL_NORMAL_ARRAY));
if (! this->triangle_indices.empty()) if (! this->triangle_indices.empty())
glsafe(glDrawElements(GL_TRIANGLES, GLsizei(std::min(this->triangle_indices_size, tverts_range.second - tverts_range.first)), GL_UNSIGNED_INT, (const void*)(this->triangle_indices.data() + tverts_range.first))); glsafe(::glDrawElements(GL_TRIANGLES, GLsizei(std::min(this->triangle_indices_size, tverts_range.second - tverts_range.first)), GL_UNSIGNED_INT, (const void*)(this->triangle_indices.data() + tverts_range.first)));
if (! this->quad_indices.empty()) if (! this->quad_indices.empty())
glsafe(glDrawElements(GL_QUADS, GLsizei(std::min(this->quad_indices_size, qverts_range.second - qverts_range.first)), GL_UNSIGNED_INT, (const void*)(this->quad_indices.data() + qverts_range.first))); glsafe(::glDrawElements(GL_QUADS, GLsizei(std::min(this->quad_indices_size, qverts_range.second - qverts_range.first)), GL_UNSIGNED_INT, (const void*)(this->quad_indices.data() + qverts_range.first)));
} }
glsafe(glDisableClientState(GL_VERTEX_ARRAY)); glsafe(::glDisableClientState(GL_VERTEX_ARRAY));
glsafe(glDisableClientState(GL_NORMAL_ARRAY)); glsafe(::glDisableClientState(GL_NORMAL_ARRAY));
} }
const float GLVolume::SELECTED_COLOR[4] = { 0.0f, 1.0f, 0.0f, 1.0f }; const float GLVolume::SELECTED_COLOR[4] = { 0.0f, 1.0f, 0.0f, 1.0f };
@ -736,7 +737,7 @@ int GLVolumeCollection::load_wipe_tower_preview(
typedef std::pair<GLVolume*, double> GLVolumeWithZ; typedef std::pair<GLVolume*, double> GLVolumeWithZ;
typedef std::vector<GLVolumeWithZ> GLVolumesWithZList; typedef std::vector<GLVolumeWithZ> GLVolumesWithZList;
static GLVolumesWithZList volumes_to_render(const GLVolumePtrs& volumes, GLVolumeCollection::ERenderType type, std::function<bool(const GLVolume&)> filter_func) static GLVolumesWithZList volumes_to_render(const GLVolumePtrs& volumes, GLVolumeCollection::ERenderType type, const Transform3d& view_matrix, std::function<bool(const GLVolume&)> filter_func)
{ {
GLVolumesWithZList list; GLVolumesWithZList list;
list.reserve(volumes.size()); list.reserve(volumes.size());
@ -753,12 +754,9 @@ static GLVolumesWithZList volumes_to_render(const GLVolumePtrs& volumes, GLVolum
if ((type == GLVolumeCollection::Transparent) && (list.size() > 1)) if ((type == GLVolumeCollection::Transparent) && (list.size() > 1))
{ {
Transform3d modelview_matrix;
glsafe(::glGetDoublev(GL_MODELVIEW_MATRIX, modelview_matrix.data()));
for (GLVolumeWithZ& volume : list) for (GLVolumeWithZ& volume : list)
{ {
volume.second = volume.first->bounding_box.transformed(modelview_matrix * volume.first->world_matrix()).max(2); volume.second = volume.first->bounding_box.transformed(view_matrix * volume.first->world_matrix()).max(2);
} }
std::sort(list.begin(), list.end(), std::sort(list.begin(), list.end(),
@ -769,7 +767,7 @@ static GLVolumesWithZList volumes_to_render(const GLVolumePtrs& volumes, GLVolum
return list; return list;
} }
void GLVolumeCollection::render_VBOs(GLVolumeCollection::ERenderType type, bool disable_cullface, std::function<bool(const GLVolume&)> filter_func) const void GLVolumeCollection::render_VBOs(GLVolumeCollection::ERenderType type, bool disable_cullface, const Transform3d& view_matrix, std::function<bool(const GLVolume&)> filter_func) const
{ {
glsafe(::glEnable(GL_BLEND)); glsafe(::glEnable(GL_BLEND));
glsafe(::glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)); glsafe(::glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA));
@ -783,12 +781,13 @@ void GLVolumeCollection::render_VBOs(GLVolumeCollection::ERenderType type, bool
GLint current_program_id; GLint current_program_id;
glsafe(::glGetIntegerv(GL_CURRENT_PROGRAM, &current_program_id)); glsafe(::glGetIntegerv(GL_CURRENT_PROGRAM, &current_program_id));
GLint color_id = (current_program_id > 0) ? glGetUniformLocation(current_program_id, "uniform_color") : -1; GLint color_id = (current_program_id > 0) ? ::glGetUniformLocation(current_program_id, "uniform_color") : -1;
GLint z_range_id = (current_program_id > 0) ? glGetUniformLocation(current_program_id, "z_range") : -1; GLint z_range_id = (current_program_id > 0) ? ::glGetUniformLocation(current_program_id, "z_range") : -1;
GLint print_box_min_id = (current_program_id > 0) ? glGetUniformLocation(current_program_id, "print_box.min") : -1; GLint print_box_min_id = (current_program_id > 0) ? ::glGetUniformLocation(current_program_id, "print_box.min") : -1;
GLint print_box_max_id = (current_program_id > 0) ? glGetUniformLocation(current_program_id, "print_box.max") : -1; GLint print_box_max_id = (current_program_id > 0) ? ::glGetUniformLocation(current_program_id, "print_box.max") : -1;
GLint print_box_detection_id = (current_program_id > 0) ? glGetUniformLocation(current_program_id, "print_box.volume_detection") : -1; GLint print_box_detection_id = (current_program_id > 0) ? ::glGetUniformLocation(current_program_id, "print_box.volume_detection") : -1;
GLint print_box_worldmatrix_id = (current_program_id > 0) ? glGetUniformLocation(current_program_id, "print_box.volume_world_matrix") : -1; GLint print_box_worldmatrix_id = (current_program_id > 0) ? ::glGetUniformLocation(current_program_id, "print_box.volume_world_matrix") : -1;
glcheck();
if (print_box_min_id != -1) if (print_box_min_id != -1)
glsafe(::glUniform3fv(print_box_min_id, 1, (const GLfloat*)print_box_min)); glsafe(::glUniform3fv(print_box_min_id, 1, (const GLfloat*)print_box_min));
@ -799,7 +798,7 @@ void GLVolumeCollection::render_VBOs(GLVolumeCollection::ERenderType type, bool
if (z_range_id != -1) if (z_range_id != -1)
glsafe(::glUniform2fv(z_range_id, 1, (const GLfloat*)z_range)); glsafe(::glUniform2fv(z_range_id, 1, (const GLfloat*)z_range));
GLVolumesWithZList to_render = volumes_to_render(this->volumes, type, filter_func); GLVolumesWithZList to_render = volumes_to_render(this->volumes, type, view_matrix, filter_func);
for (GLVolumeWithZ& volume : to_render) { for (GLVolumeWithZ& volume : to_render) {
volume.first->set_render_color(); volume.first->set_render_color();
volume.first->render_VBOs(color_id, print_box_detection_id, print_box_worldmatrix_id); volume.first->render_VBOs(color_id, print_box_detection_id, print_box_worldmatrix_id);
@ -817,32 +816,32 @@ void GLVolumeCollection::render_VBOs(GLVolumeCollection::ERenderType type, bool
glsafe(::glDisable(GL_BLEND)); glsafe(::glDisable(GL_BLEND));
} }
void GLVolumeCollection::render_legacy(ERenderType type, bool disable_cullface, std::function<bool(const GLVolume&)> filter_func) const void GLVolumeCollection::render_legacy(ERenderType type, bool disable_cullface, const Transform3d& view_matrix, std::function<bool(const GLVolume&)> filter_func) const
{ {
glsafe(glEnable(GL_BLEND)); glsafe(::glEnable(GL_BLEND));
glsafe(glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)); glsafe(::glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA));
glsafe(glCullFace(GL_BACK)); glsafe(::glCullFace(GL_BACK));
if (disable_cullface) if (disable_cullface)
glsafe(::glDisable(GL_CULL_FACE)); glsafe(::glDisable(GL_CULL_FACE));
glsafe(glEnableClientState(GL_VERTEX_ARRAY)); glsafe(::glEnableClientState(GL_VERTEX_ARRAY));
glsafe(glEnableClientState(GL_NORMAL_ARRAY)); glsafe(::glEnableClientState(GL_NORMAL_ARRAY));
GLVolumesWithZList to_render = volumes_to_render(this->volumes, type, filter_func); GLVolumesWithZList to_render = volumes_to_render(this->volumes, type, view_matrix, filter_func);
for (GLVolumeWithZ& volume : to_render) for (GLVolumeWithZ& volume : to_render)
{ {
volume.first->set_render_color(); volume.first->set_render_color();
volume.first->render_legacy(); volume.first->render_legacy();
} }
glsafe(glDisableClientState(GL_VERTEX_ARRAY)); glsafe(::glDisableClientState(GL_VERTEX_ARRAY));
glsafe(glDisableClientState(GL_NORMAL_ARRAY)); glsafe(::glDisableClientState(GL_NORMAL_ARRAY));
if (disable_cullface) if (disable_cullface)
glsafe(::glEnable(GL_CULL_FACE)); glsafe(::glEnable(GL_CULL_FACE));
glsafe(glDisable(GL_BLEND)); glsafe(::glDisable(GL_BLEND));
} }
bool GLVolumeCollection::check_outside_state(const DynamicPrintConfig* config, ModelInstance::EPrintVolumeState* out_state) bool GLVolumeCollection::check_outside_state(const DynamicPrintConfig* config, ModelInstance::EPrintVolumeState* out_state)
@ -1771,7 +1770,8 @@ void GLModel::render_VBOs() const
GLint current_program_id; GLint current_program_id;
glsafe(::glGetIntegerv(GL_CURRENT_PROGRAM, &current_program_id)); glsafe(::glGetIntegerv(GL_CURRENT_PROGRAM, &current_program_id));
GLint color_id = (current_program_id > 0) ? glGetUniformLocation(current_program_id, "uniform_color") : -1; GLint color_id = (current_program_id > 0) ? ::glGetUniformLocation(current_program_id, "uniform_color") : -1;
glcheck();
m_volume.render_VBOs(color_id, -1, -1); m_volume.render_VBOs(color_id, -1, -1);
glsafe(::glBindBuffer(GL_ARRAY_BUFFER, 0)); glsafe(::glBindBuffer(GL_ARRAY_BUFFER, 0));

6
src/slic3r/GUI/3DScene.hpp
View file

@ -19,9 +19,11 @@
extern void glAssertRecentCallImpl(const char *file_name, unsigned int line, const char *function_name); extern void glAssertRecentCallImpl(const char *file_name, unsigned int line, const char *function_name);
inline void glAssertRecentCall() { glAssertRecentCallImpl(__FILE__, __LINE__, __FUNCTION__); } inline void glAssertRecentCall() { glAssertRecentCallImpl(__FILE__, __LINE__, __FUNCTION__); }
#define glsafe(cmd) do { cmd; glAssertRecentCallImpl(__FILE__, __LINE__, __FUNCTION__); } while (false) #define glsafe(cmd) do { cmd; glAssertRecentCallImpl(__FILE__, __LINE__, __FUNCTION__); } while (false)
#define glcheck() do { glAssertRecentCallImpl(__FILE__, __LINE__, __FUNCTION__); } while (false)
#else #else
inline void glAssertRecentCall() { } inline void glAssertRecentCall() { }
#define glsafe(cmd) cmd #define glsafe(cmd) cmd
#define glcheck()
#endif #endif
namespace Slic3r { namespace Slic3r {
@ -463,8 +465,8 @@ public:
int obj_idx, float pos_x, float pos_y, float width, float depth, float height, float rotation_angle, bool use_VBOs, bool size_unknown, float brim_width); int obj_idx, float pos_x, float pos_y, float width, float depth, float height, float rotation_angle, bool use_VBOs, bool size_unknown, float brim_width);
// Render the volumes by OpenGL. // Render the volumes by OpenGL.
void render_VBOs(ERenderType type, bool disable_cullface, std::function<bool(const GLVolume&)> filter_func = std::function<bool(const GLVolume&)>()) const; void render_VBOs(ERenderType type, bool disable_cullface, const Transform3d& view_matrix, std::function<bool(const GLVolume&)> filter_func = std::function<bool(const GLVolume&)>()) const;
void render_legacy(ERenderType type, bool disable_cullface, std::function<bool(const GLVolume&)> filter_func = std::function<bool(const GLVolume&)>()) const; void render_legacy(ERenderType type, bool disable_cullface, const Transform3d& view_matrix, std::function<bool(const GLVolume&)> filter_func = std::function<bool(const GLVolume&)>()) const;
// Finalize the initialization of the geometry & indices, // Finalize the initialization of the geometry & indices,
// upload the geometry and indices to OpenGL VBO objects // upload the geometry and indices to OpenGL VBO objects

70
src/slic3r/GUI/Camera.cpp
View file

@ -1,9 +1,21 @@
#include "libslic3r/libslic3r.h" #include "libslic3r/libslic3r.h"
#include "Camera.hpp" #include "Camera.hpp"
#include "3DScene.hpp"
#include <GL/glew.h>
static const float GIMBALL_LOCK_THETA_MAX = 180.0f; static const float GIMBALL_LOCK_THETA_MAX = 180.0f;
// phi / theta angles to orient the camera.
static const float VIEW_DEFAULT[2] = { 45.0f, 45.0f };
static const float VIEW_LEFT[2] = { 90.0f, 90.0f };
static const float VIEW_RIGHT[2] = { -90.0f, 90.0f };
static const float VIEW_TOP[2] = { 0.0f, 0.0f };
static const float VIEW_BOTTOM[2] = { 0.0f, 180.0f };
static const float VIEW_FRONT[2] = { 0.0f, 90.0f };
static const float VIEW_REAR[2] = { 180.0f, 90.0f };
namespace Slic3r { namespace Slic3r {
namespace GUI { namespace GUI {
@ -57,6 +69,64 @@ void Camera::set_scene_box(const BoundingBoxf3& box)
m_scene_box = box; m_scene_box = box;
} }
bool Camera::select_view(const std::string& direction)
{
const float* dir_vec = nullptr;
if (direction == "iso")
dir_vec = VIEW_DEFAULT;
else if (direction == "left")
dir_vec = VIEW_LEFT;
else if (direction == "right")
dir_vec = VIEW_RIGHT;
else if (direction == "top")
dir_vec = VIEW_TOP;
else if (direction == "bottom")
dir_vec = VIEW_BOTTOM;
else if (direction == "front")
dir_vec = VIEW_FRONT;
else if (direction == "rear")
dir_vec = VIEW_REAR;
if (dir_vec != nullptr)
{
phi = dir_vec[0];
set_theta(dir_vec[1], false);
return true;
}
else
return false;
}
void Camera::apply_viewport(int x, int y, unsigned int w, unsigned int h) const
{
glsafe(::glViewport(0, 0, w, h));
glsafe(::glGetIntegerv(GL_VIEWPORT, m_viewport.data()));
}
void Camera::apply_view_matrix() const
{
glsafe(::glMatrixMode(GL_MODELVIEW));
glsafe(::glLoadIdentity());
glsafe(::glRotatef(-m_theta, 1.0f, 0.0f, 0.0f)); // pitch
glsafe(::glRotatef(phi, 0.0f, 0.0f, 1.0f)); // yaw
glsafe(::glTranslated(-m_target(0), -m_target(1), -m_target(2)));
glsafe(::glGetDoublev(GL_MODELVIEW_MATRIX, m_view_matrix.data()));
}
void Camera::apply_ortho_projection(float x_min, float x_max, float y_min, float y_max, float z_min, float z_max) const
{
glsafe(::glMatrixMode(GL_PROJECTION));
glsafe(::glLoadIdentity());
glsafe(::glOrtho(x_min, x_max, y_min, y_max, z_min, z_max));
glsafe(::glGetDoublev(GL_PROJECTION_MATRIX, m_projection_matrix.data()));
glsafe(::glMatrixMode(GL_MODELVIEW));
}
} // GUI } // GUI
} // Slic3r } // Slic3r

21
src/slic3r/GUI/Camera.hpp
View file

@ -2,6 +2,7 @@
#define slic3r_Camera_hpp_ #define slic3r_Camera_hpp_
#include "libslic3r/BoundingBox.hpp" #include "libslic3r/BoundingBox.hpp"
#include <array>
namespace Slic3r { namespace Slic3r {
namespace GUI { namespace GUI {
@ -26,6 +27,10 @@ private:
Vec3d m_target; Vec3d m_target;
float m_theta; float m_theta;
mutable std::array<int, 4> m_viewport;
mutable Transform3d m_view_matrix;
mutable Transform3d m_projection_matrix;
BoundingBoxf3 m_scene_box; BoundingBoxf3 m_scene_box;
public: public:
@ -41,6 +46,22 @@ public:
const BoundingBoxf3& get_scene_box() const { return m_scene_box; } const BoundingBoxf3& get_scene_box() const { return m_scene_box; }
void set_scene_box(const BoundingBoxf3& box); void set_scene_box(const BoundingBoxf3& box);
bool select_view(const std::string& direction);
const std::array<int, 4>& get_viewport() const { return m_viewport; }
const Transform3d& get_view_matrix() const { return m_view_matrix; }
const Transform3d& get_projection_matrix() const { return m_projection_matrix; }
Vec3d get_dir_right() const { return m_view_matrix.matrix().block(0, 0, 3, 3).row(0); }
Vec3d get_dir_up() const { return m_view_matrix.matrix().block(0, 0, 3, 3).row(1); }
Vec3d get_dir_forward() const { return m_view_matrix.matrix().block(0, 0, 3, 3).row(2); }
Vec3d get_position() const { return m_view_matrix.matrix().block(0, 0, 3, 3).row(3); }
void apply_viewport(int x, int y, unsigned int w, unsigned int h) const;
void apply_view_matrix() const;
void apply_ortho_projection(float x_min, float x_max, float y_min, float y_max, float z_min, float z_max) const;
}; };
} // GUI } // GUI

1675
src/slic3r/GUI/GLCanvas3D.cpp
View file

File diff suppressed because it is too large Load diff

179
src/slic3r/GUI/GLCanvas3D.hpp
View file

@ -10,6 +10,7 @@
#include "3DBed.hpp" #include "3DBed.hpp"
#include "Camera.hpp" #include "Camera.hpp"
#include "Selection.hpp" #include "Selection.hpp"
#include "Gizmos/GLGizmosManager.hpp"
#include <float.h> #include <float.h>
@ -64,33 +65,6 @@ public:
void set_scale_factor(int height); void set_scale_factor(int height);
}; };
class Rect
{
float m_left;
float m_top;
float m_right;
float m_bottom;
public:
Rect();
Rect(float left, float top, float right, float bottom);
float get_left() const;
void set_left(float left);
float get_top() const;
void set_top(float top);
float get_right() const;
void set_right(float right);
float get_bottom() const;
void set_bottom(float bottom);
float get_width() const { return m_right - m_left; }
float get_height() const { return m_top - m_bottom; }
};
wxDECLARE_EVENT(EVT_GLCANVAS_OBJECT_SELECT, SimpleEvent); wxDECLARE_EVENT(EVT_GLCANVAS_OBJECT_SELECT, SimpleEvent);
using Vec2dEvent = Event<Vec2d>; using Vec2dEvent = Event<Vec2d>;
@ -118,22 +92,6 @@ wxDECLARE_EVENT(EVT_GLCANVAS_UPDATE_BED_SHAPE, SimpleEvent);
wxDECLARE_EVENT(EVT_GLCANVAS_TAB, SimpleEvent); wxDECLARE_EVENT(EVT_GLCANVAS_TAB, SimpleEvent);
wxDECLARE_EVENT(EVT_GLCANVAS_RESETGIZMOS, SimpleEvent); wxDECLARE_EVENT(EVT_GLCANVAS_RESETGIZMOS, SimpleEvent);
// this describes events being passed from GLCanvas3D to SlaSupport gizmo
enum class SLAGizmoEventType {
LeftDown = 1,
LeftUp,
RightDown,
Dragging,
Delete,
SelectAll,
ShiftUp,
ApplyChanges,
DiscardChanges,
AutomaticGeneration,
ManualEditing
};
class GLCanvas3D class GLCanvas3D
{ {
struct GCodePreviewVolumeIndex struct GCodePreviewVolumeIndex
@ -314,7 +272,6 @@ class GLCanvas3D
Vec2d position; Vec2d position;
Vec3d scene_position; Vec3d scene_position;
Drag drag; Drag drag;
bool ignore_up_event;
Mouse(); Mouse();
@ -358,118 +315,6 @@ public:
}; };
private: private:
class Gizmos
{
public:
#if ENABLE_SVG_ICONS
static const float Default_Icons_Size;
#endif // ENABLE_SVG_ICONS
enum EType : unsigned char
{
Undefined,
Move,
Scale,
Rotate,
Flatten,
Cut,
SlaSupports,
Num_Types
};
private:
bool m_enabled;
typedef std::map<EType, GLGizmoBase*> GizmosMap;
GizmosMap m_gizmos;
#if ENABLE_SVG_ICONS
mutable GLTexture m_icons_texture;
mutable bool m_icons_texture_dirty;
#else
ItemsIconsTexture m_icons_texture;
#endif // ENABLE_SVG_ICONS
BackgroundTexture m_background_texture;
EType m_current;
#if ENABLE_SVG_ICONS
float m_overlay_icons_size;
float m_overlay_scale;
#else
float m_overlay_icons_scale;
#endif // ENABLE_SVG_ICONS
float m_overlay_border;
float m_overlay_gap_y;
public:
Gizmos();
~Gizmos();
bool init(GLCanvas3D& parent);
bool is_enabled() const;
void set_enabled(bool enable);
#if ENABLE_SVG_ICONS
void set_overlay_icon_size(float size);
#endif // ENABLE_SVG_ICONS
void set_overlay_scale(float scale);
std::string update_hover_state(const GLCanvas3D& canvas, const Vec2d& mouse_pos, const Selection& selection);
void update_on_off_state(const GLCanvas3D& canvas, const Vec2d& mouse_pos, const Selection& selection);
void update_on_off_state(const Selection& selection);
void reset_all_states();
void set_hover_id(int id);
void enable_grabber(EType type, unsigned int id, bool enable);
bool overlay_contains_mouse(const GLCanvas3D& canvas, const Vec2d& mouse_pos) const;
bool grabber_contains_mouse() const;
void update(const Linef3& mouse_ray, const Selection& selection, bool shift_down, const Point* mouse_pos = nullptr);
Rect get_reset_rect_viewport(const GLCanvas3D& canvas) const;
EType get_current_type() const;
bool is_running() const;
bool handle_shortcut(int key, const Selection& selection);
bool is_dragging() const;
void start_dragging(const Selection& selection);
void stop_dragging();
Vec3d get_displacement() const;
Vec3d get_scale() const;
void set_scale(const Vec3d& scale);
Vec3d get_rotation() const;
void set_rotation(const Vec3d& rotation);
Vec3d get_flattening_normal() const;
void set_flattening_data(const ModelObject* model_object);
void set_sla_support_data(ModelObject* model_object, const Selection& selection);
bool gizmo_event(SLAGizmoEventType action, const Vec2d& mouse_position = Vec2d::Zero(), bool shift_down = false);
void render_current_gizmo(const Selection& selection) const;
void render_current_gizmo_for_picking_pass(const Selection& selection) const;
void render_overlay(const GLCanvas3D& canvas, const Selection& selection) const;
private:
void reset();
void do_render_overlay(const GLCanvas3D& canvas, const Selection& selection) const;
void do_render_current_gizmo(const Selection& selection) const;
float get_total_overlay_height() const;
float get_total_overlay_width() const;
GLGizmoBase* get_current() const;
#if ENABLE_SVG_ICONS
bool generate_icons_texture() const;
#endif // ENABLE_SVG_ICONS
};
struct SlaCap struct SlaCap
{ {
struct Triangles struct Triangles
@ -557,7 +402,7 @@ private:
LayersEditing m_layers_editing; LayersEditing m_layers_editing;
Shader m_shader; Shader m_shader;
Mouse m_mouse; Mouse m_mouse;
mutable Gizmos m_gizmos; mutable GLGizmosManager m_gizmos;
mutable GLToolbar m_toolbar; mutable GLToolbar m_toolbar;
ClippingPlane m_clipping_planes[2]; ClippingPlane m_clipping_planes[2];
bool m_use_clipping_planes; bool m_use_clipping_planes;
@ -639,7 +484,7 @@ public:
void set_color_by(const std::string& value); void set_color_by(const std::string& value);
float get_camera_zoom() const; const Camera& get_camera() const { return m_camera; }
BoundingBoxf3 volumes_bounding_box() const; BoundingBoxf3 volumes_bounding_box() const;
BoundingBoxf3 scene_bounding_box() const; BoundingBoxf3 scene_bounding_box() const;
@ -721,6 +566,19 @@ public:
void update_ui_from_settings(); void update_ui_from_settings();
float get_view_toolbar_height() const { return m_view_toolbar.get_height(); }
int get_move_volume_id() const { return m_mouse.drag.move_volume_idx; }
int get_hover_volume_id() const { return m_hover_volume_id; }
// Returns the view ray line, in world coordinate, at the given mouse position.
Linef3 mouse_ray(const Point& mouse_pos);
void set_mouse_as_dragging() { m_mouse.dragging = true; }
void disable_regenerate_volumes() { m_regenerate_volumes = false; }
void refresh_camera_scene_box() { m_camera.set_scene_box(scene_bounding_box()); }
bool is_mouse_dragging() const { return m_mouse.dragging; }
private: private:
bool _is_shown_on_screen() const; bool _is_shown_on_screen() const;
@ -736,7 +594,6 @@ private:
void _refresh_if_shown_on_screen(); void _refresh_if_shown_on_screen();
void _camera_tranform() const;
void _picking_pass() const; void _picking_pass() const;
void _render_background() const; void _render_background() const;
void _render_bed(float theta) const; void _render_bed(float theta) const;
@ -760,7 +617,6 @@ private:
void _render_selection_sidebar_hints() const; void _render_selection_sidebar_hints() const;
void _update_volumes_hover_state() const; void _update_volumes_hover_state() const;
void _update_gizmos_data();
void _perform_layer_editing_action(wxMouseEvent* evt = nullptr); void _perform_layer_editing_action(wxMouseEvent* evt = nullptr);
@ -771,9 +627,6 @@ private:
// Convert the screen space coordinate to world coordinate on the bed. // Convert the screen space coordinate to world coordinate on the bed.
Vec3d _mouse_to_bed_3d(const Point& mouse_pos); Vec3d _mouse_to_bed_3d(const Point& mouse_pos);
// Returns the view ray line, in world coordinate, at the given mouse position.
Linef3 mouse_ray(const Point& mouse_pos);
void _start_timer(); void _start_timer();
void _stop_timer(); void _stop_timer();

62
src/slic3r/GUI/GLShader.cpp
View file

@ -3,6 +3,7 @@
#include "GLShader.hpp" #include "GLShader.hpp"
#include "libslic3r/Utils.hpp" #include "libslic3r/Utils.hpp"
#include "3DScene.hpp"
#include <boost/nowide/fstream.hpp> #include <boost/nowide/fstream.hpp>
#include <string> #include <string>
@ -52,21 +53,22 @@ bool GLShader::load_from_text(const char *fragment_shader, const char *vertex_sh
} }
if (fragment_shader != nullptr) { if (fragment_shader != nullptr) {
this->fragment_program_id = glCreateShader(GL_FRAGMENT_SHADER); this->fragment_program_id = ::glCreateShader(GL_FRAGMENT_SHADER);
glcheck();
if (this->fragment_program_id == 0) { if (this->fragment_program_id == 0) {
last_error = "glCreateShader(GL_FRAGMENT_SHADER) failed."; last_error = "glCreateShader(GL_FRAGMENT_SHADER) failed.";
return false; return false;
} }
GLint len = (GLint)strlen(fragment_shader); GLint len = (GLint)strlen(fragment_shader);
glShaderSource(this->fragment_program_id, 1, &fragment_shader, &len); glsafe(::glShaderSource(this->fragment_program_id, 1, &fragment_shader, &len));
glCompileShader(this->fragment_program_id); glsafe(::glCompileShader(this->fragment_program_id));
GLint params; GLint params;
glGetShaderiv(this->fragment_program_id, GL_COMPILE_STATUS, &params); glsafe(::glGetShaderiv(this->fragment_program_id, GL_COMPILE_STATUS, &params));
if (params == GL_FALSE) { if (params == GL_FALSE) {
// Compilation failed. Get the log. // Compilation failed. Get the log.
glGetShaderiv(this->fragment_program_id, GL_INFO_LOG_LENGTH, &params); glsafe(::glGetShaderiv(this->fragment_program_id, GL_INFO_LOG_LENGTH, &params));
std::vector<char> msg(params); std::vector<char> msg(params);
glGetShaderInfoLog(this->fragment_program_id, params, &params, msg.data()); glsafe(::glGetShaderInfoLog(this->fragment_program_id, params, &params, msg.data()));
this->last_error = std::string("Fragment shader compilation failed:\n") + msg.data(); this->last_error = std::string("Fragment shader compilation failed:\n") + msg.data();
this->release(); this->release();
return false; return false;
@ -74,22 +76,23 @@ bool GLShader::load_from_text(const char *fragment_shader, const char *vertex_sh
} }
if (vertex_shader != nullptr) { if (vertex_shader != nullptr) {
this->vertex_program_id = glCreateShader(GL_VERTEX_SHADER); this->vertex_program_id = ::glCreateShader(GL_VERTEX_SHADER);
glcheck();
if (this->vertex_program_id == 0) { if (this->vertex_program_id == 0) {
last_error = "glCreateShader(GL_VERTEX_SHADER) failed."; last_error = "glCreateShader(GL_VERTEX_SHADER) failed.";
this->release(); this->release();
return false; return false;
} }
GLint len = (GLint)strlen(vertex_shader); GLint len = (GLint)strlen(vertex_shader);
glShaderSource(this->vertex_program_id, 1, &vertex_shader, &len); glsafe(::glShaderSource(this->vertex_program_id, 1, &vertex_shader, &len));
glCompileShader(this->vertex_program_id); glsafe(::glCompileShader(this->vertex_program_id));
GLint params; GLint params;
glGetShaderiv(this->vertex_program_id, GL_COMPILE_STATUS, &params); glsafe(::glGetShaderiv(this->vertex_program_id, GL_COMPILE_STATUS, &params));
if (params == GL_FALSE) { if (params == GL_FALSE) {
// Compilation failed. Get the log. // Compilation failed. Get the log.
glGetShaderiv(this->vertex_program_id, GL_INFO_LOG_LENGTH, &params); glsafe(::glGetShaderiv(this->vertex_program_id, GL_INFO_LOG_LENGTH, &params));
std::vector<char> msg(params); std::vector<char> msg(params);
glGetShaderInfoLog(this->vertex_program_id, params, &params, msg.data()); glsafe(::glGetShaderInfoLog(this->vertex_program_id, params, &params, msg.data()));
this->last_error = std::string("Vertex shader compilation failed:\n") + msg.data(); this->last_error = std::string("Vertex shader compilation failed:\n") + msg.data();
this->release(); this->release();
return false; return false;
@ -97,7 +100,8 @@ bool GLShader::load_from_text(const char *fragment_shader, const char *vertex_sh
} }
// Link shaders // Link shaders
this->shader_program_id = glCreateProgram(); this->shader_program_id = ::glCreateProgram();
glcheck();
if (this->shader_program_id == 0) { if (this->shader_program_id == 0) {
last_error = "glCreateProgram() failed."; last_error = "glCreateProgram() failed.";
this->release(); this->release();
@ -105,18 +109,18 @@ bool GLShader::load_from_text(const char *fragment_shader, const char *vertex_sh
} }
if (this->fragment_program_id) if (this->fragment_program_id)
glAttachShader(this->shader_program_id, this->fragment_program_id); glsafe(::glAttachShader(this->shader_program_id, this->fragment_program_id));
if (this->vertex_program_id) if (this->vertex_program_id)
glAttachShader(this->shader_program_id, this->vertex_program_id); glsafe(::glAttachShader(this->shader_program_id, this->vertex_program_id));
glLinkProgram(this->shader_program_id); glsafe(::glLinkProgram(this->shader_program_id));
GLint params; GLint params;
glGetProgramiv(this->shader_program_id, GL_LINK_STATUS, &params); glsafe(::glGetProgramiv(this->shader_program_id, GL_LINK_STATUS, &params));
if (params == GL_FALSE) { if (params == GL_FALSE) {
// Linking failed. Get the log. // Linking failed. Get the log.
glGetProgramiv(this->vertex_program_id, GL_INFO_LOG_LENGTH, &params); glsafe(::glGetProgramiv(this->vertex_program_id, GL_INFO_LOG_LENGTH, &params));
std::vector<char> msg(params); std::vector<char> msg(params);
glGetProgramInfoLog(this->vertex_program_id, params, &params, msg.data()); glsafe(::glGetProgramInfoLog(this->vertex_program_id, params, &params, msg.data()));
this->last_error = std::string("Shader linking failed:\n") + msg.data(); this->last_error = std::string("Shader linking failed:\n") + msg.data();
this->release(); this->release();
return false; return false;
@ -165,31 +169,31 @@ void GLShader::release()
{ {
if (this->shader_program_id) { if (this->shader_program_id) {
if (this->vertex_program_id) if (this->vertex_program_id)
glDetachShader(this->shader_program_id, this->vertex_program_id); glsafe(::glDetachShader(this->shader_program_id, this->vertex_program_id));
if (this->fragment_program_id) if (this->fragment_program_id)
glDetachShader(this->shader_program_id, this->fragment_program_id); glsafe(::glDetachShader(this->shader_program_id, this->fragment_program_id));
glDeleteProgram(this->shader_program_id); glsafe(::glDeleteProgram(this->shader_program_id));
this->shader_program_id = 0; this->shader_program_id = 0;
} }
if (this->vertex_program_id) { if (this->vertex_program_id) {
glDeleteShader(this->vertex_program_id); glsafe(::glDeleteShader(this->vertex_program_id));
this->vertex_program_id = 0; this->vertex_program_id = 0;
} }
if (this->fragment_program_id) { if (this->fragment_program_id) {
glDeleteShader(this->fragment_program_id); glsafe(::glDeleteShader(this->fragment_program_id));
this->fragment_program_id = 0; this->fragment_program_id = 0;
} }
} }
void GLShader::enable() const void GLShader::enable() const
{ {
glUseProgram(this->shader_program_id); glsafe(::glUseProgram(this->shader_program_id));
} }
void GLShader::disable() const void GLShader::disable() const
{ {
glUseProgram(0); glsafe(::glUseProgram(0));
} }
// Return shader vertex attribute ID // Return shader vertex attribute ID
@ -208,7 +212,7 @@ bool GLShader::set_uniform(const char *name, float value) const
{ {
int id = this->get_uniform_location(name); int id = this->get_uniform_location(name);
if (id >= 0) { if (id >= 0) {
glUniform1fARB(id, value); glsafe(::glUniform1fARB(id, value));
return true; return true;
} }
return false; return false;
@ -219,7 +223,7 @@ bool GLShader::set_uniform(const char* name, const float* matrix) const
int id = get_uniform_location(name); int id = get_uniform_location(name);
if (id >= 0) if (id >= 0)
{ {
::glUniformMatrix4fv(id, 1, GL_FALSE, (const GLfloat*)matrix); glsafe(::glUniformMatrix4fv(id, 1, GL_FALSE, (const GLfloat*)matrix));
return true; return true;
} }
return false; return false;
@ -230,7 +234,7 @@ bool GLShader::set_uniform(const char* name, int value) const
int id = get_uniform_location(name); int id = get_uniform_location(name);
if (id >= 0) if (id >= 0)
{ {
::glUniform1i(id, value); glsafe(::glUniform1i(id, value));
return true; return true;
} }
return false; return false;

82
src/slic3r/GUI/GLTexture.cpp
View file

@ -1,6 +1,8 @@
#include "libslic3r/libslic3r.h" #include "libslic3r/libslic3r.h"
#include "GLTexture.hpp" #include "GLTexture.hpp"
#include "3DScene.hpp"
#include <GL/glew.h> #include <GL/glew.h>
#include <wx/image.h> #include <wx/image.h>
@ -173,15 +175,15 @@ bool GLTexture::load_from_svg_files_as_sprites_array(const std::vector<std::stri
nsvgDeleteRasterizer(rast); nsvgDeleteRasterizer(rast);
// sends data to gpu // sends data to gpu
::glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glsafe(::glPixelStorei(GL_UNPACK_ALIGNMENT, 1));
::glGenTextures(1, &m_id); glsafe(::glGenTextures(1, &m_id));
::glBindTexture(GL_TEXTURE_2D, m_id); glsafe(::glBindTexture(GL_TEXTURE_2D, m_id));
::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (GLsizei)m_width, (GLsizei)m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data()); glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (GLsizei)m_width, (GLsizei)m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data()));
::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0); glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0));
::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
::glBindTexture(GL_TEXTURE_2D, 0); glsafe(::glBindTexture(GL_TEXTURE_2D, 0));
m_source = filenames.front(); m_source = filenames.front();
@ -214,7 +216,7 @@ bool GLTexture::load_from_svg_files_as_sprites_array(const std::vector<std::stri
void GLTexture::reset() void GLTexture::reset()
{ {
if (m_id != 0) if (m_id != 0)
::glDeleteTextures(1, &m_id); glsafe(::glDeleteTextures(1, &m_id));
m_id = 0; m_id = 0;
m_width = 0; m_width = 0;
@ -229,25 +231,25 @@ void GLTexture::render_texture(unsigned int tex_id, float left, float right, flo
void GLTexture::render_sub_texture(unsigned int tex_id, float left, float right, float bottom, float top, const GLTexture::Quad_UVs& uvs) void GLTexture::render_sub_texture(unsigned int tex_id, float left, float right, float bottom, float top, const GLTexture::Quad_UVs& uvs)
{ {
::glEnable(GL_BLEND); glsafe(::glEnable(GL_BLEND));
::glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glsafe(::glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA));
::glEnable(GL_TEXTURE_2D); glsafe(::glEnable(GL_TEXTURE_2D));
::glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); glsafe(::glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE));
::glBindTexture(GL_TEXTURE_2D, (GLuint)tex_id); glsafe(::glBindTexture(GL_TEXTURE_2D, (GLuint)tex_id));
::glBegin(GL_QUADS); ::glBegin(GL_QUADS);
::glTexCoord2f(uvs.left_bottom.u, uvs.left_bottom.v); ::glVertex2f(left, bottom); ::glTexCoord2f(uvs.left_bottom.u, uvs.left_bottom.v); ::glVertex2f(left, bottom);
::glTexCoord2f(uvs.right_bottom.u, uvs.right_bottom.v); ::glVertex2f(right, bottom); ::glTexCoord2f(uvs.right_bottom.u, uvs.right_bottom.v); ::glVertex2f(right, bottom);
::glTexCoord2f(uvs.right_top.u, uvs.right_top.v); ::glVertex2f(right, top); ::glTexCoord2f(uvs.right_top.u, uvs.right_top.v); ::glVertex2f(right, top);
::glTexCoord2f(uvs.left_top.u, uvs.left_top.v); ::glVertex2f(left, top); ::glTexCoord2f(uvs.left_top.u, uvs.left_top.v); ::glVertex2f(left, top);
::glEnd(); glsafe(::glEnd());
::glBindTexture(GL_TEXTURE_2D, 0); glsafe(::glBindTexture(GL_TEXTURE_2D, 0));
::glDisable(GL_TEXTURE_2D); glsafe(::glDisable(GL_TEXTURE_2D));
::glDisable(GL_BLEND); glsafe(::glDisable(GL_BLEND));
} }
unsigned int GLTexture::generate_mipmaps(wxImage& image) unsigned int GLTexture::generate_mipmaps(wxImage& image)
@ -282,7 +284,7 @@ unsigned int GLTexture::generate_mipmaps(wxImage& image)
data[data_id + 3] = (img_alpha != nullptr) ? img_alpha[i] : 255; data[data_id + 3] = (img_alpha != nullptr) ? img_alpha[i] : 255;
} }
::glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA, (GLsizei)w, (GLsizei)h, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data()); glsafe(::glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA, (GLsizei)w, (GLsizei)h, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data()));
} }
return (unsigned int)level; return (unsigned int)level;
@ -330,25 +332,25 @@ bool GLTexture::load_from_png(const std::string& filename, bool use_mipmaps)
} }
// sends data to gpu // sends data to gpu
::glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glsafe(::glPixelStorei(GL_UNPACK_ALIGNMENT, 1));
::glGenTextures(1, &m_id); glsafe(::glGenTextures(1, &m_id));
::glBindTexture(GL_TEXTURE_2D, m_id); glsafe(::glBindTexture(GL_TEXTURE_2D, m_id));
::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (GLsizei)m_width, (GLsizei)m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data()); glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (GLsizei)m_width, (GLsizei)m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data()));
if (use_mipmaps) if (use_mipmaps)
{ {
// we manually generate mipmaps because glGenerateMipmap() function is not reliable on all graphics cards // we manually generate mipmaps because glGenerateMipmap() function is not reliable on all graphics cards
unsigned int levels_count = generate_mipmaps(image); unsigned int levels_count = generate_mipmaps(image);
::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, levels_count); glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, levels_count));
::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR));
} }
else else
{ {
::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0); glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0));
} }
::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
::glBindTexture(GL_TEXTURE_2D, 0); glsafe(::glBindTexture(GL_TEXTURE_2D, 0));
m_source = filename; m_source = filename;
@ -392,10 +394,10 @@ bool GLTexture::load_from_svg(const std::string& filename, bool use_mipmaps, uns
nsvgRasterize(rast, image, 0, 0, scale, data.data(), m_width, m_height, m_width * 4); nsvgRasterize(rast, image, 0, 0, scale, data.data(), m_width, m_height, m_width * 4);
// sends data to gpu // sends data to gpu
::glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glsafe(::glPixelStorei(GL_UNPACK_ALIGNMENT, 1));
::glGenTextures(1, &m_id); glsafe(::glGenTextures(1, &m_id));
::glBindTexture(GL_TEXTURE_2D, m_id); glsafe(::glBindTexture(GL_TEXTURE_2D, m_id));
::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (GLsizei)m_width, (GLsizei)m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data()); glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (GLsizei)m_width, (GLsizei)m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data()));
if (use_mipmaps) if (use_mipmaps)
{ {
// we manually generate mipmaps because glGenerateMipmap() function is not reliable on all graphics cards // we manually generate mipmaps because glGenerateMipmap() function is not reliable on all graphics cards
@ -411,20 +413,20 @@ bool GLTexture::load_from_svg(const std::string& filename, bool use_mipmaps, uns
scale /= 2.0f; scale /= 2.0f;
nsvgRasterize(rast, image, 0, 0, scale, data.data(), lod_w, lod_h, lod_w * 4); nsvgRasterize(rast, image, 0, 0, scale, data.data(), lod_w, lod_h, lod_w * 4);
::glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA, (GLsizei)lod_w, (GLsizei)lod_h, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data()); glsafe(::glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA, (GLsizei)lod_w, (GLsizei)lod_h, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data()));
} }
::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, level); glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, level));
::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR));
} }
else else
{ {
::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0); glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0));
} }
::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
::glBindTexture(GL_TEXTURE_2D, 0); glsafe(::glBindTexture(GL_TEXTURE_2D, 0));
m_source = filename; m_source = filename;

22
src/slic3r/GUI/GLToolbar.cpp
View file

@ -388,10 +388,10 @@ void GLToolbar::render(const GLCanvas3D& parent) const
generate_icons_texture(); generate_icons_texture();
#endif // ENABLE_SVG_ICONS #endif // ENABLE_SVG_ICONS
::glDisable(GL_DEPTH_TEST); glsafe(::glDisable(GL_DEPTH_TEST));
::glPushMatrix(); glsafe(::glPushMatrix());
::glLoadIdentity(); glsafe(::glLoadIdentity());
switch (m_layout.type) switch (m_layout.type)
{ {
@ -400,7 +400,7 @@ void GLToolbar::render(const GLCanvas3D& parent) const
case Layout::Vertical: { render_vertical(parent); break; } case Layout::Vertical: { render_vertical(parent); break; }
} }
::glPopMatrix(); glsafe(::glPopMatrix());
} }
bool GLToolbar::on_mouse(wxMouseEvent& evt, GLCanvas3D& parent) bool GLToolbar::on_mouse(wxMouseEvent& evt, GLCanvas3D& parent)
@ -444,11 +444,11 @@ bool GLToolbar::on_mouse(wxMouseEvent& evt, GLCanvas3D& parent)
{ {
m_mouse_capture.left = true; m_mouse_capture.left = true;
m_mouse_capture.parent = &parent; m_mouse_capture.parent = &parent;
processed = true;
if ((item_id != -2) && !m_items[item_id]->is_separator()) if ((item_id != -2) && !m_items[item_id]->is_separator())
{ {
// mouse is inside an icon // mouse is inside an icon
do_action((unsigned int)item_id, parent); do_action((unsigned int)item_id, parent);
processed = true;
} }
} }
else if (evt.MiddleDown()) else if (evt.MiddleDown())
@ -612,7 +612,7 @@ std::string GLToolbar::update_hover_state_horizontal(const Vec2d& mouse_pos, GLC
{ {
// NB: mouse_pos is already scaled appropriately // NB: mouse_pos is already scaled appropriately
float zoom = parent.get_camera_zoom(); float zoom = parent.get_camera().zoom;
float inv_zoom = (zoom != 0.0f) ? 1.0f / zoom : 0.0f; float inv_zoom = (zoom != 0.0f) ? 1.0f / zoom : 0.0f;
#if ENABLE_SVG_ICONS #if ENABLE_SVG_ICONS
float factor = m_layout.scale * inv_zoom; float factor = m_layout.scale * inv_zoom;
@ -717,7 +717,7 @@ std::string GLToolbar::update_hover_state_vertical(const Vec2d& mouse_pos, GLCan
{ {
// NB: mouse_pos is already scaled appropriately // NB: mouse_pos is already scaled appropriately
float zoom = parent.get_camera_zoom(); float zoom = parent.get_camera().zoom;
float inv_zoom = (zoom != 0.0f) ? 1.0f / zoom : 0.0f; float inv_zoom = (zoom != 0.0f) ? 1.0f / zoom : 0.0f;
#if ENABLE_SVG_ICONS #if ENABLE_SVG_ICONS
float factor = m_layout.scale * inv_zoom; float factor = m_layout.scale * inv_zoom;
@ -834,7 +834,7 @@ int GLToolbar::contains_mouse_horizontal(const Vec2d& mouse_pos, const GLCanvas3
{ {
// NB: mouse_pos is already scaled appropriately // NB: mouse_pos is already scaled appropriately
float zoom = parent.get_camera_zoom(); float zoom = parent.get_camera().zoom;
float inv_zoom = (zoom != 0.0f) ? 1.0f / zoom : 0.0f; float inv_zoom = (zoom != 0.0f) ? 1.0f / zoom : 0.0f;
#if ENABLE_SVG_ICONS #if ENABLE_SVG_ICONS
float factor = m_layout.scale * inv_zoom; float factor = m_layout.scale * inv_zoom;
@ -917,7 +917,7 @@ int GLToolbar::contains_mouse_vertical(const Vec2d& mouse_pos, const GLCanvas3D&
{ {
// NB: mouse_pos is already scaled appropriately // NB: mouse_pos is already scaled appropriately
float zoom = parent.get_camera_zoom(); float zoom = parent.get_camera().zoom;
float inv_zoom = (zoom != 0.0f) ? 1.0f / zoom : 0.0f; float inv_zoom = (zoom != 0.0f) ? 1.0f / zoom : 0.0f;
#if ENABLE_SVG_ICONS #if ENABLE_SVG_ICONS
float factor = m_layout.scale * inv_zoom; float factor = m_layout.scale * inv_zoom;
@ -1013,7 +1013,7 @@ void GLToolbar::render_horizontal(const GLCanvas3D& parent) const
return; return;
#endif // !ENABLE_SVG_ICONS #endif // !ENABLE_SVG_ICONS
float zoom = parent.get_camera_zoom(); float zoom = parent.get_camera().zoom;
float inv_zoom = (zoom != 0.0f) ? 1.0f / zoom : 0.0f; float inv_zoom = (zoom != 0.0f) ? 1.0f / zoom : 0.0f;
#if ENABLE_SVG_ICONS #if ENABLE_SVG_ICONS
float factor = inv_zoom * m_layout.scale; float factor = inv_zoom * m_layout.scale;
@ -1168,7 +1168,7 @@ void GLToolbar::render_vertical(const GLCanvas3D& parent) const
return; return;
#endif // !ENABLE_SVG_ICONS #endif // !ENABLE_SVG_ICONS
float zoom = parent.get_camera_zoom(); float zoom = parent.get_camera().zoom;
float inv_zoom = (zoom != 0.0f) ? 1.0f / zoom : 0.0f; float inv_zoom = (zoom != 0.0f) ? 1.0f / zoom : 0.0f;
#if ENABLE_SVG_ICONS #if ENABLE_SVG_ICONS
float factor = inv_zoom * m_layout.scale; float factor = inv_zoom * m_layout.scale;

1
src/slic3r/GUI/GLToolbar.hpp
View file

@ -7,6 +7,7 @@
#include "GLTexture.hpp" #include "GLTexture.hpp"
#include "Event.hpp" #include "Event.hpp"
#include "libslic3r/Point.hpp"
class wxEvtHandler; class wxEvtHandler;

67
src/slic3r/GUI/Gizmos/GLGizmoBase.cpp
View file

@ -1,4 +1,5 @@
#include "GLGizmoBase.hpp" #include "GLGizmoBase.hpp"
#include "slic3r/GUI/GLCanvas3D.hpp"
#include <GL/glew.h> #include <GL/glew.h>
@ -60,62 +61,62 @@ void GLGizmoBase::Grabber::render(float size, const float* render_color, bool us
float half_size = dragging ? get_dragging_half_size(size) : get_half_size(size); float half_size = dragging ? get_dragging_half_size(size) : get_half_size(size);
if (use_lighting) if (use_lighting)
::glEnable(GL_LIGHTING); glsafe(::glEnable(GL_LIGHTING));
::glColor3fv(render_color); glsafe(::glColor3fv(render_color));
::glPushMatrix(); glsafe(::glPushMatrix());
::glTranslated(center(0), center(1), center(2)); glsafe(::glTranslated(center(0), center(1), center(2)));
::glRotated(Geometry::rad2deg(angles(2)), 0.0, 0.0, 1.0); glsafe(::glRotated(Geometry::rad2deg(angles(2)), 0.0, 0.0, 1.0));
::glRotated(Geometry::rad2deg(angles(1)), 0.0, 1.0, 0.0); glsafe(::glRotated(Geometry::rad2deg(angles(1)), 0.0, 1.0, 0.0));
::glRotated(Geometry::rad2deg(angles(0)), 1.0, 0.0, 0.0); glsafe(::glRotated(Geometry::rad2deg(angles(0)), 1.0, 0.0, 0.0));
// face min x // face min x
::glPushMatrix(); glsafe(::glPushMatrix());
::glTranslatef(-(GLfloat)half_size, 0.0f, 0.0f); glsafe(::glTranslatef(-(GLfloat)half_size, 0.0f, 0.0f));
::glRotatef(-90.0f, 0.0f, 1.0f, 0.0f); glsafe(::glRotatef(-90.0f, 0.0f, 1.0f, 0.0f));
render_face(half_size); render_face(half_size);
::glPopMatrix(); glsafe(::glPopMatrix());
// face max x // face max x
::glPushMatrix(); glsafe(::glPushMatrix());
::glTranslatef((GLfloat)half_size, 0.0f, 0.0f); glsafe(::glTranslatef((GLfloat)half_size, 0.0f, 0.0f));
::glRotatef(90.0f, 0.0f, 1.0f, 0.0f); glsafe(::glRotatef(90.0f, 0.0f, 1.0f, 0.0f));
render_face(half_size); render_face(half_size);
::glPopMatrix(); glsafe(::glPopMatrix());
// face min y // face min y
::glPushMatrix(); glsafe(::glPushMatrix());
::glTranslatef(0.0f, -(GLfloat)half_size, 0.0f); glsafe(::glTranslatef(0.0f, -(GLfloat)half_size, 0.0f));
::glRotatef(90.0f, 1.0f, 0.0f, 0.0f); glsafe(::glRotatef(90.0f, 1.0f, 0.0f, 0.0f));
render_face(half_size); render_face(half_size);
::glPopMatrix(); glsafe(::glPopMatrix());
// face max y // face max y
::glPushMatrix(); glsafe(::glPushMatrix());
::glTranslatef(0.0f, (GLfloat)half_size, 0.0f); glsafe(::glTranslatef(0.0f, (GLfloat)half_size, 0.0f));
::glRotatef(-90.0f, 1.0f, 0.0f, 0.0f); glsafe(::glRotatef(-90.0f, 1.0f, 0.0f, 0.0f));
render_face(half_size); render_face(half_size);
::glPopMatrix(); glsafe(::glPopMatrix());
// face min z // face min z
::glPushMatrix(); glsafe(::glPushMatrix());
::glTranslatef(0.0f, 0.0f, -(GLfloat)half_size); glsafe(::glTranslatef(0.0f, 0.0f, -(GLfloat)half_size));
::glRotatef(180.0f, 1.0f, 0.0f, 0.0f); glsafe(::glRotatef(180.0f, 1.0f, 0.0f, 0.0f));
render_face(half_size); render_face(half_size);
::glPopMatrix(); glsafe(::glPopMatrix());
// face max z // face max z
::glPushMatrix(); glsafe(::glPushMatrix());
::glTranslatef(0.0f, 0.0f, (GLfloat)half_size); glsafe(::glTranslatef(0.0f, 0.0f, (GLfloat)half_size));
render_face(half_size); render_face(half_size);
::glPopMatrix(); glsafe(::glPopMatrix());
::glPopMatrix(); glsafe(::glPopMatrix());
if (use_lighting) if (use_lighting)
::glDisable(GL_LIGHTING); glsafe(::glDisable(GL_LIGHTING));
} }
void GLGizmoBase::Grabber::render_face(float half_size) const void GLGizmoBase::Grabber::render_face(float half_size) const
@ -128,7 +129,7 @@ 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);
::glVertex3f(-(GLfloat)half_size, (GLfloat)half_size, 0.0f); ::glVertex3f(-(GLfloat)half_size, (GLfloat)half_size, 0.0f);
::glVertex3f(-(GLfloat)half_size, -(GLfloat)half_size, 0.0f); ::glVertex3f(-(GLfloat)half_size, -(GLfloat)half_size, 0.0f);
::glEnd(); glsafe(::glEnd());
} }
#if ENABLE_SVG_ICONS #if ENABLE_SVG_ICONS

1
src/slic3r/GUI/Gizmos/GLGizmoBase.hpp
View file

@ -3,7 +3,6 @@
#include "libslic3r/Point.hpp" #include "libslic3r/Point.hpp"
#include "slic3r/GUI/GLCanvas3D.hpp"
#include "slic3r/GUI/I18N.hpp" #include "slic3r/GUI/I18N.hpp"
#include "slic3r/GUI/Selection.hpp" #include "slic3r/GUI/Selection.hpp"

25
src/slic3r/GUI/Gizmos/GLGizmoCut.cpp
View file

@ -1,5 +1,6 @@
// Include GLGizmoBase.hpp before I18N.hpp as it includes some libigl code, which overrides our localization "L" macro. // Include GLGizmoBase.hpp before I18N.hpp as it includes some libigl code, which overrides our localization "L" macro.
#include "GLGizmoCut.hpp" #include "GLGizmoCut.hpp"
#include "slic3r/GUI/GLCanvas3D.hpp"
#include <GL/glew.h> #include <GL/glew.h>
@ -135,10 +136,10 @@ void GLGizmoCut::on_render(const Selection& selection) const
const float max_x = box.max(0) + Margin; const float max_x = box.max(0) + Margin;
const float min_y = box.min(1) - Margin; const float min_y = box.min(1) - Margin;
const float max_y = box.max(1) + Margin; const float max_y = box.max(1) + Margin;
::glEnable(GL_DEPTH_TEST); glsafe(::glEnable(GL_DEPTH_TEST));
::glDisable(GL_CULL_FACE); glsafe(::glDisable(GL_CULL_FACE));
::glEnable(GL_BLEND); glsafe(::glEnable(GL_BLEND));
::glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glsafe(::glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA));
// Draw the cutting plane // Draw the cutting plane
::glBegin(GL_QUADS); ::glBegin(GL_QUADS);
@ -147,10 +148,10 @@ void GLGizmoCut::on_render(const Selection& selection) const
::glVertex3f(max_x, min_y, plane_center(2)); ::glVertex3f(max_x, min_y, plane_center(2));
::glVertex3f(max_x, max_y, plane_center(2)); ::glVertex3f(max_x, max_y, plane_center(2));
::glVertex3f(min_x, max_y, plane_center(2)); ::glVertex3f(min_x, max_y, plane_center(2));
::glEnd(); glsafe(::glEnd());
::glEnable(GL_CULL_FACE); glsafe(::glEnable(GL_CULL_FACE));
::glDisable(GL_BLEND); glsafe(::glDisable(GL_BLEND));
// TODO: draw cut part contour? // TODO: draw cut part contour?
@ -158,13 +159,13 @@ void GLGizmoCut::on_render(const Selection& selection) const
m_grabbers[0].center = plane_center; m_grabbers[0].center = plane_center;
m_grabbers[0].center(2) = plane_center(2) + Offset; m_grabbers[0].center(2) = plane_center(2) + Offset;
::glDisable(GL_DEPTH_TEST); glsafe(::glDisable(GL_DEPTH_TEST));
::glLineWidth(m_hover_id != -1 ? 2.0f : 1.5f); glsafe(::glLineWidth(m_hover_id != -1 ? 2.0f : 1.5f));
::glColor3f(1.0, 1.0, 0.0); glsafe(::glColor3f(1.0, 1.0, 0.0));
::glBegin(GL_LINES); ::glBegin(GL_LINES);
::glVertex3dv(plane_center.data()); ::glVertex3dv(plane_center.data());
::glVertex3dv(m_grabbers[0].center.data()); ::glVertex3dv(m_grabbers[0].center.data());
::glEnd(); glsafe(::glEnd());
std::copy(std::begin(GrabberColor), std::end(GrabberColor), m_grabbers[0].color); std::copy(std::begin(GrabberColor), std::end(GrabberColor), m_grabbers[0].color);
m_grabbers[0].render(m_hover_id == 0, (float)((box.size()(0) + box.size()(1) + box.size()(2)) / 3.0)); m_grabbers[0].render(m_hover_id == 0, (float)((box.size()(0) + box.size()(1) + box.size()(2)) / 3.0));
@ -172,7 +173,7 @@ void GLGizmoCut::on_render(const Selection& selection) const
void GLGizmoCut::on_render_for_picking(const Selection& selection) const void GLGizmoCut::on_render_for_picking(const Selection& selection) const
{ {
::glDisable(GL_DEPTH_TEST); glsafe(::glDisable(GL_DEPTH_TEST));
render_grabbers_for_picking(selection.get_bounding_box()); render_grabbers_for_picking(selection.get_bounding_box());
} }

42
src/slic3r/GUI/Gizmos/GLGizmoFlatten.cpp
View file

@ -49,67 +49,67 @@ void GLGizmoFlatten::on_start_dragging(const Selection& selection)
void GLGizmoFlatten::on_render(const Selection& selection) const void GLGizmoFlatten::on_render(const Selection& selection) const
{ {
::glClear(GL_DEPTH_BUFFER_BIT); glsafe(::glClear(GL_DEPTH_BUFFER_BIT));
::glEnable(GL_DEPTH_TEST); glsafe(::glEnable(GL_DEPTH_TEST));
::glEnable(GL_BLEND); glsafe(::glEnable(GL_BLEND));
if (selection.is_single_full_instance()) if (selection.is_single_full_instance())
{ {
const Transform3d& m = selection.get_volume(*selection.get_volume_idxs().begin())->get_instance_transformation().get_matrix(); const Transform3d& m = selection.get_volume(*selection.get_volume_idxs().begin())->get_instance_transformation().get_matrix();
::glPushMatrix(); glsafe(::glPushMatrix());
::glTranslatef(0.f, 0.f, selection.get_volume(*selection.get_volume_idxs().begin())->get_sla_shift_z()); glsafe(::glTranslatef(0.f, 0.f, selection.get_volume(*selection.get_volume_idxs().begin())->get_sla_shift_z()));
::glMultMatrixd(m.data()); glsafe(::glMultMatrixd(m.data()));
if (this->is_plane_update_necessary()) if (this->is_plane_update_necessary())
const_cast<GLGizmoFlatten*>(this)->update_planes(); const_cast<GLGizmoFlatten*>(this)->update_planes();
for (int i = 0; i < (int)m_planes.size(); ++i) for (int i = 0; i < (int)m_planes.size(); ++i)
{ {
if (i == m_hover_id) if (i == m_hover_id)
::glColor4f(0.9f, 0.9f, 0.9f, 0.75f); glsafe(::glColor4f(0.9f, 0.9f, 0.9f, 0.75f));
else else
::glColor4f(0.9f, 0.9f, 0.9f, 0.5f); glsafe(::glColor4f(0.9f, 0.9f, 0.9f, 0.5f));
::glBegin(GL_POLYGON); ::glBegin(GL_POLYGON);
for (const Vec3d& vertex : m_planes[i].vertices) for (const Vec3d& vertex : m_planes[i].vertices)
{ {
::glVertex3dv(vertex.data()); ::glVertex3dv(vertex.data());
} }
::glEnd(); glsafe(::glEnd());
} }
::glPopMatrix(); glsafe(::glPopMatrix());
} }
::glEnable(GL_CULL_FACE); glsafe(::glEnable(GL_CULL_FACE));
::glDisable(GL_BLEND); glsafe(::glDisable(GL_BLEND));
} }
void GLGizmoFlatten::on_render_for_picking(const Selection& selection) const void GLGizmoFlatten::on_render_for_picking(const Selection& selection) const
{ {
::glDisable(GL_DEPTH_TEST); glsafe(::glDisable(GL_DEPTH_TEST));
::glDisable(GL_BLEND); glsafe(::glDisable(GL_BLEND));
if (selection.is_single_full_instance()) if (selection.is_single_full_instance())
{ {
const Transform3d& m = selection.get_volume(*selection.get_volume_idxs().begin())->get_instance_transformation().get_matrix(); const Transform3d& m = selection.get_volume(*selection.get_volume_idxs().begin())->get_instance_transformation().get_matrix();
::glPushMatrix(); glsafe(::glPushMatrix());
::glTranslatef(0.f, 0.f, selection.get_volume(*selection.get_volume_idxs().begin())->get_sla_shift_z()); glsafe(::glTranslatef(0.f, 0.f, selection.get_volume(*selection.get_volume_idxs().begin())->get_sla_shift_z()));
::glMultMatrixd(m.data()); glsafe(::glMultMatrixd(m.data()));
if (this->is_plane_update_necessary()) if (this->is_plane_update_necessary())
const_cast<GLGizmoFlatten*>(this)->update_planes(); const_cast<GLGizmoFlatten*>(this)->update_planes();
for (int i = 0; i < (int)m_planes.size(); ++i) for (int i = 0; i < (int)m_planes.size(); ++i)
{ {
::glColor3fv(picking_color_component(i).data()); glsafe(::glColor3fv(picking_color_component(i).data()));
::glBegin(GL_POLYGON); ::glBegin(GL_POLYGON);
for (const Vec3d& vertex : m_planes[i].vertices) for (const Vec3d& vertex : m_planes[i].vertices)
{ {
::glVertex3dv(vertex.data()); ::glVertex3dv(vertex.data());
} }
::glEnd(); glsafe(::glEnd());
} }
::glPopMatrix(); glsafe(::glPopMatrix());
} }
::glEnable(GL_CULL_FACE); glsafe(::glEnable(GL_CULL_FACE));
} }
void GLGizmoFlatten::set_flattening_data(const ModelObject* model_object) void GLGizmoFlatten::set_flattening_data(const ModelObject* model_object)

34
src/slic3r/GUI/Gizmos/GLGizmoMove.cpp
View file

@ -97,8 +97,8 @@ void GLGizmoMove3D::on_render(const Selection& selection) const
else if (!m_grabbers[2].dragging && (m_hover_id == 2)) else if (!m_grabbers[2].dragging && (m_hover_id == 2))
set_tooltip("Z"); set_tooltip("Z");
::glClear(GL_DEPTH_BUFFER_BIT); glsafe(::glClear(GL_DEPTH_BUFFER_BIT));
::glEnable(GL_DEPTH_TEST); glsafe(::glEnable(GL_DEPTH_TEST));
const BoundingBoxf3& box = selection.get_bounding_box(); const BoundingBoxf3& box = selection.get_bounding_box();
const Vec3d& center = box.center(); const Vec3d& center = box.center();
@ -115,7 +115,7 @@ void GLGizmoMove3D::on_render(const Selection& selection) const
m_grabbers[2].center = Vec3d(center(0), center(1), box.max(2) + Offset); m_grabbers[2].center = Vec3d(center(0), center(1), box.max(2) + Offset);
::memcpy((void*)m_grabbers[2].color, (const void*)&AXES_COLOR[2], 3 * sizeof(float)); ::memcpy((void*)m_grabbers[2].color, (const void*)&AXES_COLOR[2], 3 * sizeof(float));
::glLineWidth((m_hover_id != -1) ? 2.0f : 1.5f); glsafe(::glLineWidth((m_hover_id != -1) ? 2.0f : 1.5f));
if (m_hover_id == -1) if (m_hover_id == -1)
{ {
@ -124,11 +124,11 @@ void GLGizmoMove3D::on_render(const Selection& selection) const
{ {
if (m_grabbers[i].enabled) if (m_grabbers[i].enabled)
{ {
::glColor3fv(AXES_COLOR[i]); glsafe(::glColor3fv(AXES_COLOR[i]));
::glBegin(GL_LINES); ::glBegin(GL_LINES);
::glVertex3dv(center.data()); ::glVertex3dv(center.data());
::glVertex3dv(m_grabbers[i].center.data()); ::glVertex3dv(m_grabbers[i].center.data());
::glEnd(); glsafe(::glEnd());
} }
} }
@ -143,11 +143,11 @@ void GLGizmoMove3D::on_render(const Selection& selection) const
else else
{ {
// draw axis // draw axis
::glColor3fv(AXES_COLOR[m_hover_id]); glsafe(::glColor3fv(AXES_COLOR[m_hover_id]));
::glBegin(GL_LINES); ::glBegin(GL_LINES);
::glVertex3dv(center.data()); ::glVertex3dv(center.data());
::glVertex3dv(m_grabbers[m_hover_id].center.data()); ::glVertex3dv(m_grabbers[m_hover_id].center.data());
::glEnd(); glsafe(::glEnd());
// draw grabber // draw grabber
m_grabbers[m_hover_id].render(true, box.max_size()); m_grabbers[m_hover_id].render(true, box.max_size());
@ -157,7 +157,7 @@ void GLGizmoMove3D::on_render(const Selection& selection) const
void GLGizmoMove3D::on_render_for_picking(const Selection& selection) const void GLGizmoMove3D::on_render_for_picking(const Selection& selection) const
{ {
::glDisable(GL_DEPTH_TEST); glsafe(::glDisable(GL_DEPTH_TEST));
const BoundingBoxf3& box = selection.get_bounding_box(); const BoundingBoxf3& box = selection.get_bounding_box();
render_grabbers_for_picking(box); render_grabbers_for_picking(box);
@ -229,25 +229,25 @@ void GLGizmoMove3D::render_grabber_extension(Axis axis, const BoundingBoxf3& box
} }
if (!picking) if (!picking)
::glEnable(GL_LIGHTING); glsafe(::glEnable(GL_LIGHTING));
::glColor3fv(color); glsafe(::glColor3fv(color));
::glPushMatrix(); glsafe(::glPushMatrix());
::glTranslated(m_grabbers[axis].center(0), m_grabbers[axis].center(1), m_grabbers[axis].center(2)); glsafe(::glTranslated(m_grabbers[axis].center(0), m_grabbers[axis].center(1), m_grabbers[axis].center(2)));
if (axis == X) if (axis == X)
::glRotated(90.0, 0.0, 1.0, 0.0); glsafe(::glRotated(90.0, 0.0, 1.0, 0.0));
else if (axis == Y) else if (axis == Y)
::glRotated(-90.0, 1.0, 0.0, 0.0); glsafe(::glRotated(-90.0, 1.0, 0.0, 0.0));
::glTranslated(0.0, 0.0, 2.0 * size); glsafe(::glTranslated(0.0, 0.0, 2.0 * size));
::gluQuadricOrientation(m_quadric, GLU_OUTSIDE); ::gluQuadricOrientation(m_quadric, GLU_OUTSIDE);
::gluCylinder(m_quadric, 0.75 * size, 0.0, 3.0 * size, 36, 1); ::gluCylinder(m_quadric, 0.75 * size, 0.0, 3.0 * size, 36, 1);
::gluQuadricOrientation(m_quadric, GLU_INSIDE); ::gluQuadricOrientation(m_quadric, GLU_INSIDE);
::gluDisk(m_quadric, 0.0, 0.75 * size, 36, 1); ::gluDisk(m_quadric, 0.0, 0.75 * size, 36, 1);
::glPopMatrix(); glsafe(::glPopMatrix());
if (!picking) if (!picking)
::glDisable(GL_LIGHTING); glsafe(::glDisable(GL_LIGHTING));
} }

76
src/slic3r/GUI/Gizmos/GLGizmoRotate.cpp
View file

@ -155,13 +155,13 @@ void GLGizmoRotate::on_render(const Selection& selection) const
m_snap_fine_out_radius = m_radius * (1.0f + ScaleLongTooth); m_snap_fine_out_radius = m_radius * (1.0f + ScaleLongTooth);
} }
::glEnable(GL_DEPTH_TEST); glsafe(::glEnable(GL_DEPTH_TEST));
::glPushMatrix(); glsafe(::glPushMatrix());
transform_to_local(selection); transform_to_local(selection);
::glLineWidth((m_hover_id != -1) ? 2.0f : 1.5f); glsafe(::glLineWidth((m_hover_id != -1) ? 2.0f : 1.5f));
::glColor3fv((m_hover_id != -1) ? m_drag_color : m_highlight_color); glsafe(::glColor3fv((m_hover_id != -1) ? m_drag_color : m_highlight_color));
render_circle(); render_circle();
@ -172,7 +172,7 @@ void GLGizmoRotate::on_render(const Selection& selection) const
render_reference_radius(); render_reference_radius();
} }
::glColor3fv(m_highlight_color); glsafe(::glColor3fv(m_highlight_color));
if (m_hover_id != -1) if (m_hover_id != -1)
render_angle(); render_angle();
@ -180,14 +180,14 @@ void GLGizmoRotate::on_render(const Selection& selection) const
render_grabber(box); render_grabber(box);
render_grabber_extension(box, false); render_grabber_extension(box, false);
::glPopMatrix(); glsafe(::glPopMatrix());
} }
void GLGizmoRotate::on_render_for_picking(const Selection& selection) const void GLGizmoRotate::on_render_for_picking(const Selection& selection) const
{ {
::glDisable(GL_DEPTH_TEST); glsafe(::glDisable(GL_DEPTH_TEST));
::glPushMatrix(); glsafe(::glPushMatrix());
transform_to_local(selection); transform_to_local(selection);
@ -195,7 +195,7 @@ void GLGizmoRotate::on_render_for_picking(const Selection& selection) const
render_grabbers_for_picking(box); render_grabbers_for_picking(box);
render_grabber_extension(box, true); render_grabber_extension(box, true);
::glPopMatrix(); glsafe(::glPopMatrix());
} }
void GLGizmoRotate::render_circle() const void GLGizmoRotate::render_circle() const
@ -209,7 +209,7 @@ void GLGizmoRotate::render_circle() const
float z = 0.0f; float z = 0.0f;
::glVertex3f((GLfloat)x, (GLfloat)y, (GLfloat)z); ::glVertex3f((GLfloat)x, (GLfloat)y, (GLfloat)z);
} }
::glEnd(); glsafe(::glEnd());
} }
void GLGizmoRotate::render_scale() const void GLGizmoRotate::render_scale() const
@ -232,7 +232,7 @@ void GLGizmoRotate::render_scale() const
::glVertex3f((GLfloat)in_x, (GLfloat)in_y, (GLfloat)in_z); ::glVertex3f((GLfloat)in_x, (GLfloat)in_y, (GLfloat)in_z);
::glVertex3f((GLfloat)out_x, (GLfloat)out_y, (GLfloat)out_z); ::glVertex3f((GLfloat)out_x, (GLfloat)out_y, (GLfloat)out_z);
} }
::glEnd(); glsafe(::glEnd());
} }
void GLGizmoRotate::render_snap_radii() const void GLGizmoRotate::render_snap_radii() const
@ -257,7 +257,7 @@ void GLGizmoRotate::render_snap_radii() const
::glVertex3f((GLfloat)in_x, (GLfloat)in_y, (GLfloat)in_z); ::glVertex3f((GLfloat)in_x, (GLfloat)in_y, (GLfloat)in_z);
::glVertex3f((GLfloat)out_x, (GLfloat)out_y, (GLfloat)out_z); ::glVertex3f((GLfloat)out_x, (GLfloat)out_y, (GLfloat)out_z);
} }
::glEnd(); glsafe(::glEnd());
} }
void GLGizmoRotate::render_reference_radius() const void GLGizmoRotate::render_reference_radius() const
@ -265,7 +265,7 @@ 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 * (1.0f + GrabberOffset)), 0.0f, 0.0f); ::glVertex3f((GLfloat)(m_radius * (1.0f + GrabberOffset)), 0.0f, 0.0f);
::glEnd(); glsafe(::glEnd());
} }
void GLGizmoRotate::render_angle() const void GLGizmoRotate::render_angle() const
@ -282,7 +282,7 @@ void GLGizmoRotate::render_angle() const
float z = 0.0f; float z = 0.0f;
::glVertex3f((GLfloat)x, (GLfloat)y, (GLfloat)z); ::glVertex3f((GLfloat)x, (GLfloat)y, (GLfloat)z);
} }
::glEnd(); glsafe(::glEnd());
} }
void GLGizmoRotate::render_grabber(const BoundingBoxf3& box) const void GLGizmoRotate::render_grabber(const BoundingBoxf3& box) const
@ -291,12 +291,12 @@ void GLGizmoRotate::render_grabber(const BoundingBoxf3& box) const
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;
::glColor3fv((m_hover_id != -1) ? m_drag_color : m_highlight_color); glsafe(::glColor3fv((m_hover_id != -1) ? m_drag_color : m_highlight_color));
::glBegin(GL_LINES); ::glBegin(GL_LINES);
::glVertex3f(0.0f, 0.0f, 0.0f); ::glVertex3f(0.0f, 0.0f, 0.0f);
::glVertex3dv(m_grabbers[0].center.data()); ::glVertex3dv(m_grabbers[0].center.data());
::glEnd(); glsafe(::glEnd());
::memcpy((void*)m_grabbers[0].color, (const void*)m_highlight_color, 3 * sizeof(float)); ::memcpy((void*)m_grabbers[0].color, (const void*)m_highlight_color, 3 * sizeof(float));
render_grabbers(box); render_grabbers(box);
@ -320,56 +320,56 @@ void GLGizmoRotate::render_grabber_extension(const BoundingBoxf3& box, bool pick
} }
if (!picking) if (!picking)
::glEnable(GL_LIGHTING); glsafe(::glEnable(GL_LIGHTING));
::glColor3fv(color); glsafe(::glColor3fv(color));
::glPushMatrix(); glsafe(::glPushMatrix());
::glTranslated(m_grabbers[0].center(0), m_grabbers[0].center(1), m_grabbers[0].center(2)); glsafe(::glTranslated(m_grabbers[0].center(0), m_grabbers[0].center(1), m_grabbers[0].center(2)));
::glRotated(Geometry::rad2deg(m_angle), 0.0, 0.0, 1.0); glsafe(::glRotated(Geometry::rad2deg(m_angle), 0.0, 0.0, 1.0));
::glRotated(90.0, 1.0, 0.0, 0.0); glsafe(::glRotated(90.0, 1.0, 0.0, 0.0));
::glTranslated(0.0, 0.0, 2.0 * size); glsafe(::glTranslated(0.0, 0.0, 2.0 * size));
::gluQuadricOrientation(m_quadric, GLU_OUTSIDE); ::gluQuadricOrientation(m_quadric, GLU_OUTSIDE);
::gluCylinder(m_quadric, 0.75 * size, 0.0, 3.0 * size, 36, 1); ::gluCylinder(m_quadric, 0.75 * size, 0.0, 3.0 * size, 36, 1);
::gluQuadricOrientation(m_quadric, GLU_INSIDE); ::gluQuadricOrientation(m_quadric, GLU_INSIDE);
::gluDisk(m_quadric, 0.0, 0.75 * size, 36, 1); ::gluDisk(m_quadric, 0.0, 0.75 * size, 36, 1);
::glPopMatrix(); glsafe(::glPopMatrix());
::glPushMatrix(); glsafe(::glPushMatrix());
::glTranslated(m_grabbers[0].center(0), m_grabbers[0].center(1), m_grabbers[0].center(2)); glsafe(::glTranslated(m_grabbers[0].center(0), m_grabbers[0].center(1), m_grabbers[0].center(2)));
::glRotated(Geometry::rad2deg(m_angle), 0.0, 0.0, 1.0); glsafe(::glRotated(Geometry::rad2deg(m_angle), 0.0, 0.0, 1.0));
::glRotated(-90.0, 1.0, 0.0, 0.0); glsafe(::glRotated(-90.0, 1.0, 0.0, 0.0));
::glTranslated(0.0, 0.0, 2.0 * size); glsafe(::glTranslated(0.0, 0.0, 2.0 * size));
::gluQuadricOrientation(m_quadric, GLU_OUTSIDE); ::gluQuadricOrientation(m_quadric, GLU_OUTSIDE);
::gluCylinder(m_quadric, 0.75 * size, 0.0, 3.0 * size, 36, 1); ::gluCylinder(m_quadric, 0.75 * size, 0.0, 3.0 * size, 36, 1);
::gluQuadricOrientation(m_quadric, GLU_INSIDE); ::gluQuadricOrientation(m_quadric, GLU_INSIDE);
::gluDisk(m_quadric, 0.0, 0.75 * size, 36, 1); ::gluDisk(m_quadric, 0.0, 0.75 * size, 36, 1);
::glPopMatrix(); glsafe(::glPopMatrix());
if (!picking) if (!picking)
::glDisable(GL_LIGHTING); glsafe(::glDisable(GL_LIGHTING));
} }
void GLGizmoRotate::transform_to_local(const Selection& selection) const void GLGizmoRotate::transform_to_local(const Selection& selection) const
{ {
::glTranslated(m_center(0), m_center(1), m_center(2)); glsafe(::glTranslated(m_center(0), m_center(1), m_center(2)));
if (selection.is_single_volume() || selection.is_single_modifier() || selection.requires_local_axes()) if (selection.is_single_volume() || selection.is_single_modifier() || selection.requires_local_axes())
{ {
Transform3d orient_matrix = selection.get_volume(*selection.get_volume_idxs().begin())->get_instance_transformation().get_matrix(true, false, true, true); Transform3d orient_matrix = selection.get_volume(*selection.get_volume_idxs().begin())->get_instance_transformation().get_matrix(true, false, true, true);
::glMultMatrixd(orient_matrix.data()); glsafe(::glMultMatrixd(orient_matrix.data()));
} }
switch (m_axis) switch (m_axis)
{ {
case X: case X:
{ {
::glRotatef(90.0f, 0.0f, 1.0f, 0.0f); glsafe(::glRotatef(90.0f, 0.0f, 1.0f, 0.0f));
::glRotatef(-90.0f, 0.0f, 0.0f, 1.0f); glsafe(::glRotatef(-90.0f, 0.0f, 0.0f, 1.0f));
break; break;
} }
case Y: case Y:
{ {
::glRotatef(-90.0f, 0.0f, 0.0f, 1.0f); glsafe(::glRotatef(-90.0f, 0.0f, 0.0f, 1.0f));
::glRotatef(-90.0f, 0.0f, 1.0f, 0.0f); glsafe(::glRotatef(-90.0f, 0.0f, 1.0f, 0.0f));
break; break;
} }
default: default:
@ -472,7 +472,7 @@ void GLGizmoRotate3D::on_stop_dragging()
void GLGizmoRotate3D::on_render(const Selection& selection) const void GLGizmoRotate3D::on_render(const Selection& selection) const
{ {
::glClear(GL_DEPTH_BUFFER_BIT); glsafe(::glClear(GL_DEPTH_BUFFER_BIT));
if ((m_hover_id == -1) || (m_hover_id == 0)) if ((m_hover_id == -1) || (m_hover_id == 0))
m_gizmos[X].render(selection); m_gizmos[X].render(selection);

26
src/slic3r/GUI/Gizmos/GLGizmoScale.cpp
View file

@ -108,8 +108,8 @@ void GLGizmoScale3D::on_render(const Selection& selection) const
((m_hover_id == 6) || (m_hover_id == 7) || (m_hover_id == 8) || (m_hover_id == 9))) ((m_hover_id == 6) || (m_hover_id == 7) || (m_hover_id == 8) || (m_hover_id == 9)))
set_tooltip("X/Y/Z"); set_tooltip("X/Y/Z");
::glClear(GL_DEPTH_BUFFER_BIT); glsafe(::glClear(GL_DEPTH_BUFFER_BIT));
::glEnable(GL_DEPTH_TEST); glsafe(::glEnable(GL_DEPTH_TEST));
BoundingBoxf3 box; BoundingBoxf3 box;
Transform3d transform = Transform3d::Identity(); Transform3d transform = Transform3d::Identity();
@ -187,7 +187,7 @@ void GLGizmoScale3D::on_render(const Selection& selection) const
m_grabbers[i].angles = angles; m_grabbers[i].angles = angles;
} }
::glLineWidth((m_hover_id != -1) ? 2.0f : 1.5f); glsafe(::glLineWidth((m_hover_id != -1) ? 2.0f : 1.5f));
const BoundingBoxf3& selection_box = selection.get_bounding_box(); const BoundingBoxf3& selection_box = selection.get_bounding_box();
@ -198,20 +198,20 @@ void GLGizmoScale3D::on_render(const Selection& selection) const
// draw connections // draw connections
if (m_grabbers[0].enabled && m_grabbers[1].enabled) if (m_grabbers[0].enabled && m_grabbers[1].enabled)
{ {
::glColor3fv(m_grabbers[0].color); glsafe(::glColor3fv(m_grabbers[0].color));
render_grabbers_connection(0, 1); render_grabbers_connection(0, 1);
} }
if (m_grabbers[2].enabled && m_grabbers[3].enabled) if (m_grabbers[2].enabled && m_grabbers[3].enabled)
{ {
::glColor3fv(m_grabbers[2].color); glsafe(::glColor3fv(m_grabbers[2].color));
render_grabbers_connection(2, 3); render_grabbers_connection(2, 3);
} }
if (m_grabbers[4].enabled && m_grabbers[5].enabled) if (m_grabbers[4].enabled && m_grabbers[5].enabled)
{ {
::glColor3fv(m_grabbers[4].color); glsafe(::glColor3fv(m_grabbers[4].color));
render_grabbers_connection(4, 5); render_grabbers_connection(4, 5);
} }
::glColor3fv(m_base_color); glsafe(::glColor3fv(m_base_color));
render_grabbers_connection(6, 7); render_grabbers_connection(6, 7);
render_grabbers_connection(7, 8); render_grabbers_connection(7, 8);
render_grabbers_connection(8, 9); render_grabbers_connection(8, 9);
@ -222,7 +222,7 @@ void GLGizmoScale3D::on_render(const Selection& selection) const
else if ((m_hover_id == 0) || (m_hover_id == 1)) else if ((m_hover_id == 0) || (m_hover_id == 1))
{ {
// draw connection // draw connection
::glColor3fv(m_grabbers[0].color); glsafe(::glColor3fv(m_grabbers[0].color));
render_grabbers_connection(0, 1); render_grabbers_connection(0, 1);
// draw grabbers // draw grabbers
m_grabbers[0].render(true, grabber_mean_size); m_grabbers[0].render(true, grabber_mean_size);
@ -231,7 +231,7 @@ void GLGizmoScale3D::on_render(const Selection& selection) const
else if ((m_hover_id == 2) || (m_hover_id == 3)) else if ((m_hover_id == 2) || (m_hover_id == 3))
{ {
// draw connection // draw connection
::glColor3fv(m_grabbers[2].color); glsafe(::glColor3fv(m_grabbers[2].color));
render_grabbers_connection(2, 3); render_grabbers_connection(2, 3);
// draw grabbers // draw grabbers
m_grabbers[2].render(true, grabber_mean_size); m_grabbers[2].render(true, grabber_mean_size);
@ -240,7 +240,7 @@ void GLGizmoScale3D::on_render(const Selection& selection) const
else if ((m_hover_id == 4) || (m_hover_id == 5)) else if ((m_hover_id == 4) || (m_hover_id == 5))
{ {
// draw connection // draw connection
::glColor3fv(m_grabbers[4].color); glsafe(::glColor3fv(m_grabbers[4].color));
render_grabbers_connection(4, 5); render_grabbers_connection(4, 5);
// draw grabbers // draw grabbers
m_grabbers[4].render(true, grabber_mean_size); m_grabbers[4].render(true, grabber_mean_size);
@ -249,7 +249,7 @@ void GLGizmoScale3D::on_render(const Selection& selection) const
else if (m_hover_id >= 6) else if (m_hover_id >= 6)
{ {
// draw connection // draw connection
::glColor3fv(m_drag_color); glsafe(::glColor3fv(m_drag_color));
render_grabbers_connection(6, 7); render_grabbers_connection(6, 7);
render_grabbers_connection(7, 8); render_grabbers_connection(7, 8);
render_grabbers_connection(8, 9); render_grabbers_connection(8, 9);
@ -264,7 +264,7 @@ void GLGizmoScale3D::on_render(const Selection& selection) const
void GLGizmoScale3D::on_render_for_picking(const Selection& selection) const void GLGizmoScale3D::on_render_for_picking(const Selection& selection) const
{ {
::glDisable(GL_DEPTH_TEST); glsafe(::glDisable(GL_DEPTH_TEST));
render_grabbers_for_picking(selection.get_bounding_box()); render_grabbers_for_picking(selection.get_bounding_box());
} }
@ -291,7 +291,7 @@ void GLGizmoScale3D::render_grabbers_connection(unsigned int id_1, unsigned int
::glBegin(GL_LINES); ::glBegin(GL_LINES);
::glVertex3dv(m_grabbers[id_1].center.data()); ::glVertex3dv(m_grabbers[id_1].center.data());
::glVertex3dv(m_grabbers[id_2].center.data()); ::glVertex3dv(m_grabbers[id_2].center.data());
::glEnd(); glsafe(::glEnd());
} }
} }

111
src/slic3r/GUI/Gizmos/GLGizmoSlaSupports.cpp
View file

@ -1,5 +1,6 @@
// Include GLGizmoBase.hpp before I18N.hpp as it includes some libigl code, which overrides our localization "L" macro. // Include GLGizmoBase.hpp before I18N.hpp as it includes some libigl code, which overrides our localization "L" macro.
#include "GLGizmoSlaSupports.hpp" #include "GLGizmoSlaSupports.hpp"
#include "slic3r/GUI/GLCanvas3D.hpp"
#include <GL/glew.h> #include <GL/glew.h>
@ -84,13 +85,13 @@ void GLGizmoSlaSupports::on_render(const Selection& selection) const
return; return;
} }
::glEnable(GL_BLEND); glsafe(::glEnable(GL_BLEND));
::glEnable(GL_DEPTH_TEST); glsafe(::glEnable(GL_DEPTH_TEST));
render_points(selection, false); render_points(selection, false);
render_selection_rectangle(); render_selection_rectangle();
::glDisable(GL_BLEND); glsafe(::glDisable(GL_BLEND));
} }
void GLGizmoSlaSupports::render_selection_rectangle() const void GLGizmoSlaSupports::render_selection_rectangle() const
@ -98,44 +99,44 @@ void GLGizmoSlaSupports::render_selection_rectangle() const
if (!m_selection_rectangle_active) if (!m_selection_rectangle_active)
return; return;
::glLineWidth(1.5f); glsafe(::glLineWidth(1.5f));
float render_color[3] = {1.f, 0.f, 0.f}; float render_color[3] = {1.f, 0.f, 0.f};
::glColor3fv(render_color); glsafe(::glColor3fv(render_color));
::glPushAttrib(GL_TRANSFORM_BIT); // remember current MatrixMode glsafe(::glPushAttrib(GL_TRANSFORM_BIT)); // remember current MatrixMode
::glMatrixMode(GL_MODELVIEW); // cache modelview matrix and set to identity glsafe(::glMatrixMode(GL_MODELVIEW)); // cache modelview matrix and set to identity
::glPushMatrix(); glsafe(::glPushMatrix());
::glLoadIdentity(); glsafe(::glLoadIdentity());
::glMatrixMode(GL_PROJECTION); // cache projection matrix and set to identity glsafe(::glMatrixMode(GL_PROJECTION)); // cache projection matrix and set to identity
::glPushMatrix(); glsafe(::glPushMatrix());
::glLoadIdentity(); glsafe(::glLoadIdentity());
::glOrtho(0.f, m_canvas_width, m_canvas_height, 0.f, -1.f, 1.f); // set projection matrix so that world coords = window coords glsafe(::glOrtho(0.f, m_canvas_width, m_canvas_height, 0.f, -1.f, 1.f)); // set projection matrix so that world coords = window coords
// render the selection rectangle (window coordinates): // render the selection rectangle (window coordinates):
::glPushAttrib(GL_ENABLE_BIT); glsafe(::glPushAttrib(GL_ENABLE_BIT));
::glLineStipple(4, 0xAAAA); glsafe(::glLineStipple(4, 0xAAAA));
::glEnable(GL_LINE_STIPPLE); glsafe(::glEnable(GL_LINE_STIPPLE));
::glBegin(GL_LINE_LOOP); ::glBegin(GL_LINE_LOOP);
::glVertex3f((GLfloat)m_selection_rectangle_start_corner(0), (GLfloat)m_selection_rectangle_start_corner(1), (GLfloat)0.5f); ::glVertex3f((GLfloat)m_selection_rectangle_start_corner(0), (GLfloat)m_selection_rectangle_start_corner(1), (GLfloat)0.5f);
::glVertex3f((GLfloat)m_selection_rectangle_end_corner(0), (GLfloat)m_selection_rectangle_start_corner(1), (GLfloat)0.5f); ::glVertex3f((GLfloat)m_selection_rectangle_end_corner(0), (GLfloat)m_selection_rectangle_start_corner(1), (GLfloat)0.5f);
::glVertex3f((GLfloat)m_selection_rectangle_end_corner(0), (GLfloat)m_selection_rectangle_end_corner(1), (GLfloat)0.5f); ::glVertex3f((GLfloat)m_selection_rectangle_end_corner(0), (GLfloat)m_selection_rectangle_end_corner(1), (GLfloat)0.5f);
::glVertex3f((GLfloat)m_selection_rectangle_start_corner(0), (GLfloat)m_selection_rectangle_end_corner(1), (GLfloat)0.5f); ::glVertex3f((GLfloat)m_selection_rectangle_start_corner(0), (GLfloat)m_selection_rectangle_end_corner(1), (GLfloat)0.5f);
::glEnd(); glsafe(::glEnd());
::glPopAttrib(); glsafe(::glPopAttrib());
::glPopMatrix(); // restore former projection matrix glsafe(::glPopMatrix()); // restore former projection matrix
::glMatrixMode(GL_MODELVIEW); glsafe(::glMatrixMode(GL_MODELVIEW));
::glPopMatrix(); // restore former modelview matrix glsafe(::glPopMatrix()); // restore former modelview matrix
::glPopAttrib(); // restore former MatrixMode glsafe(::glPopAttrib()); // restore former MatrixMode
} }
void GLGizmoSlaSupports::on_render_for_picking(const Selection& selection) const void GLGizmoSlaSupports::on_render_for_picking(const Selection& selection) const
{ {
::glEnable(GL_DEPTH_TEST); glsafe(::glEnable(GL_DEPTH_TEST));
render_points(selection, true); render_points(selection, true);
} }
@ -146,16 +147,16 @@ void GLGizmoSlaSupports::render_points(const Selection& selection, bool picking)
return; return;
if (!picking) if (!picking)
::glEnable(GL_LIGHTING); glsafe(::glEnable(GL_LIGHTING));
const GLVolume* vol = selection.get_volume(*selection.get_volume_idxs().begin()); const GLVolume* vol = selection.get_volume(*selection.get_volume_idxs().begin());
double z_shift = vol->get_sla_shift_z(); double z_shift = vol->get_sla_shift_z();
const Transform3d& instance_scaling_matrix_inverse = vol->get_instance_transformation().get_matrix(true, true, false, true).inverse(); const Transform3d& instance_scaling_matrix_inverse = vol->get_instance_transformation().get_matrix(true, true, false, true).inverse();
const Transform3d& instance_matrix = vol->get_instance_transformation().get_matrix(); const Transform3d& instance_matrix = vol->get_instance_transformation().get_matrix();
::glPushMatrix(); glsafe(::glPushMatrix());
::glTranslated(0.0, 0.0, z_shift); glsafe(::glTranslated(0.0, 0.0, z_shift));
::glMultMatrixd(instance_matrix.data()); glsafe(::glMultMatrixd(instance_matrix.data()));
float render_color[3]; float render_color[3];
for (int i = 0; i < (int)m_editing_mode_cache.size(); ++i) for (int i = 0; i < (int)m_editing_mode_cache.size(); ++i)
@ -187,14 +188,14 @@ void GLGizmoSlaSupports::render_points(const Selection& selection, bool picking)
for (unsigned char i=0; i<3; ++i) render_color[i] = 0.5f; for (unsigned char i=0; i<3; ++i) render_color[i] = 0.5f;
} }
} }
::glColor3fv(render_color); glsafe(::glColor3fv(render_color));
float render_color_emissive[4] = { 0.5f * render_color[0], 0.5f * render_color[1], 0.5f * render_color[2], 1.f}; float render_color_emissive[4] = { 0.5f * render_color[0], 0.5f * render_color[1], 0.5f * render_color[2], 1.f};
::glMaterialfv(GL_FRONT, GL_EMISSION, render_color_emissive); glsafe(::glMaterialfv(GL_FRONT, GL_EMISSION, render_color_emissive));
// Inverse matrix of the instance scaling is applied so that the mark does not scale with the object. // Inverse matrix of the instance scaling is applied so that the mark does not scale with the object.
::glPushMatrix(); glsafe(::glPushMatrix());
::glTranslated(support_point.pos(0), support_point.pos(1), support_point.pos(2)); glsafe(::glTranslated(support_point.pos(0), support_point.pos(1), support_point.pos(2)));
::glMultMatrixd(instance_scaling_matrix_inverse.data()); glsafe(::glMultMatrixd(instance_scaling_matrix_inverse.data()));
// Matrices set, we can render the point mark now. // Matrices set, we can render the point mark now.
// If in editing mode, we'll also render a cone pointing to the sphere. // If in editing mode, we'll also render a cone pointing to the sphere.
@ -205,31 +206,31 @@ void GLGizmoSlaSupports::render_points(const Selection& selection, bool picking)
Eigen::Quaterniond q; Eigen::Quaterniond q;
q.setFromTwoVectors(Vec3d{0., 0., 1.}, instance_scaling_matrix_inverse * m_editing_mode_cache[i].normal.cast<double>()); q.setFromTwoVectors(Vec3d{0., 0., 1.}, instance_scaling_matrix_inverse * m_editing_mode_cache[i].normal.cast<double>());
Eigen::AngleAxisd aa(q); Eigen::AngleAxisd aa(q);
::glRotated(aa.angle() * (180./M_PI), aa.axis()(0), aa.axis()(1), aa.axis()(2)); glsafe(::glRotated(aa.angle() * (180. / M_PI), aa.axis()(0), aa.axis()(1), aa.axis()(2)));
const float cone_radius = 0.25f; // mm const float cone_radius = 0.25f; // mm
const float cone_height = 0.75f; const float cone_height = 0.75f;
::glPushMatrix(); glsafe(::glPushMatrix());
::glTranslatef(0.f, 0.f, m_editing_mode_cache[i].support_point.head_front_radius * RenderPointScale); glsafe(::glTranslatef(0.f, 0.f, m_editing_mode_cache[i].support_point.head_front_radius * RenderPointScale));
::gluCylinder(m_quadric, 0.f, cone_radius, cone_height, 24, 1); ::gluCylinder(m_quadric, 0.f, cone_radius, cone_height, 24, 1);
::glTranslatef(0.f, 0.f, cone_height); glsafe(::glTranslatef(0.f, 0.f, cone_height));
::gluDisk(m_quadric, 0.0, cone_radius, 24, 1); ::gluDisk(m_quadric, 0.0, cone_radius, 24, 1);
::glPopMatrix(); glsafe(::glPopMatrix());
} }
::gluSphere(m_quadric, m_editing_mode_cache[i].support_point.head_front_radius * RenderPointScale, 24, 12); ::gluSphere(m_quadric, m_editing_mode_cache[i].support_point.head_front_radius * RenderPointScale, 24, 12);
::glPopMatrix(); glsafe(::glPopMatrix());
} }
{ {
// Reset emissive component to zero (the default value) // Reset emissive component to zero (the default value)
float render_color_emissive[4] = { 0.f, 0.f, 0.f, 1.f }; float render_color_emissive[4] = { 0.f, 0.f, 0.f, 1.f };
::glMaterialfv(GL_FRONT, GL_EMISSION, render_color_emissive); glsafe(::glMaterialfv(GL_FRONT, GL_EMISSION, render_color_emissive));
} }
if (!picking) if (!picking)
::glDisable(GL_LIGHTING); glsafe(::glDisable(GL_LIGHTING));
::glPopMatrix(); glsafe(::glPopMatrix());
} }
bool GLGizmoSlaSupports::is_mesh_update_necessary() const bool GLGizmoSlaSupports::is_mesh_update_necessary() const
@ -272,17 +273,15 @@ std::pair<Vec3f, Vec3f> GLGizmoSlaSupports::unproject_on_mesh(const Vec2d& mouse
if (m_V.size() == 0) if (m_V.size() == 0)
update_mesh(); update_mesh();
Eigen::Matrix<GLint, 4, 1, Eigen::DontAlign> viewport; const Camera& camera = m_parent.get_camera();
::glGetIntegerv(GL_VIEWPORT, viewport.data()); const std::array<int, 4>& viewport = camera.get_viewport();
Eigen::Matrix<GLdouble, 4, 4, Eigen::DontAlign> modelview_matrix; const Transform3d& modelview_matrix = camera.get_view_matrix();
::glGetDoublev(GL_MODELVIEW_MATRIX, modelview_matrix.data()); const Transform3d& projection_matrix = camera.get_projection_matrix();
Eigen::Matrix<GLdouble, 4, 4, Eigen::DontAlign> projection_matrix;
::glGetDoublev(GL_PROJECTION_MATRIX, projection_matrix.data());
Vec3d point1; Vec3d point1;
Vec3d point2; Vec3d point2;
::gluUnProject(mouse_pos(0), viewport(3)-mouse_pos(1), 0.f, modelview_matrix.data(), projection_matrix.data(), viewport.data(), &point1(0), &point1(1), &point1(2)); ::gluUnProject(mouse_pos(0), viewport[3] - mouse_pos(1), 0.f, modelview_matrix.data(), projection_matrix.data(), viewport.data(), &point1(0), &point1(1), &point1(2));
::gluUnProject(mouse_pos(0), viewport(3)-mouse_pos(1), 1.f, modelview_matrix.data(), projection_matrix.data(), viewport.data(), &point2(0), &point2(1), &point2(2)); ::gluUnProject(mouse_pos(0), viewport[3] - mouse_pos(1), 1.f, modelview_matrix.data(), projection_matrix.data(), viewport.data(), &point2(0), &point2(1), &point2(2));
igl::Hit hit; igl::Hit hit;
@ -368,12 +367,10 @@ bool GLGizmoSlaSupports::gizmo_event(SLAGizmoEventType action, const Vec2d& mous
// left up with selection rectangle - select points inside the rectangle: // left up with selection rectangle - select points inside the rectangle:
if ((action == SLAGizmoEventType::LeftUp || action == SLAGizmoEventType::ShiftUp) && m_selection_rectangle_active) { if ((action == SLAGizmoEventType::LeftUp || action == SLAGizmoEventType::ShiftUp) && m_selection_rectangle_active) {
const Transform3d& instance_matrix = m_model_object->instances[m_active_instance]->get_transformation().get_matrix(); const Transform3d& instance_matrix = m_model_object->instances[m_active_instance]->get_transformation().get_matrix();
GLint viewport[4]; const Camera& camera = m_parent.get_camera();
::glGetIntegerv(GL_VIEWPORT, viewport); const std::array<int, 4>& viewport = camera.get_viewport();
GLdouble modelview_matrix[16]; const Transform3d& modelview_matrix = camera.get_view_matrix();
::glGetDoublev(GL_MODELVIEW_MATRIX, modelview_matrix); const Transform3d& projection_matrix = camera.get_projection_matrix();
GLdouble projection_matrix[16];
::glGetDoublev(GL_PROJECTION_MATRIX, projection_matrix);
const Selection& selection = m_parent.get_selection(); const Selection& selection = m_parent.get_selection();
const GLVolume* volume = selection.get_volume(*selection.get_volume_idxs().begin()); const GLVolume* volume = selection.get_volume(*selection.get_volume_idxs().begin());
@ -384,7 +381,7 @@ bool GLGizmoSlaSupports::gizmo_event(SLAGizmoEventType action, const Vec2d& mous
const Transform3d& instance_matrix_no_translation = volume->get_instance_transformation().get_matrix(true); const Transform3d& instance_matrix_no_translation = volume->get_instance_transformation().get_matrix(true);
// we'll recover current look direction from the modelview matrix (in world coords)... // we'll recover current look direction from the modelview matrix (in world coords)...
Vec3f direction_to_camera(modelview_matrix[2], modelview_matrix[6], modelview_matrix[10]); Vec3f direction_to_camera = camera.get_dir_forward().cast<float>();
// ...and transform it to model coords. // ...and transform it to model coords.
direction_to_camera = (instance_matrix_no_translation.inverse().cast<float>() * direction_to_camera).normalized().eval(); direction_to_camera = (instance_matrix_no_translation.inverse().cast<float>() * direction_to_camera).normalized().eval();
@ -394,7 +391,7 @@ bool GLGizmoSlaSupports::gizmo_event(SLAGizmoEventType action, const Vec2d& mous
Vec3f pos = instance_matrix.cast<float>() * support_point.pos; Vec3f pos = instance_matrix.cast<float>() * support_point.pos;
pos(2) += z_offset; pos(2) += z_offset;
GLdouble out_x, out_y, out_z; GLdouble out_x, out_y, out_z;
::gluProject((GLdouble)pos(0), (GLdouble)pos(1), (GLdouble)pos(2), modelview_matrix, projection_matrix, viewport, &out_x, &out_y, &out_z); ::gluProject((GLdouble)pos(0), (GLdouble)pos(1), (GLdouble)pos(2), (GLdouble*)modelview_matrix.data(), (GLdouble*)projection_matrix.data(), (GLint*)viewport.data(), &out_x, &out_y, &out_z);
out_y = m_canvas_height - out_y; out_y = m_canvas_height - out_y;
if (rectangle.contains(Point(out_x, out_y))) { if (rectangle.contains(Point(out_x, out_y))) {

1
src/slic3r/GUI/Gizmos/GLGizmoSlaSupports.hpp
View file

@ -2,6 +2,7 @@
#define slic3r_GLGizmoSlaSupports_hpp_ #define slic3r_GLGizmoSlaSupports_hpp_
#include "GLGizmoBase.hpp" #include "GLGizmoBase.hpp"
#include "GLGizmos.hpp"
// There is an L function in igl that would be overridden by our localization macro - let's undefine it... // There is an L function in igl that would be overridden by our localization macro - let's undefine it...
#undef L #undef L

15
src/slic3r/GUI/Gizmos/GLGizmos.hpp
View file

@ -1,6 +1,21 @@
#ifndef slic3r_GLGizmos_hpp_ #ifndef slic3r_GLGizmos_hpp_
#define slic3r_GLGizmos_hpp_ #define slic3r_GLGizmos_hpp_
// this describes events being passed from GLCanvas3D to SlaSupport gizmo
enum class SLAGizmoEventType {
LeftDown = 1,
LeftUp,
RightDown,
Dragging,
Delete,
SelectAll,
ShiftUp,
ApplyChanges,
DiscardChanges,
AutomaticGeneration,
ManualEditing
};
#include "slic3r/GUI/Gizmos/GLGizmoMove.hpp" #include "slic3r/GUI/Gizmos/GLGizmoMove.hpp"
#include "slic3r/GUI/Gizmos/GLGizmoScale.hpp" #include "slic3r/GUI/Gizmos/GLGizmoScale.hpp"
#include "slic3r/GUI/Gizmos/GLGizmoRotate.hpp" #include "slic3r/GUI/Gizmos/GLGizmoRotate.hpp"

1215
src/slic3r/GUI/Gizmos/GLGizmosManager.cpp Normal file
View file

File diff suppressed because it is too large Load diff

184
src/slic3r/GUI/Gizmos/GLGizmosManager.hpp Normal file
View file

@ -0,0 +1,184 @@
#ifndef slic3r_GUI_GLGizmosManager_hpp_
#define slic3r_GUI_GLGizmosManager_hpp_
#include "slic3r/GUI/GLTexture.hpp"
#include "slic3r/GUI/GLToolbar.hpp"
#include "slic3r/GUI/Gizmos/GLGizmos.hpp"
#include <map>
namespace Slic3r {
namespace GUI {
class Selection;
class GLGizmoBase;
class GLCanvas3D;
class Rect
{
float m_left;
float m_top;
float m_right;
float m_bottom;
public:
Rect() : m_left(0.0f) , m_top(0.0f) , m_right(0.0f) , m_bottom(0.0f) {}
Rect(float left, float top, float right, float bottom) : m_left(left) , m_top(top) , m_right(right) , m_bottom(bottom) {}
float get_left() const { return m_left; }
void set_left(float left) { m_left = left; }
float get_top() const { return m_top; }
void set_top(float top) { m_top = top; }
float get_right() const { return m_right; }
void set_right(float right) { m_right = right; }
float get_bottom() const { return m_bottom; }
void set_bottom(float bottom) { m_bottom = bottom; }
float get_width() const { return m_right - m_left; }
float get_height() const { return m_top - m_bottom; }
};
class GLGizmosManager
{
public:
#if ENABLE_SVG_ICONS
static const float Default_Icons_Size;
#endif // ENABLE_SVG_ICONS
enum EType : unsigned char
{
Undefined,
Move,
Scale,
Rotate,
Flatten,
Cut,
SlaSupports,
Num_Types
};
private:
bool m_enabled;
typedef std::map<EType, GLGizmoBase*> GizmosMap;
GizmosMap m_gizmos;
#if ENABLE_SVG_ICONS
mutable GLTexture m_icons_texture;
mutable bool m_icons_texture_dirty;
#else
ItemsIconsTexture m_icons_texture;
#endif // ENABLE_SVG_ICONS
BackgroundTexture m_background_texture;
EType m_current;
#if ENABLE_SVG_ICONS
float m_overlay_icons_size;
float m_overlay_scale;
#else
float m_overlay_icons_scale;
#endif // ENABLE_SVG_ICONS
float m_overlay_border;
float m_overlay_gap_y;
struct MouseCapture
{
bool left;
bool middle;
bool right;
GLCanvas3D* parent;
MouseCapture() { reset(); }
bool any() const { return left || middle || right; }
void reset() { left = middle = right = false; parent = nullptr; }
};
MouseCapture m_mouse_capture;
std::string m_tooltip;
public:
GLGizmosManager();
~GLGizmosManager();
bool init(GLCanvas3D& parent);
bool is_enabled() const { return m_enabled; }
void set_enabled(bool enable) { m_enabled = enable; }
#if ENABLE_SVG_ICONS
void set_overlay_icon_size(float size);
#endif // ENABLE_SVG_ICONS
void set_overlay_scale(float scale);
void refresh_on_off_state(const Selection& selection);
void reset_all_states();
void set_hover_id(int id);
void enable_grabber(EType type, unsigned int id, bool enable);
void update(const Linef3& mouse_ray, const Selection& selection, bool shift_down, const Point* mouse_pos = nullptr);
void update_data(GLCanvas3D& canvas);
Rect get_reset_rect_viewport(const GLCanvas3D& canvas) const;
EType get_current_type() const { return m_current; }
bool is_running() const;
bool handle_shortcut(int key, const Selection& selection);
bool is_dragging() const;
void start_dragging(const Selection& selection);
void stop_dragging();
Vec3d get_displacement() const;
Vec3d get_scale() const;
void set_scale(const Vec3d& scale);
Vec3d get_rotation() const;
void set_rotation(const Vec3d& rotation);
Vec3d get_flattening_normal() const;
void set_flattening_data(const ModelObject* model_object);
void set_sla_support_data(ModelObject* model_object, const Selection& selection);
bool gizmo_event(SLAGizmoEventType action, const Vec2d& mouse_position = Vec2d::Zero(), bool shift_down = false);
void render_current_gizmo(const Selection& selection) const;
void render_current_gizmo_for_picking_pass(const Selection& selection) const;
void render_overlay(const GLCanvas3D& canvas, const Selection& selection) const;
const std::string& get_tooltip() const { return m_tooltip; }
bool on_mouse(wxMouseEvent& evt, GLCanvas3D& canvas);
bool on_char(wxKeyEvent& evt, GLCanvas3D& canvas);
bool on_key(wxKeyEvent& evt, GLCanvas3D& canvas);
private:
void reset();
void do_render_overlay(const GLCanvas3D& canvas, const Selection& selection) const;
float get_total_overlay_height() const;
float get_total_overlay_width() const;
GLGizmoBase* get_current() const;
#if ENABLE_SVG_ICONS
bool generate_icons_texture() const;
#endif // ENABLE_SVG_ICONS
void update_on_off_state(const GLCanvas3D& canvas, const Vec2d& mouse_pos, const Selection& selection);
std::string update_hover_state(const GLCanvas3D& canvas, const Vec2d& mouse_pos);
bool overlay_contains_mouse(const GLCanvas3D& canvas, const Vec2d& mouse_pos) const;
bool grabber_contains_mouse() const;
};
} // namespace GUI
} // namespace Slic3r
#endif // slic3r_GUI_GLGizmosManager_hpp_

113
src/slic3r/GUI/ImGuiWrapper.cpp
View file

@ -19,6 +19,7 @@
#include "libslic3r/libslic3r.h" #include "libslic3r/libslic3r.h"
#include "libslic3r/Utils.hpp" #include "libslic3r/Utils.hpp"
#include "3DScene.hpp"
#include "GUI.hpp" #include "GUI.hpp"
namespace Slic3r { namespace Slic3r {
@ -359,19 +360,19 @@ void ImGuiWrapper::init_font()
// Upload texture to graphics system // Upload texture to graphics system
GLint last_texture; GLint last_texture;
glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture); glsafe(::glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture));
glGenTextures(1, &m_font_texture); glsafe(::glGenTextures(1, &m_font_texture));
glBindTexture(GL_TEXTURE_2D, m_font_texture); glsafe(::glBindTexture(GL_TEXTURE_2D, m_font_texture));
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0); glsafe(::glPixelStorei(GL_UNPACK_ROW_LENGTH, 0));
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels); glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels));
// Store our identifier // Store our identifier
io.Fonts->TexID = (ImTextureID)(intptr_t)m_font_texture; io.Fonts->TexID = (ImTextureID)(intptr_t)m_font_texture;
// Restore state // Restore state
glBindTexture(GL_TEXTURE_2D, last_texture); glsafe(::glBindTexture(GL_TEXTURE_2D, last_texture));
} }
void ImGuiWrapper::init_input() void ImGuiWrapper::init_input()
@ -466,39 +467,39 @@ void ImGuiWrapper::render_draw_data(ImDrawData *draw_data)
// We are using the OpenGL fixed pipeline to make the example code simpler to read! // We are using the OpenGL fixed pipeline to make the example code simpler to read!
// Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled, vertex/texcoord/color pointers, polygon fill. // Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled, vertex/texcoord/color pointers, polygon fill.
GLint last_texture; glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture); GLint last_texture; glsafe(::glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture));
GLint last_polygon_mode[2]; glGetIntegerv(GL_POLYGON_MODE, last_polygon_mode); GLint last_polygon_mode[2]; glsafe(::glGetIntegerv(GL_POLYGON_MODE, last_polygon_mode));
GLint last_viewport[4]; glGetIntegerv(GL_VIEWPORT, last_viewport); GLint last_viewport[4]; glsafe(::glGetIntegerv(GL_VIEWPORT, last_viewport));
GLint last_scissor_box[4]; glGetIntegerv(GL_SCISSOR_BOX, last_scissor_box); GLint last_scissor_box[4]; glsafe(::glGetIntegerv(GL_SCISSOR_BOX, last_scissor_box));
glPushAttrib(GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT | GL_TRANSFORM_BIT); glsafe(::glPushAttrib(GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT | GL_TRANSFORM_BIT));
glEnable(GL_BLEND); glsafe(::glEnable(GL_BLEND));
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glsafe(::glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA));
glDisable(GL_CULL_FACE); glsafe(::glDisable(GL_CULL_FACE));
glDisable(GL_DEPTH_TEST); glsafe(::glDisable(GL_DEPTH_TEST));
glDisable(GL_LIGHTING); glsafe(::glDisable(GL_LIGHTING));
glDisable(GL_COLOR_MATERIAL); glsafe(::glDisable(GL_COLOR_MATERIAL));
glEnable(GL_SCISSOR_TEST); glsafe(::glEnable(GL_SCISSOR_TEST));
glEnableClientState(GL_VERTEX_ARRAY); glsafe(::glEnableClientState(GL_VERTEX_ARRAY));
glEnableClientState(GL_TEXTURE_COORD_ARRAY); glsafe(::glEnableClientState(GL_TEXTURE_COORD_ARRAY));
glEnableClientState(GL_COLOR_ARRAY); glsafe(::glEnableClientState(GL_COLOR_ARRAY));
glEnable(GL_TEXTURE_2D); glsafe(::glEnable(GL_TEXTURE_2D));
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); glsafe(::glPolygonMode(GL_FRONT_AND_BACK, GL_FILL));
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); glsafe(::glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE));
GLint texture_env_mode = GL_MODULATE; GLint texture_env_mode = GL_MODULATE;
glGetTexEnviv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, &texture_env_mode); glsafe(::glGetTexEnviv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, &texture_env_mode));
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); glsafe(::glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE));
//glUseProgram(0); // You may want this if using this code in an OpenGL 3+ context where shaders may be bound //glUseProgram(0); // You may want this if using this code in an OpenGL 3+ context where shaders may be bound
// Setup viewport, orthographic projection matrix // Setup viewport, orthographic projection matrix
// Our visible imgui space lies from draw_data->DisplayPps (top left) to draw_data->DisplayPos+data_data->DisplaySize (bottom right). DisplayMin is typically (0,0) for single viewport apps. // Our visible imgui space lies from draw_data->DisplayPps (top left) to draw_data->DisplayPos+data_data->DisplaySize (bottom right). DisplayMin is typically (0,0) for single viewport apps.
glViewport(0, 0, (GLsizei)fb_width, (GLsizei)fb_height); glsafe(::glViewport(0, 0, (GLsizei)fb_width, (GLsizei)fb_height));
glMatrixMode(GL_PROJECTION); glsafe(::glMatrixMode(GL_PROJECTION));
glPushMatrix(); glsafe(::glPushMatrix());
glLoadIdentity(); glsafe(::glLoadIdentity());
glOrtho(draw_data->DisplayPos.x, draw_data->DisplayPos.x + draw_data->DisplaySize.x, draw_data->DisplayPos.y + draw_data->DisplaySize.y, draw_data->DisplayPos.y, -1.0f, +1.0f); glsafe(::glOrtho(draw_data->DisplayPos.x, draw_data->DisplayPos.x + draw_data->DisplaySize.x, draw_data->DisplayPos.y + draw_data->DisplaySize.y, draw_data->DisplayPos.y, -1.0f, +1.0f));
glMatrixMode(GL_MODELVIEW); glsafe(::glMatrixMode(GL_MODELVIEW));
glPushMatrix(); glsafe(::glPushMatrix());
glLoadIdentity(); glsafe(::glLoadIdentity());
// Render command lists // Render command lists
ImVec2 pos = draw_data->DisplayPos; ImVec2 pos = draw_data->DisplayPos;
@ -507,9 +508,9 @@ void ImGuiWrapper::render_draw_data(ImDrawData *draw_data)
const ImDrawList* cmd_list = draw_data->CmdLists[n]; const ImDrawList* cmd_list = draw_data->CmdLists[n];
const ImDrawVert* vtx_buffer = cmd_list->VtxBuffer.Data; const ImDrawVert* vtx_buffer = cmd_list->VtxBuffer.Data;
const ImDrawIdx* idx_buffer = cmd_list->IdxBuffer.Data; const ImDrawIdx* idx_buffer = cmd_list->IdxBuffer.Data;
glVertexPointer(2, GL_FLOAT, sizeof(ImDrawVert), (const GLvoid*)((const char*)vtx_buffer + IM_OFFSETOF(ImDrawVert, pos))); glsafe(::glVertexPointer(2, GL_FLOAT, sizeof(ImDrawVert), (const GLvoid*)((const char*)vtx_buffer + IM_OFFSETOF(ImDrawVert, pos))));
glTexCoordPointer(2, GL_FLOAT, sizeof(ImDrawVert), (const GLvoid*)((const char*)vtx_buffer + IM_OFFSETOF(ImDrawVert, uv))); glsafe(::glTexCoordPointer(2, GL_FLOAT, sizeof(ImDrawVert), (const GLvoid*)((const char*)vtx_buffer + IM_OFFSETOF(ImDrawVert, uv))));
glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(ImDrawVert), (const GLvoid*)((const char*)vtx_buffer + IM_OFFSETOF(ImDrawVert, col))); glsafe(::glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(ImDrawVert), (const GLvoid*)((const char*)vtx_buffer + IM_OFFSETOF(ImDrawVert, col))));
for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.Size; cmd_i++) for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.Size; cmd_i++)
{ {
@ -525,11 +526,11 @@ void ImGuiWrapper::render_draw_data(ImDrawData *draw_data)
if (clip_rect.x < fb_width && clip_rect.y < fb_height && clip_rect.z >= 0.0f && clip_rect.w >= 0.0f) if (clip_rect.x < fb_width && clip_rect.y < fb_height && clip_rect.z >= 0.0f && clip_rect.w >= 0.0f)
{ {
// Apply scissor/clipping rectangle // Apply scissor/clipping rectangle
glScissor((int)clip_rect.x, (int)(fb_height - clip_rect.w), (int)(clip_rect.z - clip_rect.x), (int)(clip_rect.w - clip_rect.y)); glsafe(::glScissor((int)clip_rect.x, (int)(fb_height - clip_rect.w), (int)(clip_rect.z - clip_rect.x), (int)(clip_rect.w - clip_rect.y)));
// Bind texture, Draw // Bind texture, Draw
glBindTexture(GL_TEXTURE_2D, (GLuint)(intptr_t)pcmd->TextureId); glsafe(::glBindTexture(GL_TEXTURE_2D, (GLuint)(intptr_t)pcmd->TextureId));
glDrawElements(GL_TRIANGLES, (GLsizei)pcmd->ElemCount, sizeof(ImDrawIdx) == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT, idx_buffer); glsafe(::glDrawElements(GL_TRIANGLES, (GLsizei)pcmd->ElemCount, sizeof(ImDrawIdx) == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT, idx_buffer));
} }
} }
idx_buffer += pcmd->ElemCount; idx_buffer += pcmd->ElemCount;
@ -537,19 +538,19 @@ void ImGuiWrapper::render_draw_data(ImDrawData *draw_data)
} }
// Restore modified state // Restore modified state
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, texture_env_mode); glsafe(::glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, texture_env_mode));
glDisableClientState(GL_COLOR_ARRAY); glsafe(::glDisableClientState(GL_COLOR_ARRAY));
glDisableClientState(GL_TEXTURE_COORD_ARRAY); glsafe(::glDisableClientState(GL_TEXTURE_COORD_ARRAY));
glDisableClientState(GL_VERTEX_ARRAY); glsafe(::glDisableClientState(GL_VERTEX_ARRAY));
glBindTexture(GL_TEXTURE_2D, (GLuint)last_texture); glsafe(::glBindTexture(GL_TEXTURE_2D, (GLuint)last_texture));
glMatrixMode(GL_MODELVIEW); glsafe(::glMatrixMode(GL_MODELVIEW));
glPopMatrix(); glsafe(::glPopMatrix());
glMatrixMode(GL_PROJECTION); glsafe(::glMatrixMode(GL_PROJECTION));
glPopMatrix(); glsafe(::glPopMatrix());
glPopAttrib(); glsafe(::glPopAttrib());
glPolygonMode(GL_FRONT, (GLenum)last_polygon_mode[0]); glPolygonMode(GL_BACK, (GLenum)last_polygon_mode[1]); glsafe(::glPolygonMode(GL_FRONT, (GLenum)last_polygon_mode[0]); glPolygonMode(GL_BACK, (GLenum)last_polygon_mode[1]));
glViewport(last_viewport[0], last_viewport[1], (GLsizei)last_viewport[2], (GLsizei)last_viewport[3]); glsafe(::glViewport(last_viewport[0], last_viewport[1], (GLsizei)last_viewport[2], (GLsizei)last_viewport[3]));
glScissor(last_scissor_box[0], last_scissor_box[1], (GLsizei)last_scissor_box[2], (GLsizei)last_scissor_box[3]); glsafe(::glScissor(last_scissor_box[0], last_scissor_box[1], (GLsizei)last_scissor_box[2], (GLsizei)last_scissor_box[3]));
} }
bool ImGuiWrapper::display_initialized() const bool ImGuiWrapper::display_initialized() const
@ -563,7 +564,7 @@ void ImGuiWrapper::destroy_font()
if (m_font_texture != 0) { if (m_font_texture != 0) {
ImGuiIO& io = ImGui::GetIO(); ImGuiIO& io = ImGui::GetIO();
io.Fonts->TexID = 0; io.Fonts->TexID = 0;
glDeleteTextures(1, &m_font_texture); glsafe(::glDeleteTextures(1, &m_font_texture));
m_font_texture = 0; m_font_texture = 0;
} }
} }

251
src/slic3r/GUI/Selection.cpp
View file

@ -6,6 +6,7 @@
#include "GUI_ObjectManipulation.hpp" #include "GUI_ObjectManipulation.hpp"
#include "GUI_ObjectList.hpp" #include "GUI_ObjectList.hpp"
#include "Gizmos/GLGizmoBase.hpp" #include "Gizmos/GLGizmoBase.hpp"
#include "slic3r/GUI/3DScene.hpp"
#include <GL/glew.h> #include <GL/glew.h>
@ -75,7 +76,7 @@ Selection::~Selection()
void Selection::set_volumes(GLVolumePtrs* volumes) void Selection::set_volumes(GLVolumePtrs* volumes)
{ {
m_volumes = volumes; m_volumes = volumes;
_update_valid(); update_valid();
} }
bool Selection::init(bool useVBOs) bool Selection::init(bool useVBOs)
@ -95,7 +96,7 @@ bool Selection::init(bool useVBOs)
void Selection::set_model(Model* model) void Selection::set_model(Model* model)
{ {
m_model = model; m_model = model;
_update_valid(); update_valid();
} }
void Selection::add(unsigned int volume_idx, bool as_single_selection) void Selection::add(unsigned int volume_idx, bool as_single_selection)
@ -134,18 +135,18 @@ void Selection::add(unsigned int volume_idx, bool as_single_selection)
case Volume: case Volume:
{ {
if ((volume->volume_idx() >= 0) && (is_empty() || (volume->instance_idx() == get_instance_idx()))) if ((volume->volume_idx() >= 0) && (is_empty() || (volume->instance_idx() == get_instance_idx())))
_add_volume(volume_idx); do_add_volume(volume_idx);
break; break;
} }
case Instance: case Instance:
{ {
_add_instance(volume->object_idx(), volume->instance_idx()); do_add_instance(volume->object_idx(), volume->instance_idx());
break; break;
} }
} }
_update_type(); update_type();
m_bounding_box_dirty = true; m_bounding_box_dirty = true;
} }
@ -160,17 +161,17 @@ void Selection::remove(unsigned int volume_idx)
{ {
case Volume: case Volume:
{ {
_remove_volume(volume_idx); do_remove_volume(volume_idx);
break; break;
} }
case Instance: case Instance:
{ {
_remove_instance(volume->object_idx(), volume->instance_idx()); do_remove_instance(volume->object_idx(), volume->instance_idx());
break; break;
} }
} }
_update_type(); update_type();
m_bounding_box_dirty = true; m_bounding_box_dirty = true;
} }
@ -185,9 +186,9 @@ void Selection::add_object(unsigned int object_idx, bool as_single_selection)
m_mode = Instance; m_mode = Instance;
_add_object(object_idx); do_add_object(object_idx);
_update_type(); update_type();
m_bounding_box_dirty = true; m_bounding_box_dirty = true;
} }
@ -196,9 +197,9 @@ void Selection::remove_object(unsigned int object_idx)
if (!m_valid) if (!m_valid)
return; return;
_remove_object(object_idx); do_remove_object(object_idx);
_update_type(); update_type();
m_bounding_box_dirty = true; m_bounding_box_dirty = true;
} }
@ -213,9 +214,9 @@ void Selection::add_instance(unsigned int object_idx, unsigned int instance_idx,
m_mode = Instance; m_mode = Instance;
_add_instance(object_idx, instance_idx); do_add_instance(object_idx, instance_idx);
_update_type(); update_type();
m_bounding_box_dirty = true; m_bounding_box_dirty = true;
} }
@ -224,9 +225,9 @@ void Selection::remove_instance(unsigned int object_idx, unsigned int instance_i
if (!m_valid) if (!m_valid)
return; return;
_remove_instance(object_idx, instance_idx); do_remove_instance(object_idx, instance_idx);
_update_type(); update_type();
m_bounding_box_dirty = true; m_bounding_box_dirty = true;
} }
@ -247,11 +248,11 @@ void Selection::add_volume(unsigned int object_idx, unsigned int volume_idx, int
if ((v->object_idx() == object_idx) && (v->volume_idx() == volume_idx)) if ((v->object_idx() == object_idx) && (v->volume_idx() == volume_idx))
{ {
if ((instance_idx != -1) && (v->instance_idx() == instance_idx)) if ((instance_idx != -1) && (v->instance_idx() == instance_idx))
_add_volume(i); do_add_volume(i);
} }
} }
_update_type(); update_type();
m_bounding_box_dirty = true; m_bounding_box_dirty = true;
} }
@ -264,10 +265,10 @@ void Selection::remove_volume(unsigned int object_idx, unsigned int volume_idx)
{ {
GLVolume* v = (*m_volumes)[i]; GLVolume* v = (*m_volumes)[i];
if ((v->object_idx() == object_idx) && (v->volume_idx() == volume_idx)) if ((v->object_idx() == object_idx) && (v->volume_idx() == volume_idx))
_remove_volume(i); do_remove_volume(i);
} }
_update_type(); update_type();
m_bounding_box_dirty = true; m_bounding_box_dirty = true;
} }
@ -282,10 +283,10 @@ void Selection::add_all()
for (unsigned int i = 0; i < (unsigned int)m_volumes->size(); ++i) for (unsigned int i = 0; i < (unsigned int)m_volumes->size(); ++i)
{ {
if (!(*m_volumes)[i]->is_wipe_tower) if (!(*m_volumes)[i]->is_wipe_tower)
_add_volume(i); do_add_volume(i);
} }
_update_type(); update_type();
m_bounding_box_dirty = true; m_bounding_box_dirty = true;
} }
@ -301,7 +302,7 @@ void Selection::clear()
m_list.clear(); m_list.clear();
_update_type(); update_type();
m_bounding_box_dirty = true; m_bounding_box_dirty = true;
// resets the cache in the sidebar // resets the cache in the sidebar
@ -341,11 +342,11 @@ void Selection::volumes_changed(const std::vector<size_t> &map_volume_old_to_new
const GLVolume* volume = (*m_volumes)[i]; const GLVolume* volume = (*m_volumes)[i];
for (const std::pair<int, int> &model_instance : model_instances) for (const std::pair<int, int> &model_instance : model_instances)
if (volume->object_idx() == model_instance.first && volume->instance_idx() == model_instance.second) if (volume->object_idx() == model_instance.first && volume->instance_idx() == model_instance.second)
this->_add_volume(i); do_add_volume(i);
} }
} }
_update_type(); update_type();
m_bounding_box_dirty = true; m_bounding_box_dirty = true;
} }
@ -426,7 +427,7 @@ const GLVolume* Selection::get_volume(unsigned int volume_idx) const
const BoundingBoxf3& Selection::get_bounding_box() const const BoundingBoxf3& Selection::get_bounding_box() const
{ {
if (m_bounding_box_dirty) if (m_bounding_box_dirty)
_calc_bounding_box(); calc_bounding_box();
return m_bounding_box; return m_bounding_box;
} }
@ -436,7 +437,7 @@ void Selection::start_dragging()
if (!m_valid) if (!m_valid)
return; return;
_set_caches(); set_caches();
} }
void Selection::translate(const Vec3d& displacement, bool local) void Selection::translate(const Vec3d& displacement, bool local)
@ -460,7 +461,7 @@ void Selection::translate(const Vec3d& displacement, bool local)
} }
else if (m_mode == Instance) else if (m_mode == Instance)
{ {
if (_is_from_fully_selected_instance(i)) if (is_from_fully_selected_instance(i))
(*m_volumes)[i]->set_instance_offset(m_cache.volumes_data[i].get_instance_position() + displacement); (*m_volumes)[i]->set_instance_offset(m_cache.volumes_data[i].get_instance_position() + displacement);
else else
{ {
@ -473,9 +474,9 @@ void Selection::translate(const Vec3d& displacement, bool local)
#if !DISABLE_INSTANCES_SYNCH #if !DISABLE_INSTANCES_SYNCH
if (translation_type == Instance) if (translation_type == Instance)
_synchronize_unselected_instances(SYNC_ROTATION_NONE); synchronize_unselected_instances(SYNC_ROTATION_NONE);
else if (translation_type == Volume) else if (translation_type == Volume)
_synchronize_unselected_volumes(); synchronize_unselected_volumes();
#endif // !DISABLE_INSTANCES_SYNCH #endif // !DISABLE_INSTANCES_SYNCH
m_bounding_box_dirty = true; m_bounding_box_dirty = true;
@ -604,9 +605,9 @@ void Selection::rotate(const Vec3d& rotation, TransformationType transformation_
#if !DISABLE_INSTANCES_SYNCH #if !DISABLE_INSTANCES_SYNCH
if (m_mode == Instance) if (m_mode == Instance)
_synchronize_unselected_instances((rot_axis_max == 2) ? SYNC_ROTATION_NONE : SYNC_ROTATION_GENERAL); synchronize_unselected_instances((rot_axis_max == 2) ? SYNC_ROTATION_NONE : SYNC_ROTATION_GENERAL);
else if (m_mode == Volume) else if (m_mode == Volume)
_synchronize_unselected_volumes(); synchronize_unselected_volumes();
#endif // !DISABLE_INSTANCES_SYNCH #endif // !DISABLE_INSTANCES_SYNCH
m_bounding_box_dirty = true; m_bounding_box_dirty = true;
@ -647,7 +648,7 @@ void Selection::flattening_rotate(const Vec3d& normal)
// we want to synchronize z-rotation as well, otherwise the flattening behaves funny // we want to synchronize z-rotation as well, otherwise the flattening behaves funny
// when applied on one of several identical instances // when applied on one of several identical instances
if (m_mode == Instance) if (m_mode == Instance)
_synchronize_unselected_instances(SYNC_ROTATION_FULL); synchronize_unselected_instances(SYNC_ROTATION_FULL);
#endif // !DISABLE_INSTANCES_SYNCH #endif // !DISABLE_INSTANCES_SYNCH
m_bounding_box_dirty = true; m_bounding_box_dirty = true;
@ -694,12 +695,12 @@ void Selection::scale(const Vec3d& scale, bool local)
#if !DISABLE_INSTANCES_SYNCH #if !DISABLE_INSTANCES_SYNCH
if (m_mode == Instance) if (m_mode == Instance)
_synchronize_unselected_instances(SYNC_ROTATION_NONE); synchronize_unselected_instances(SYNC_ROTATION_NONE);
else if (m_mode == Volume) else if (m_mode == Volume)
_synchronize_unselected_volumes(); synchronize_unselected_volumes();
#endif // !DISABLE_INSTANCES_SYNCH #endif // !DISABLE_INSTANCES_SYNCH
_ensure_on_bed(); ensure_on_bed();
m_bounding_box_dirty = true; m_bounding_box_dirty = true;
} }
@ -721,9 +722,9 @@ void Selection::mirror(Axis axis)
#if !DISABLE_INSTANCES_SYNCH #if !DISABLE_INSTANCES_SYNCH
if (m_mode == Instance) if (m_mode == Instance)
_synchronize_unselected_instances(SYNC_ROTATION_NONE); synchronize_unselected_instances(SYNC_ROTATION_NONE);
else if (m_mode == Volume) else if (m_mode == Volume)
_synchronize_unselected_volumes(); synchronize_unselected_volumes();
#endif // !DISABLE_INSTANCES_SYNCH #endif // !DISABLE_INSTANCES_SYNCH
m_bounding_box_dirty = true; m_bounding_box_dirty = true;
@ -941,8 +942,8 @@ void Selection::render(float scale_factor) const
m_scale_factor = scale_factor; m_scale_factor = scale_factor;
// render cumulative bounding box of selected volumes // render cumulative bounding box of selected volumes
_render_selected_volumes(); render_selected_volumes();
_render_synchronized_volumes(); render_synchronized_volumes();
} }
#if ENABLE_RENDER_SELECTION_CENTER #if ENABLE_RENDER_SELECTION_CENTER
@ -953,17 +954,17 @@ void Selection::render_center() const
const Vec3d& center = get_bounding_box().center(); const Vec3d& center = get_bounding_box().center();
::glDisable(GL_DEPTH_TEST); glsafe(::glDisable(GL_DEPTH_TEST)));
::glEnable(GL_LIGHTING); glsafe(::glEnable(GL_LIGHTING));
::glColor3f(1.0f, 1.0f, 1.0f); glsafe(::glColor3f(1.0f, 1.0f, 1.0f));
::glPushMatrix(); glsafe(::glPushMatrix());
::glTranslated(center(0), center(1), center(2)); glsafe(::glTranslated(center(0), center(1), center(2)));
::gluSphere(m_quadric, 0.75, 32, 32); glsafe(::gluSphere(m_quadric, 0.75, 32, 32));
::glPopMatrix(); glsafe(::glPopMatrix());
::glDisable(GL_LIGHTING); glsafe(::glDisable(GL_LIGHTING));
} }
#endif // ENABLE_RENDER_SELECTION_CENTER #endif // ENABLE_RENDER_SELECTION_CENTER
@ -972,18 +973,18 @@ void Selection::render_sidebar_hints(const std::string& sidebar_field) const
if (sidebar_field.empty()) if (sidebar_field.empty())
return; return;
::glClear(GL_DEPTH_BUFFER_BIT); glsafe(::glClear(GL_DEPTH_BUFFER_BIT));
::glEnable(GL_DEPTH_TEST); glsafe(::glEnable(GL_DEPTH_TEST));
::glEnable(GL_LIGHTING); glsafe(::glEnable(GL_LIGHTING));
::glPushMatrix(); glsafe(::glPushMatrix());
const Vec3d& center = get_bounding_box().center(); const Vec3d& center = get_bounding_box().center();
if (is_single_full_instance()) if (is_single_full_instance())
{ {
::glTranslated(center(0), center(1), center(2)); glsafe(::glTranslated(center(0), center(1), center(2)));
if (!boost::starts_with(sidebar_field, "position")) if (!boost::starts_with(sidebar_field, "position"))
{ {
Transform3d orient_matrix = Transform3d::Identity(); Transform3d orient_matrix = Transform3d::Identity();
@ -1003,40 +1004,40 @@ void Selection::render_sidebar_hints(const std::string& sidebar_field) const
} }
} }
::glMultMatrixd(orient_matrix.data()); glsafe(::glMultMatrixd(orient_matrix.data()));
} }
} }
else if (is_single_volume() || is_single_modifier()) else if (is_single_volume() || is_single_modifier())
{ {
::glTranslated(center(0), center(1), center(2)); glsafe(::glTranslated(center(0), center(1), center(2)));
Transform3d orient_matrix = (*m_volumes)[*m_list.begin()]->get_instance_transformation().get_matrix(true, false, true, true); Transform3d orient_matrix = (*m_volumes)[*m_list.begin()]->get_instance_transformation().get_matrix(true, false, true, true);
if (!boost::starts_with(sidebar_field, "position")) if (!boost::starts_with(sidebar_field, "position"))
orient_matrix = orient_matrix * (*m_volumes)[*m_list.begin()]->get_volume_transformation().get_matrix(true, false, true, true); orient_matrix = orient_matrix * (*m_volumes)[*m_list.begin()]->get_volume_transformation().get_matrix(true, false, true, true);
::glMultMatrixd(orient_matrix.data()); glsafe(::glMultMatrixd(orient_matrix.data()));
} }
else else
{ {
::glTranslated(center(0), center(1), center(2)); glsafe(::glTranslated(center(0), center(1), center(2)));
if (requires_local_axes()) if (requires_local_axes())
{ {
Transform3d orient_matrix = (*m_volumes)[*m_list.begin()]->get_instance_transformation().get_matrix(true, false, true, true); Transform3d orient_matrix = (*m_volumes)[*m_list.begin()]->get_instance_transformation().get_matrix(true, false, true, true);
::glMultMatrixd(orient_matrix.data()); glsafe(::glMultMatrixd(orient_matrix.data()));
} }
} }
if (boost::starts_with(sidebar_field, "position")) if (boost::starts_with(sidebar_field, "position"))
_render_sidebar_position_hints(sidebar_field); render_sidebar_position_hints(sidebar_field);
else if (boost::starts_with(sidebar_field, "rotation")) else if (boost::starts_with(sidebar_field, "rotation"))
_render_sidebar_rotation_hints(sidebar_field); render_sidebar_rotation_hints(sidebar_field);
else if (boost::starts_with(sidebar_field, "scale")) else if (boost::starts_with(sidebar_field, "scale"))
_render_sidebar_scale_hints(sidebar_field); render_sidebar_scale_hints(sidebar_field);
else if (boost::starts_with(sidebar_field, "size")) else if (boost::starts_with(sidebar_field, "size"))
_render_sidebar_size_hints(sidebar_field); render_sidebar_size_hints(sidebar_field);
::glPopMatrix(); glsafe(::glPopMatrix());
::glDisable(GL_LIGHTING); glsafe(::glDisable(GL_LIGHTING));
} }
bool Selection::requires_local_axes() const bool Selection::requires_local_axes() const
@ -1044,12 +1045,12 @@ bool Selection::requires_local_axes() const
return (m_mode == Volume) && is_from_single_instance(); return (m_mode == Volume) && is_from_single_instance();
} }
void Selection::_update_valid() void Selection::update_valid()
{ {
m_valid = (m_volumes != nullptr) && (m_model != nullptr); m_valid = (m_volumes != nullptr) && (m_model != nullptr);
} }
void Selection::_update_type() void Selection::update_type()
{ {
m_cache.content.clear(); m_cache.content.clear();
m_type = Mixed; m_type = Mixed;
@ -1273,7 +1274,7 @@ void Selection::_update_type()
#endif // ENABLE_SELECTION_DEBUG_OUTPUT #endif // ENABLE_SELECTION_DEBUG_OUTPUT
} }
void Selection::_set_caches() void Selection::set_caches()
{ {
m_cache.volumes_data.clear(); m_cache.volumes_data.clear();
for (unsigned int i = 0; i < (unsigned int)m_volumes->size(); ++i) for (unsigned int i = 0; i < (unsigned int)m_volumes->size(); ++i)
@ -1284,33 +1285,33 @@ void Selection::_set_caches()
m_cache.dragging_center = get_bounding_box().center(); m_cache.dragging_center = get_bounding_box().center();
} }
void Selection::_add_volume(unsigned int volume_idx) void Selection::do_add_volume(unsigned int volume_idx)
{ {
m_list.insert(volume_idx); m_list.insert(volume_idx);
(*m_volumes)[volume_idx]->selected = true; (*m_volumes)[volume_idx]->selected = true;
} }
void Selection::_add_instance(unsigned int object_idx, unsigned int instance_idx) void Selection::do_add_instance(unsigned int object_idx, unsigned int instance_idx)
{ {
for (unsigned int i = 0; i < (unsigned int)m_volumes->size(); ++i) for (unsigned int i = 0; i < (unsigned int)m_volumes->size(); ++i)
{ {
GLVolume* v = (*m_volumes)[i]; GLVolume* v = (*m_volumes)[i];
if ((v->object_idx() == object_idx) && (v->instance_idx() == instance_idx)) if ((v->object_idx() == object_idx) && (v->instance_idx() == instance_idx))
_add_volume(i); do_add_volume(i);
} }
} }
void Selection::_add_object(unsigned int object_idx) void Selection::do_add_object(unsigned int object_idx)
{ {
for (unsigned int i = 0; i < (unsigned int)m_volumes->size(); ++i) for (unsigned int i = 0; i < (unsigned int)m_volumes->size(); ++i)
{ {
GLVolume* v = (*m_volumes)[i]; GLVolume* v = (*m_volumes)[i];
if (v->object_idx() == object_idx) if (v->object_idx() == object_idx)
_add_volume(i); do_add_volume(i);
} }
} }
void Selection::_remove_volume(unsigned int volume_idx) void Selection::do_remove_volume(unsigned int volume_idx)
{ {
IndicesList::iterator v_it = m_list.find(volume_idx); IndicesList::iterator v_it = m_list.find(volume_idx);
if (v_it == m_list.end()) if (v_it == m_list.end())
@ -1321,27 +1322,27 @@ void Selection::_remove_volume(unsigned int volume_idx)
(*m_volumes)[volume_idx]->selected = false; (*m_volumes)[volume_idx]->selected = false;
} }
void Selection::_remove_instance(unsigned int object_idx, unsigned int instance_idx) void Selection::do_remove_instance(unsigned int object_idx, unsigned int instance_idx)
{ {
for (unsigned int i = 0; i < (unsigned int)m_volumes->size(); ++i) for (unsigned int i = 0; i < (unsigned int)m_volumes->size(); ++i)
{ {
GLVolume* v = (*m_volumes)[i]; GLVolume* v = (*m_volumes)[i];
if ((v->object_idx() == object_idx) && (v->instance_idx() == instance_idx)) if ((v->object_idx() == object_idx) && (v->instance_idx() == instance_idx))
_remove_volume(i); do_remove_volume(i);
} }
} }
void Selection::_remove_object(unsigned int object_idx) void Selection::do_remove_object(unsigned int object_idx)
{ {
for (unsigned int i = 0; i < (unsigned int)m_volumes->size(); ++i) for (unsigned int i = 0; i < (unsigned int)m_volumes->size(); ++i)
{ {
GLVolume* v = (*m_volumes)[i]; GLVolume* v = (*m_volumes)[i];
if (v->object_idx() == object_idx) if (v->object_idx() == object_idx)
_remove_volume(i); do_remove_volume(i);
} }
} }
void Selection::_calc_bounding_box() const void Selection::calc_bounding_box() const
{ {
m_bounding_box = BoundingBoxf3(); m_bounding_box = BoundingBoxf3();
if (m_valid) if (m_valid)
@ -1354,13 +1355,13 @@ void Selection::_calc_bounding_box() const
m_bounding_box_dirty = false; m_bounding_box_dirty = false;
} }
void Selection::_render_selected_volumes() const void Selection::render_selected_volumes() const
{ {
float color[3] = { 1.0f, 1.0f, 1.0f }; float color[3] = { 1.0f, 1.0f, 1.0f };
_render_bounding_box(get_bounding_box(), color); render_bounding_box(get_bounding_box(), color);
} }
void Selection::_render_synchronized_volumes() const void Selection::render_synchronized_volumes() const
{ {
if (m_mode == Instance) if (m_mode == Instance)
return; return;
@ -1382,12 +1383,12 @@ void Selection::_render_synchronized_volumes() const
if ((v->object_idx() != object_idx) || (v->volume_idx() != volume_idx)) if ((v->object_idx() != object_idx) || (v->volume_idx() != volume_idx))
continue; continue;
_render_bounding_box(v->transformed_convex_hull_bounding_box(), color); render_bounding_box(v->transformed_convex_hull_bounding_box(), color);
} }
} }
} }
void Selection::_render_bounding_box(const BoundingBoxf3& box, float* color) const void Selection::render_bounding_box(const BoundingBoxf3& box, float* color) const
{ {
if (color == nullptr) if (color == nullptr)
return; return;
@ -1396,10 +1397,10 @@ void Selection::_render_bounding_box(const BoundingBoxf3& box, float* color) con
Vec3f b_max = box.max.cast<float>(); Vec3f b_max = box.max.cast<float>();
Vec3f size = 0.2f * box.size().cast<float>(); Vec3f size = 0.2f * box.size().cast<float>();
::glEnable(GL_DEPTH_TEST); glsafe(::glEnable(GL_DEPTH_TEST));
::glColor3fv(color); glsafe(::glColor3fv(color));
::glLineWidth(2.0f * m_scale_factor); glsafe(::glLineWidth(2.0f * m_scale_factor));
::glBegin(GL_LINES); ::glBegin(GL_LINES);
@ -1435,102 +1436,102 @@ void Selection::_render_bounding_box(const BoundingBoxf3& box, float* color) con
::glVertex3f(b_min(0), b_max(1), b_max(2)); ::glVertex3f(b_min(0), b_max(1) - size(1), b_max(2)); ::glVertex3f(b_min(0), b_max(1), b_max(2)); ::glVertex3f(b_min(0), b_max(1) - size(1), b_max(2));
::glVertex3f(b_min(0), b_max(1), b_max(2)); ::glVertex3f(b_min(0), b_max(1), b_max(2) - size(2)); ::glVertex3f(b_min(0), b_max(1), b_max(2)); ::glVertex3f(b_min(0), b_max(1), b_max(2) - size(2));
::glEnd(); glsafe(::glEnd());
} }
void Selection::_render_sidebar_position_hints(const std::string& sidebar_field) const void Selection::render_sidebar_position_hints(const std::string& sidebar_field) const
{ {
if (boost::ends_with(sidebar_field, "x")) if (boost::ends_with(sidebar_field, "x"))
{ {
::glRotated(-90.0, 0.0, 0.0, 1.0); glsafe(::glRotated(-90.0, 0.0, 0.0, 1.0));
_render_sidebar_position_hint(X); render_sidebar_position_hint(X);
} }
else if (boost::ends_with(sidebar_field, "y")) else if (boost::ends_with(sidebar_field, "y"))
_render_sidebar_position_hint(Y); render_sidebar_position_hint(Y);
else if (boost::ends_with(sidebar_field, "z")) else if (boost::ends_with(sidebar_field, "z"))
{ {
::glRotated(90.0, 1.0, 0.0, 0.0); glsafe(::glRotated(90.0, 1.0, 0.0, 0.0));
_render_sidebar_position_hint(Z); render_sidebar_position_hint(Z);
} }
} }
void Selection::_render_sidebar_rotation_hints(const std::string& sidebar_field) const void Selection::render_sidebar_rotation_hints(const std::string& sidebar_field) const
{ {
if (boost::ends_with(sidebar_field, "x")) if (boost::ends_with(sidebar_field, "x"))
{ {
::glRotated(90.0, 0.0, 1.0, 0.0); glsafe(::glRotated(90.0, 0.0, 1.0, 0.0));
_render_sidebar_rotation_hint(X); render_sidebar_rotation_hint(X);
} }
else if (boost::ends_with(sidebar_field, "y")) else if (boost::ends_with(sidebar_field, "y"))
{ {
::glRotated(-90.0, 1.0, 0.0, 0.0); glsafe(::glRotated(-90.0, 1.0, 0.0, 0.0));
_render_sidebar_rotation_hint(Y); render_sidebar_rotation_hint(Y);
} }
else if (boost::ends_with(sidebar_field, "z")) else if (boost::ends_with(sidebar_field, "z"))
_render_sidebar_rotation_hint(Z); render_sidebar_rotation_hint(Z);
} }
void Selection::_render_sidebar_scale_hints(const std::string& sidebar_field) const void Selection::render_sidebar_scale_hints(const std::string& sidebar_field) const
{ {
bool uniform_scale = requires_uniform_scale() || wxGetApp().obj_manipul()->get_uniform_scaling(); bool uniform_scale = requires_uniform_scale() || wxGetApp().obj_manipul()->get_uniform_scaling();
if (boost::ends_with(sidebar_field, "x") || uniform_scale) if (boost::ends_with(sidebar_field, "x") || uniform_scale)
{ {
::glPushMatrix(); glsafe(::glPushMatrix());
::glRotated(-90.0, 0.0, 0.0, 1.0); glsafe(::glRotated(-90.0, 0.0, 0.0, 1.0));
_render_sidebar_scale_hint(X); render_sidebar_scale_hint(X);
::glPopMatrix(); glsafe(::glPopMatrix());
} }
if (boost::ends_with(sidebar_field, "y") || uniform_scale) if (boost::ends_with(sidebar_field, "y") || uniform_scale)
{ {
::glPushMatrix(); glsafe(::glPushMatrix());
_render_sidebar_scale_hint(Y); render_sidebar_scale_hint(Y);
::glPopMatrix(); glsafe(::glPopMatrix());
} }
if (boost::ends_with(sidebar_field, "z") || uniform_scale) if (boost::ends_with(sidebar_field, "z") || uniform_scale)
{ {
::glPushMatrix(); glsafe(::glPushMatrix());
::glRotated(90.0, 1.0, 0.0, 0.0); glsafe(::glRotated(90.0, 1.0, 0.0, 0.0));
_render_sidebar_scale_hint(Z); render_sidebar_scale_hint(Z);
::glPopMatrix(); glsafe(::glPopMatrix());
} }
} }
void Selection::_render_sidebar_size_hints(const std::string& sidebar_field) const void Selection::render_sidebar_size_hints(const std::string& sidebar_field) const
{ {
_render_sidebar_scale_hints(sidebar_field); render_sidebar_scale_hints(sidebar_field);
} }
void Selection::_render_sidebar_position_hint(Axis axis) const void Selection::render_sidebar_position_hint(Axis axis) const
{ {
m_arrow.set_color(AXES_COLOR[axis], 3); m_arrow.set_color(AXES_COLOR[axis], 3);
m_arrow.render(); m_arrow.render();
} }
void Selection::_render_sidebar_rotation_hint(Axis axis) const void Selection::render_sidebar_rotation_hint(Axis axis) const
{ {
m_curved_arrow.set_color(AXES_COLOR[axis], 3); m_curved_arrow.set_color(AXES_COLOR[axis], 3);
m_curved_arrow.render(); m_curved_arrow.render();
::glRotated(180.0, 0.0, 0.0, 1.0); glsafe(::glRotated(180.0, 0.0, 0.0, 1.0));
m_curved_arrow.render(); m_curved_arrow.render();
} }
void Selection::_render_sidebar_scale_hint(Axis axis) const void Selection::render_sidebar_scale_hint(Axis axis) const
{ {
m_arrow.set_color(((requires_uniform_scale() || wxGetApp().obj_manipul()->get_uniform_scaling()) ? UNIFORM_SCALE_COLOR : AXES_COLOR[axis]), 3); m_arrow.set_color(((requires_uniform_scale() || wxGetApp().obj_manipul()->get_uniform_scaling()) ? UNIFORM_SCALE_COLOR : AXES_COLOR[axis]), 3);
::glTranslated(0.0, 5.0, 0.0); glsafe(::glTranslated(0.0, 5.0, 0.0));
m_arrow.render(); m_arrow.render();
::glTranslated(0.0, -10.0, 0.0); glsafe(::glTranslated(0.0, -10.0, 0.0));
::glRotated(180.0, 0.0, 0.0, 1.0); glsafe(::glRotated(180.0, 0.0, 0.0, 1.0));
m_arrow.render(); m_arrow.render();
} }
void Selection::_render_sidebar_size_hint(Axis axis, double length) const void Selection::render_sidebar_size_hint(Axis axis, double length) const
{ {
} }
@ -1571,7 +1572,7 @@ static void verify_instances_rotation_synchronized(const Model &model, const GLV
} }
#endif /* NDEBUG */ #endif /* NDEBUG */
void Selection::_synchronize_unselected_instances(SyncRotationType sync_rotation_type) void Selection::synchronize_unselected_instances(SyncRotationType sync_rotation_type)
{ {
std::set<unsigned int> done; // prevent processing volumes twice std::set<unsigned int> done; // prevent processing volumes twice
done.insert(m_list.begin(), m_list.end()); done.insert(m_list.begin(), m_list.end());
@ -1634,7 +1635,7 @@ void Selection::_synchronize_unselected_instances(SyncRotationType sync_rotation
#endif /* NDEBUG */ #endif /* NDEBUG */
} }
void Selection::_synchronize_unselected_volumes() void Selection::synchronize_unselected_volumes()
{ {
for (unsigned int i : m_list) for (unsigned int i : m_list)
{ {
@ -1667,7 +1668,7 @@ void Selection::_synchronize_unselected_volumes()
} }
} }
void Selection::_ensure_on_bed() void Selection::ensure_on_bed()
{ {
typedef std::map<std::pair<int, int>, double> InstancesToZMap; typedef std::map<std::pair<int, int>, double> InstancesToZMap;
InstancesToZMap instances_min_z; InstancesToZMap instances_min_z;
@ -1695,7 +1696,7 @@ void Selection::_ensure_on_bed()
} }
} }
bool Selection::_is_from_fully_selected_instance(unsigned int volume_idx) const bool Selection::is_from_fully_selected_instance(unsigned int volume_idx) const
{ {
struct SameInstance struct SameInstance
{ {

50
src/slic3r/GUI/Selection.hpp
View file

@ -267,27 +267,27 @@ public:
bool requires_local_axes() const; bool requires_local_axes() const;
private: private:
void _update_valid(); void update_valid();
void _update_type(); void update_type();
void _set_caches(); void set_caches();
void _add_volume(unsigned int volume_idx); void do_add_volume(unsigned int volume_idx);
void _add_instance(unsigned int object_idx, unsigned int instance_idx); void do_add_instance(unsigned int object_idx, unsigned int instance_idx);
void _add_object(unsigned int object_idx); void do_add_object(unsigned int object_idx);
void _remove_volume(unsigned int volume_idx); void do_remove_volume(unsigned int volume_idx);
void _remove_instance(unsigned int object_idx, unsigned int instance_idx); void do_remove_instance(unsigned int object_idx, unsigned int instance_idx);
void _remove_object(unsigned int object_idx); void do_remove_object(unsigned int object_idx);
void _calc_bounding_box() const; void calc_bounding_box() const;
void _render_selected_volumes() const; void render_selected_volumes() const;
void _render_synchronized_volumes() const; void render_synchronized_volumes() const;
void _render_bounding_box(const BoundingBoxf3& box, float* color) const; void render_bounding_box(const BoundingBoxf3& box, float* color) const;
void _render_sidebar_position_hints(const std::string& sidebar_field) const; void render_sidebar_position_hints(const std::string& sidebar_field) const;
void _render_sidebar_rotation_hints(const std::string& sidebar_field) const; void render_sidebar_rotation_hints(const std::string& sidebar_field) const;
void _render_sidebar_scale_hints(const std::string& sidebar_field) const; void render_sidebar_scale_hints(const std::string& sidebar_field) const;
void _render_sidebar_size_hints(const std::string& sidebar_field) const; void render_sidebar_size_hints(const std::string& sidebar_field) const;
void _render_sidebar_position_hint(Axis axis) const; void render_sidebar_position_hint(Axis axis) const;
void _render_sidebar_rotation_hint(Axis axis) const; void render_sidebar_rotation_hint(Axis axis) const;
void _render_sidebar_scale_hint(Axis axis) const; void render_sidebar_scale_hint(Axis axis) const;
void _render_sidebar_size_hint(Axis axis, double length) const; void render_sidebar_size_hint(Axis axis, double length) const;
enum SyncRotationType { enum SyncRotationType {
// Do not synchronize rotation. Either not rotating at all, or rotating by world Z axis. // Do not synchronize rotation. Either not rotating at all, or rotating by world Z axis.
SYNC_ROTATION_NONE = 0, SYNC_ROTATION_NONE = 0,
@ -296,10 +296,10 @@ private:
// Synchronize after rotation by an axis not parallel with Z. // Synchronize after rotation by an axis not parallel with Z.
SYNC_ROTATION_GENERAL = 2, SYNC_ROTATION_GENERAL = 2,
}; };
void _synchronize_unselected_instances(SyncRotationType sync_rotation_type); void synchronize_unselected_instances(SyncRotationType sync_rotation_type);
void _synchronize_unselected_volumes(); void synchronize_unselected_volumes();
void _ensure_on_bed(); void ensure_on_bed();
bool _is_from_fully_selected_instance(unsigned int volume_idx) const; bool is_from_fully_selected_instance(unsigned int volume_idx) const;
}; };
} // namespace GUI } // namespace GUI