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

Removed mutable members from class Bed3D

Browse source
This commit is contained in:
enricoturri1966 2021-04-20 08:53:56 +02:00
parent ffe036df1f
commit 3e09334162
2 changed files with 55 additions and 52 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -113,7 +113,7 @@ void Bed3D::Axes::render() const
glsafe(::glPopMatrix()); glsafe(::glPopMatrix());
}; };
m_arrow.init_from(stilized_arrow(16, DefaultTipRadius, DefaultTipLength, DefaultStemRadius, m_stem_length)); const_cast<GLModel*>(&m_arrow)->init_from(stilized_arrow(16, DefaultTipRadius, DefaultTipLength, DefaultStemRadius, m_stem_length));
GLShaderProgram* shader = wxGetApp().get_shader("gouraud_light"); GLShaderProgram* shader = wxGetApp().get_shader("gouraud_light");
if (shader == nullptr) if (shader == nullptr)
@ -143,13 +143,6 @@ void Bed3D::Axes::render() const
glsafe(::glDisable(GL_DEPTH_TEST)); glsafe(::glDisable(GL_DEPTH_TEST));
} }
Bed3D::Bed3D()
: m_type(Custom)
, m_vbo_id(0)
, m_scale_factor(1.0f)
{
}
bool Bed3D::set_shape(const Pointfs& shape, const std::string& custom_texture, const std::string& custom_model, bool force_as_custom) bool Bed3D::set_shape(const Pointfs& shape, const std::string& custom_texture, const std::string& custom_model, bool force_as_custom)
{ {
auto check_texture = [](const std::string& texture) { auto check_texture = [](const std::string& texture) {
@ -193,7 +186,7 @@ bool Bed3D::set_shape(const Pointfs& shape, const std::string& custom_texture, c
ExPolygon poly; ExPolygon poly;
for (const Vec2d& p : m_shape) { for (const Vec2d& p : m_shape) {
poly.contour.append(Point(scale_(p(0)), scale_(p(1)))); poly.contour.append({ scale_(p(0)), scale_(p(1)) });
} }
calc_triangles(poly); calc_triangles(poly);
@ -228,7 +221,8 @@ Point Bed3D::point_projection(const Point& point) const
void Bed3D::render(GLCanvas3D& canvas, bool bottom, float scale_factor, void Bed3D::render(GLCanvas3D& canvas, bool bottom, float scale_factor,
bool show_axes, bool show_texture) const bool show_axes, bool show_texture) const
{ {
m_scale_factor = scale_factor; float* factor = const_cast<float*>(&m_scale_factor);
*factor = scale_factor;
if (show_axes) if (show_axes)
render_axes(); render_axes();
@ -247,22 +241,24 @@ void Bed3D::render(GLCanvas3D& canvas, bool bottom, float scale_factor,
void Bed3D::calc_bounding_boxes() const void Bed3D::calc_bounding_boxes() const
{ {
m_bounding_box = BoundingBoxf3(); BoundingBoxf3* bounding_box = const_cast<BoundingBoxf3*>(&m_bounding_box);
*bounding_box = BoundingBoxf3();
for (const Vec2d& p : m_shape) { for (const Vec2d& p : m_shape) {
m_bounding_box.merge(Vec3d(p(0), p(1), 0.0)); bounding_box->merge({ p(0), p(1), 0.0 });
} }
m_extended_bounding_box = m_bounding_box; BoundingBoxf3* extended_bounding_box = const_cast<BoundingBoxf3*>(&m_extended_bounding_box);
*extended_bounding_box = m_bounding_box;
// extend to contain axes // extend to contain axes
m_extended_bounding_box.merge(m_axes.get_origin() + m_axes.get_total_length() * Vec3d::Ones()); extended_bounding_box->merge(m_axes.get_origin() + m_axes.get_total_length() * Vec3d::Ones());
m_extended_bounding_box.merge(m_extended_bounding_box.min + Vec3d(-Axes::DefaultTipRadius, -Axes::DefaultTipRadius, m_extended_bounding_box.max(2))); extended_bounding_box->merge(extended_bounding_box->min + Vec3d(-Axes::DefaultTipRadius, -Axes::DefaultTipRadius, extended_bounding_box->max(2)));
// extend to contain model, if any // extend to contain model, if any
BoundingBoxf3 model_bb = m_model.get_bounding_box(); BoundingBoxf3 model_bb = m_model.get_bounding_box();
if (model_bb.defined) { if (model_bb.defined) {
model_bb.translate(m_model_offset); model_bb.translate(m_model_offset);
m_extended_bounding_box.merge(model_bb); extended_bounding_box->merge(model_bb);
} }
} }
@ -339,21 +335,24 @@ void Bed3D::render_system(GLCanvas3D& canvas, bool bottom, bool show_texture) co
void Bed3D::render_texture(bool bottom, GLCanvas3D& canvas) const void Bed3D::render_texture(bool bottom, GLCanvas3D& canvas) const
{ {
GLTexture* texture = const_cast<GLTexture*>(&m_texture);
GLTexture* temp_texture = const_cast<GLTexture*>(&m_temp_texture);
if (m_texture_filename.empty()) { if (m_texture_filename.empty()) {
m_texture.reset(); texture->reset();
render_default(bottom); render_default(bottom);
return; return;
} }
if ((m_texture.get_id() == 0) || (m_texture.get_source() != m_texture_filename)) { if (texture->get_id() == 0 || texture->get_source() != m_texture_filename) {
m_texture.reset(); texture->reset();
if (boost::algorithm::iends_with(m_texture_filename, ".svg")) { if (boost::algorithm::iends_with(m_texture_filename, ".svg")) {
// use higher resolution images if graphic card and opengl version allow // use higher resolution images if graphic card and opengl version allow
GLint max_tex_size = OpenGLManager::get_gl_info().get_max_tex_size(); GLint max_tex_size = OpenGLManager::get_gl_info().get_max_tex_size();
if ((m_temp_texture.get_id() == 0) || (m_temp_texture.get_source() != m_texture_filename)) { if (temp_texture->get_id() == 0 || temp_texture->get_source() != m_texture_filename) {
// generate a temporary lower resolution texture to show while no main texture levels have been compressed // generate a temporary lower resolution texture to show while no main texture levels have been compressed
if (!m_temp_texture.load_from_svg_file(m_texture_filename, false, false, false, max_tex_size / 8)) { if (!temp_texture->load_from_svg_file(m_texture_filename, false, false, false, max_tex_size / 8)) {
render_default(bottom); render_default(bottom);
return; return;
} }
@ -361,15 +360,15 @@ void Bed3D::render_texture(bool bottom, GLCanvas3D& canvas) const
} }
// starts generating the main texture, compression will run asynchronously // starts generating the main texture, compression will run asynchronously
if (!m_texture.load_from_svg_file(m_texture_filename, true, true, true, max_tex_size)) { if (!texture->load_from_svg_file(m_texture_filename, true, true, true, max_tex_size)) {
render_default(bottom); render_default(bottom);
return; return;
} }
} }
else if (boost::algorithm::iends_with(m_texture_filename, ".png")) { else if (boost::algorithm::iends_with(m_texture_filename, ".png")) {
// generate a temporary lower resolution texture to show while no main texture levels have been compressed // generate a temporary lower resolution texture to show while no main texture levels have been compressed
if ((m_temp_texture.get_id() == 0) || (m_temp_texture.get_source() != m_texture_filename)) { if (temp_texture->get_id() == 0 || temp_texture->get_source() != m_texture_filename) {
if (!m_temp_texture.load_from_file(m_texture_filename, false, GLTexture::None, false)) { if (!temp_texture->load_from_file(m_texture_filename, false, GLTexture::None, false)) {
render_default(bottom); render_default(bottom);
return; return;
} }
@ -377,7 +376,7 @@ void Bed3D::render_texture(bool bottom, GLCanvas3D& canvas) const
} }
// starts generating the main texture, compression will run asynchronously // starts generating the main texture, compression will run asynchronously
if (!m_texture.load_from_file(m_texture_filename, true, GLTexture::MultiThreaded, true)) { if (!texture->load_from_file(m_texture_filename, true, GLTexture::MultiThreaded, true)) {
render_default(bottom); render_default(bottom);
return; return;
} }
@ -387,13 +386,13 @@ void Bed3D::render_texture(bool bottom, GLCanvas3D& canvas) const
return; return;
} }
} }
else if (m_texture.unsent_compressed_data_available()) { else if (texture->unsent_compressed_data_available()) {
// sends to gpu the already available compressed levels of the main texture // sends to gpu the already available compressed levels of the main texture
m_texture.send_compressed_data_to_gpu(); texture->send_compressed_data_to_gpu();
// the temporary texture is not needed anymore, reset it // the temporary texture is not needed anymore, reset it
if (m_temp_texture.get_id() != 0) if (temp_texture->get_id() != 0)
m_temp_texture.reset(); temp_texture->reset();
canvas.request_extra_frame(); canvas.request_extra_frame();
@ -406,9 +405,11 @@ void Bed3D::render_texture(bool bottom, GLCanvas3D& canvas) const
shader->set_uniform("transparent_background", bottom); shader->set_uniform("transparent_background", bottom);
shader->set_uniform("svg_source", boost::algorithm::iends_with(m_texture.get_source(), ".svg")); shader->set_uniform("svg_source", boost::algorithm::iends_with(m_texture.get_source(), ".svg"));
if (m_vbo_id == 0) { unsigned int* vbo_id = const_cast<unsigned int*>(&m_vbo_id);
glsafe(::glGenBuffers(1, &m_vbo_id));
glsafe(::glBindBuffer(GL_ARRAY_BUFFER, m_vbo_id)); if (*vbo_id == 0) {
glsafe(::glGenBuffers(1, vbo_id));
glsafe(::glBindBuffer(GL_ARRAY_BUFFER, *vbo_id));
glsafe(::glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)m_triangles.get_vertices_data_size(), (const GLvoid*)m_triangles.get_vertices_data(), GL_STATIC_DRAW)); glsafe(::glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)m_triangles.get_vertices_data_size(), (const GLvoid*)m_triangles.get_vertices_data(), GL_STATIC_DRAW));
glsafe(::glBindBuffer(GL_ARRAY_BUFFER, 0)); glsafe(::glBindBuffer(GL_ARRAY_BUFFER, 0));
} }
@ -428,12 +429,12 @@ void Bed3D::render_texture(bool bottom, GLCanvas3D& canvas) const
GLint tex_coords_id = shader->get_attrib_location("v_tex_coords"); GLint tex_coords_id = shader->get_attrib_location("v_tex_coords");
// show the temporary texture while no compressed data is available // show the temporary texture while no compressed data is available
GLuint tex_id = (GLuint)m_temp_texture.get_id(); GLuint tex_id = (GLuint)temp_texture->get_id();
if (tex_id == 0) if (tex_id == 0)
tex_id = (GLuint)m_texture.get_id(); tex_id = (GLuint)texture->get_id();
glsafe(::glBindTexture(GL_TEXTURE_2D, tex_id)); glsafe(::glBindTexture(GL_TEXTURE_2D, tex_id));
glsafe(::glBindBuffer(GL_ARRAY_BUFFER, m_vbo_id)); glsafe(::glBindBuffer(GL_ARRAY_BUFFER, *vbo_id));
if (position_id != -1) { if (position_id != -1) {
glsafe(::glEnableVertexAttribArray(position_id)); glsafe(::glEnableVertexAttribArray(position_id));
@ -471,24 +472,26 @@ void Bed3D::render_model() const
if (m_model_filename.empty()) if (m_model_filename.empty())
return; return;
if ((m_model.get_filename() != m_model_filename) && m_model.init_from_file(m_model_filename)) { GLModel* model = const_cast<GLModel*>(&m_model);
if (model->get_filename() != m_model_filename && model->init_from_file(m_model_filename)) {
// move the model so that its origin (0.0, 0.0, 0.0) goes into the bed shape center and a bit down to avoid z-fighting with the texture quad // move the model so that its origin (0.0, 0.0, 0.0) goes into the bed shape center and a bit down to avoid z-fighting with the texture quad
Vec3d shift = m_bounding_box.center(); Vec3d shift = m_bounding_box.center();
shift(2) = -0.03; shift(2) = -0.03;
m_model_offset = shift; *const_cast<Vec3d*>(&m_model_offset) = shift;
// update extended bounding box // update extended bounding box
calc_bounding_boxes(); calc_bounding_boxes();
} }
if (!m_model.get_filename().empty()) { if (!model->get_filename().empty()) {
GLShaderProgram* shader = wxGetApp().get_shader("gouraud_light"); GLShaderProgram* shader = wxGetApp().get_shader("gouraud_light");
if (shader != nullptr) { if (shader != nullptr) {
shader->start_using(); shader->start_using();
shader->set_uniform("uniform_color", m_model_color); shader->set_uniform("uniform_color", m_model_color);
::glPushMatrix(); ::glPushMatrix();
::glTranslated(m_model_offset(0), m_model_offset(1), m_model_offset(2)); ::glTranslated(m_model_offset(0), m_model_offset(1), m_model_offset(2));
m_model.render(); model->render();
::glPopMatrix(); ::glPopMatrix();
shader->stop_using(); shader->stop_using();
} }
@ -511,7 +514,7 @@ void Bed3D::render_custom(GLCanvas3D& canvas, bool bottom, bool show_texture) co
void Bed3D::render_default(bool bottom) const void Bed3D::render_default(bool bottom) const
{ {
m_texture.reset(); const_cast<GLTexture*>(&m_texture)->reset();
unsigned int triangles_vcount = m_triangles.get_vertices_count(); unsigned int triangles_vcount = m_triangles.get_vertices_count();
if (triangles_vcount > 0) { if (triangles_vcount > 0) {

24
src/slic3r/GUI/3DBed.hpp
View file

@ -48,7 +48,7 @@ class Bed3D
private: private:
Vec3d m_origin{ Vec3d::Zero() }; Vec3d m_origin{ Vec3d::Zero() };
float m_stem_length{ DefaultStemLength }; float m_stem_length{ DefaultStemLength };
mutable GLModel m_arrow; GLModel m_arrow;
public: public:
const Vec3d& get_origin() const { return m_origin; } const Vec3d& get_origin() const { return m_origin; }
@ -67,28 +67,28 @@ public:
}; };
private: private:
EType m_type; EType m_type{ Custom };
Pointfs m_shape; Pointfs m_shape;
std::string m_texture_filename; std::string m_texture_filename;
std::string m_model_filename; std::string m_model_filename;
mutable BoundingBoxf3 m_bounding_box; BoundingBoxf3 m_bounding_box;
mutable BoundingBoxf3 m_extended_bounding_box; BoundingBoxf3 m_extended_bounding_box;
Polygon m_polygon; Polygon m_polygon;
GeometryBuffer m_triangles; GeometryBuffer m_triangles;
GeometryBuffer m_gridlines; GeometryBuffer m_gridlines;
mutable GLTexture m_texture; GLTexture m_texture;
mutable GLModel m_model;
mutable Vec3d m_model_offset{ Vec3d::Zero() };
std::array<float, 4> m_model_color{ 0.235f, 0.235f, 0.235f, 1.0f };
// temporary texture shown until the main texture has still no levels compressed // temporary texture shown until the main texture has still no levels compressed
mutable GLTexture m_temp_texture; GLTexture m_temp_texture;
mutable unsigned int m_vbo_id; GLModel m_model;
Vec3d m_model_offset{ Vec3d::Zero() };
std::array<float, 4> m_model_color{ 0.235f, 0.235f, 0.235f, 1.0f };
unsigned int m_vbo_id{ 0 };
Axes m_axes; Axes m_axes;
mutable float m_scale_factor; float m_scale_factor{ 1.0f };
public: public:
Bed3D(); Bed3D() = default;
~Bed3D() { reset(); } ~Bed3D() { reset(); }
EType get_type() const { return m_type; } EType get_type() const { return m_type; }