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

ENABLE_UNIQUE_BED set as default

Browse source
This commit is contained in:
Enrico Turri 2019-02-20 13:50:35 +01:00
parent 7443868e87
commit cb1ef36ceb
9 changed files with 1 additions and 771 deletions
Download patch file Download diff file Expand all files Collapse all files

8
src/libslic3r/Technologies.hpp
View file

@ -53,12 +53,4 @@
#define ENABLE_MODE_AWARE_TOOLBAR_ITEMS (1 && ENABLE_1_42_0_ALPHA5) #define ENABLE_MODE_AWARE_TOOLBAR_ITEMS (1 && ENABLE_1_42_0_ALPHA5)
//====================
// 1.42.0.alpha7 techs
//====================
#define ENABLE_1_42_0_ALPHA7 1
// Moves bed from GLCanva3d to Plater to have a unique instance of it
#define ENABLE_UNIQUE_BED (1 && ENABLE_1_42_0_ALPHA7)
#endif // _technologies_h_ #endif // _technologies_h_

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

@ -18,7 +18,6 @@ static const float GROUND_Z = -0.02f;
namespace Slic3r { namespace Slic3r {
namespace GUI { namespace GUI {
#if ENABLE_UNIQUE_BED
bool GeometryBuffer::set_from_triangles(const Polygons& triangles, float z, bool generate_tex_coords) bool GeometryBuffer::set_from_triangles(const Polygons& triangles, float z, bool generate_tex_coords)
{ {
m_vertices.clear(); m_vertices.clear();
@ -511,7 +510,6 @@ void Bed3D::render_custom() const
glsafe(::glDisable(GL_LIGHTING)); glsafe(::glDisable(GL_LIGHTING));
} }
} }
#endif // ENABLE_UNIQUE_BED
} // GUI } // GUI
} // Slic3r } // Slic3r

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

@ -10,7 +10,6 @@ typedef class GLUquadric GLUquadricObj;
namespace Slic3r { namespace Slic3r {
namespace GUI { namespace GUI {
#if ENABLE_UNIQUE_BED
class GeometryBuffer class GeometryBuffer
{ {
std::vector<float> m_vertices; std::vector<float> m_vertices;
@ -97,7 +96,6 @@ private:
void render_prusa(const std::string &key, float theta, bool useVBOs) const; void render_prusa(const std::string &key, float theta, bool useVBOs) const;
void render_custom() const; void render_custom() const;
}; };
#endif // ENABLE_UNIQUE_BED
} // GUI } // GUI
} // Slic3r } // Slic3r

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

@ -84,114 +84,6 @@ static const float AXES_COLOR[3][3] = { { 1.0f, 0.0f, 0.0f }, { 0.0f, 1.0f, 0.0f
namespace Slic3r { namespace Slic3r {
namespace GUI { namespace GUI {
#if !ENABLE_UNIQUE_BED
bool GeometryBuffer::set_from_triangles(const Polygons& triangles, float z, bool generate_tex_coords)
{
m_vertices.clear();
m_tex_coords.clear();
unsigned int v_size = 9 * (unsigned int)triangles.size();
unsigned int t_size = 6 * (unsigned int)triangles.size();
if (v_size == 0)
return false;
m_vertices = std::vector<float>(v_size, 0.0f);
if (generate_tex_coords)
m_tex_coords = std::vector<float>(t_size, 0.0f);
float min_x = unscale<float>(triangles[0].points[0](0));
float min_y = unscale<float>(triangles[0].points[0](1));
float max_x = min_x;
float max_y = min_y;
unsigned int v_coord = 0;
unsigned int t_coord = 0;
for (const Polygon& t : triangles)
{
for (unsigned int v = 0; v < 3; ++v)
{
const Point& p = t.points[v];
float x = unscale<float>(p(0));
float y = unscale<float>(p(1));
m_vertices[v_coord++] = x;
m_vertices[v_coord++] = y;
m_vertices[v_coord++] = z;
if (generate_tex_coords)
{
m_tex_coords[t_coord++] = x;
m_tex_coords[t_coord++] = y;
min_x = std::min(min_x, x);
max_x = std::max(max_x, x);
min_y = std::min(min_y, y);
max_y = std::max(max_y, y);
}
}
}
if (generate_tex_coords)
{
float size_x = max_x - min_x;
float size_y = max_y - min_y;
if ((size_x != 0.0f) && (size_y != 0.0f))
{
float inv_size_x = 1.0f / size_x;
float inv_size_y = -1.0f / size_y;
for (unsigned int i = 0; i < m_tex_coords.size(); i += 2)
{
m_tex_coords[i] = (m_tex_coords[i] - min_x) * inv_size_x;
m_tex_coords[i + 1] = (m_tex_coords[i + 1] - min_y) * inv_size_y;
}
}
}
return true;
}
bool GeometryBuffer::set_from_lines(const Lines& lines, float z)
{
m_vertices.clear();
m_tex_coords.clear();
unsigned int size = 6 * (unsigned int)lines.size();
if (size == 0)
return false;
m_vertices = std::vector<float>(size, 0.0f);
unsigned int coord = 0;
for (const Line& l : lines)
{
m_vertices[coord++] = unscale<float>(l.a(0));
m_vertices[coord++] = unscale<float>(l.a(1));
m_vertices[coord++] = z;
m_vertices[coord++] = unscale<float>(l.b(0));
m_vertices[coord++] = unscale<float>(l.b(1));
m_vertices[coord++] = z;
}
return true;
}
const float* GeometryBuffer::get_vertices() const
{
return m_vertices.data();
}
const float* GeometryBuffer::get_tex_coords() const
{
return m_tex_coords.data();
}
unsigned int GeometryBuffer::get_vertices_count() const
{
return (unsigned int)m_vertices.size() / 3;
}
#endif // !ENABLE_UNIQUE_BED
Size::Size() Size::Size()
: m_width(0) : m_width(0)
, m_height(0) , m_height(0)
@ -346,416 +238,6 @@ void GLCanvas3D::Camera::set_scene_box(const BoundingBoxf3& box, GLCanvas3D& can
} }
} }
#if !ENABLE_UNIQUE_BED
GLCanvas3D::Bed::Bed()
: m_type(Custom)
, m_scale_factor(1.0f)
{
}
bool GLCanvas3D::Bed::is_prusa() const
{
return (m_type == MK2) || (m_type == MK3) || (m_type == SL1);
}
bool GLCanvas3D::Bed::is_custom() const
{
return m_type == Custom;
}
const Pointfs& GLCanvas3D::Bed::get_shape() const
{
return m_shape;
}
bool GLCanvas3D::Bed::set_shape(const Pointfs& shape)
{
EType new_type = _detect_type(shape);
if (m_shape == shape && m_type == new_type)
// No change, no need to update the UI.
return false;
m_shape = shape;
m_type = new_type;
_calc_bounding_box();
ExPolygon poly;
for (const Vec2d& p : m_shape)
{
poly.contour.append(Point(scale_(p(0)), scale_(p(1))));
}
_calc_triangles(poly);
const BoundingBox& bed_bbox = poly.contour.bounding_box();
_calc_gridlines(poly, bed_bbox);
m_polygon = offset_ex(poly.contour, (float)bed_bbox.radius() * 1.7f, jtRound, scale_(0.5))[0].contour;
// Let the calee to update the UI.
return true;
}
const BoundingBoxf3& GLCanvas3D::Bed::get_bounding_box() const
{
return m_bounding_box;
}
bool GLCanvas3D::Bed::contains(const Point& point) const
{
return m_polygon.contains(point);
}
Point GLCanvas3D::Bed::point_projection(const Point& point) const
{
return m_polygon.point_projection(point);
}
void GLCanvas3D::Bed::render(float theta, bool useVBOs, float scale_factor) const
{
m_scale_factor = scale_factor;
switch (m_type)
{
case MK2:
{
_render_prusa("mk2", theta, useVBOs);
break;
}
case MK3:
{
_render_prusa("mk3", theta, useVBOs);
break;
}
case SL1:
{
_render_prusa("sl1", theta, useVBOs);
break;
}
default:
case Custom:
{
_render_custom();
break;
}
}
}
void GLCanvas3D::Bed::_calc_bounding_box()
{
m_bounding_box = BoundingBoxf3();
for (const Vec2d& p : m_shape)
{
m_bounding_box.merge(Vec3d(p(0), p(1), 0.0));
}
}
void GLCanvas3D::Bed::_calc_triangles(const ExPolygon& poly)
{
Polygons triangles;
poly.triangulate(&triangles);
if (!m_triangles.set_from_triangles(triangles, GROUND_Z, m_type != Custom))
printf("Unable to create bed triangles\n");
}
void GLCanvas3D::Bed::_calc_gridlines(const ExPolygon& poly, const BoundingBox& bed_bbox)
{
Polylines axes_lines;
for (coord_t x = bed_bbox.min(0); x <= bed_bbox.max(0); x += scale_(10.0))
{
Polyline line;
line.append(Point(x, bed_bbox.min(1)));
line.append(Point(x, bed_bbox.max(1)));
axes_lines.push_back(line);
}
for (coord_t y = bed_bbox.min(1); y <= bed_bbox.max(1); y += scale_(10.0))
{
Polyline line;
line.append(Point(bed_bbox.min(0), y));
line.append(Point(bed_bbox.max(0), y));
axes_lines.push_back(line);
}
// clip with a slightly grown expolygon because our lines lay on the contours and may get erroneously clipped
Lines gridlines = to_lines(intersection_pl(axes_lines, offset(poly, (float)SCALED_EPSILON)));
// append bed contours
Lines contour_lines = to_lines(poly);
std::copy(contour_lines.begin(), contour_lines.end(), std::back_inserter(gridlines));
if (!m_gridlines.set_from_lines(gridlines, GROUND_Z))
printf("Unable to create bed grid lines\n");
}
GLCanvas3D::Bed::EType GLCanvas3D::Bed::_detect_type(const Pointfs& shape) const
{
EType type = Custom;
auto bundle = wxGetApp().preset_bundle;
if (bundle != nullptr)
{
const Preset* curr = &bundle->printers.get_selected_preset();
while (curr != nullptr)
{
if (curr->config.has("bed_shape"))
{
if ((curr->vendor != nullptr) && (curr->vendor->name == "Prusa Research") && (shape == dynamic_cast<const ConfigOptionPoints*>(curr->config.option("bed_shape"))->values))
{
if (boost::contains(curr->name, "SL1"))
{
type = SL1;
break;
}
else if (boost::contains(curr->name, "MK3") || boost::contains(curr->name, "MK2.5"))
{
type = MK3;
break;
}
else if (boost::contains(curr->name, "MK2"))
{
type = MK2;
break;
}
}
}
curr = bundle->printers.get_preset_parent(*curr);
}
}
return type;
}
void GLCanvas3D::Bed::_render_prusa(const std::string &key, float theta, bool useVBOs) const
{
std::string tex_path = resources_dir() + "/icons/bed/" + key;
// use higher resolution images if graphic card allows
GLint max_tex_size;
::glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max_tex_size);
// temporary set to lowest resolution
max_tex_size = 2048;
if (max_tex_size >= 8192)
tex_path += "_8192";
else if (max_tex_size >= 4096)
tex_path += "_4096";
std::string model_path = resources_dir() + "/models/" + key;
#if ENABLE_ANISOTROPIC_FILTER_ON_BED_TEXTURES
// use anisotropic filter if graphic card allows
GLfloat max_anisotropy = 0.0f;
if (glewIsSupported("GL_EXT_texture_filter_anisotropic"))
::glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &max_anisotropy);
#endif // ENABLE_ANISOTROPIC_FILTER_ON_BED_TEXTURES
std::string filename = tex_path + "_top.png";
if ((m_top_texture.get_id() == 0) || (m_top_texture.get_source() != filename))
{
if (!m_top_texture.load_from_file(filename, true))
{
_render_custom();
return;
}
#if ENABLE_ANISOTROPIC_FILTER_ON_BED_TEXTURES
if (max_anisotropy > 0.0f)
{
::glBindTexture(GL_TEXTURE_2D, m_top_texture.get_id());
::glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, max_anisotropy);
::glBindTexture(GL_TEXTURE_2D, 0);
}
#endif // ENABLE_ANISOTROPIC_FILTER_ON_BED_TEXTURES
}
filename = tex_path + "_bottom.png";
if ((m_bottom_texture.get_id() == 0) || (m_bottom_texture.get_source() != filename))
{
if (!m_bottom_texture.load_from_file(filename, true))
{
_render_custom();
return;
}
#if ENABLE_ANISOTROPIC_FILTER_ON_BED_TEXTURES
if (max_anisotropy > 0.0f)
{
::glBindTexture(GL_TEXTURE_2D, m_bottom_texture.get_id());
::glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, max_anisotropy);
::glBindTexture(GL_TEXTURE_2D, 0);
}
#endif // ENABLE_ANISOTROPIC_FILTER_ON_BED_TEXTURES
}
if (theta <= 90.0f)
{
filename = model_path + "_bed.stl";
if ((m_model.get_filename() != filename) && m_model.init_from_file(filename, useVBOs)) {
Vec3d offset = m_bounding_box.center() - Vec3d(0.0, 0.0, 0.5 * m_model.get_bounding_box().size()(2));
if (key == "mk2")
// hardcoded value to match the stl model
offset += Vec3d(0.0, 7.5, -0.03);
else if (key == "mk3")
// hardcoded value to match the stl model
offset += Vec3d(0.0, 5.5, 2.43);
else if (key == "sl1")
// hardcoded value to match the stl model
offset += Vec3d(0.0, 0.0, -0.03);
m_model.center_around(offset);
}
if (!m_model.get_filename().empty())
{
::glEnable(GL_LIGHTING);
m_model.render();
::glDisable(GL_LIGHTING);
}
}
unsigned int triangles_vcount = m_triangles.get_vertices_count();
if (triangles_vcount > 0)
{
::glEnable(GL_DEPTH_TEST);
::glDepthMask(GL_FALSE);
::glEnable(GL_BLEND);
::glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
::glEnable(GL_TEXTURE_2D);
::glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
::glEnableClientState(GL_VERTEX_ARRAY);
::glEnableClientState(GL_TEXTURE_COORD_ARRAY);
if (theta > 90.0f)
::glFrontFace(GL_CW);
::glBindTexture(GL_TEXTURE_2D, (theta <= 90.0f) ? (GLuint)m_top_texture.get_id() : (GLuint)m_bottom_texture.get_id());
::glVertexPointer(3, GL_FLOAT, 0, (GLvoid*)m_triangles.get_vertices());
::glTexCoordPointer(2, GL_FLOAT, 0, (GLvoid*)m_triangles.get_tex_coords());
::glDrawArrays(GL_TRIANGLES, 0, (GLsizei)triangles_vcount);
if (theta > 90.0f)
::glFrontFace(GL_CCW);
::glBindTexture(GL_TEXTURE_2D, 0);
::glDisableClientState(GL_TEXTURE_COORD_ARRAY);
::glDisableClientState(GL_VERTEX_ARRAY);
::glDisable(GL_TEXTURE_2D);
::glDisable(GL_BLEND);
::glDepthMask(GL_TRUE);
}
}
void GLCanvas3D::Bed::_render_custom() const
{
m_top_texture.reset();
m_bottom_texture.reset();
unsigned int triangles_vcount = m_triangles.get_vertices_count();
if (triangles_vcount > 0)
{
::glEnable(GL_LIGHTING);
::glDisable(GL_DEPTH_TEST);
::glEnable(GL_BLEND);
::glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
::glEnableClientState(GL_VERTEX_ARRAY);
::glColor4f(0.35f, 0.35f, 0.35f, 0.4f);
::glNormal3d(0.0f, 0.0f, 1.0f);
::glVertexPointer(3, GL_FLOAT, 0, (GLvoid*)m_triangles.get_vertices());
::glDrawArrays(GL_TRIANGLES, 0, (GLsizei)triangles_vcount);
// draw grid
unsigned int gridlines_vcount = m_gridlines.get_vertices_count();
// we need depth test for grid, otherwise it would disappear when looking the object from below
::glEnable(GL_DEPTH_TEST);
::glLineWidth(3.0f * m_scale_factor);
::glColor4f(0.2f, 0.2f, 0.2f, 0.4f);
::glVertexPointer(3, GL_FLOAT, 0, (GLvoid*)m_gridlines.get_vertices());
::glDrawArrays(GL_LINES, 0, (GLsizei)gridlines_vcount);
::glDisableClientState(GL_VERTEX_ARRAY);
::glDisable(GL_BLEND);
::glDisable(GL_LIGHTING);
}
}
const double GLCanvas3D::Axes::Radius = 0.5;
const double GLCanvas3D::Axes::ArrowBaseRadius = 2.5 * GLCanvas3D::Axes::Radius;
const double GLCanvas3D::Axes::ArrowLength = 5.0;
GLCanvas3D::Axes::Axes()
: origin(Vec3d::Zero())
, length(Vec3d::Zero())
{
m_quadric = ::gluNewQuadric();
if (m_quadric != nullptr)
::gluQuadricDrawStyle(m_quadric, GLU_FILL);
}
GLCanvas3D::Axes::~Axes()
{
if (m_quadric != nullptr)
::gluDeleteQuadric(m_quadric);
}
void GLCanvas3D::Axes::render() const
{
if (m_quadric == nullptr)
return;
::glEnable(GL_DEPTH_TEST);
::glEnable(GL_LIGHTING);
// x axis
::glColor3f(1.0f, 0.0f, 0.0f);
::glPushMatrix();
::glTranslated(origin(0), origin(1), origin(2));
::glRotated(90.0, 0.0, 1.0, 0.0);
render_axis(length(0));
::glPopMatrix();
// y axis
::glColor3f(0.0f, 1.0f, 0.0f);
::glPushMatrix();
::glTranslated(origin(0), origin(1), origin(2));
::glRotated(-90.0, 1.0, 0.0, 0.0);
render_axis(length(1));
::glPopMatrix();
// z axis
::glColor3f(0.0f, 0.0f, 1.0f);
::glPushMatrix();
::glTranslated(origin(0), origin(1), origin(2));
render_axis(length(2));
::glPopMatrix();
::glDisable(GL_LIGHTING);
}
void GLCanvas3D::Axes::render_axis(double length) const
{
::gluQuadricOrientation(m_quadric, GLU_OUTSIDE);
::gluCylinder(m_quadric, Radius, Radius, length, 32, 1);
::gluQuadricOrientation(m_quadric, GLU_INSIDE);
::gluDisk(m_quadric, 0.0, Radius, 32, 1);
::glTranslated(0.0, 0.0, length);
::gluQuadricOrientation(m_quadric, GLU_OUTSIDE);
::gluCylinder(m_quadric, ArrowBaseRadius, 0.0, ArrowLength, 32, 1);
::gluQuadricOrientation(m_quadric, GLU_INSIDE);
::gluDisk(m_quadric, 0.0, ArrowBaseRadius, 32, 1);
}
#endif // !ENABLE_UNIQUE_BED
GLCanvas3D::Shader::Shader() GLCanvas3D::Shader::Shader()
: m_shader(nullptr) : m_shader(nullptr)
{ {
@ -3964,9 +3446,7 @@ wxDEFINE_EVENT(EVT_GLCANVAS_WIPETOWER_MOVED, Vec3dEvent);
wxDEFINE_EVENT(EVT_GLCANVAS_ENABLE_ACTION_BUTTONS, Event<bool>); wxDEFINE_EVENT(EVT_GLCANVAS_ENABLE_ACTION_BUTTONS, Event<bool>);
wxDEFINE_EVENT(EVT_GLCANVAS_UPDATE_GEOMETRY, Vec3dsEvent<2>); wxDEFINE_EVENT(EVT_GLCANVAS_UPDATE_GEOMETRY, Vec3dsEvent<2>);
wxDEFINE_EVENT(EVT_GLCANVAS_MOUSE_DRAGGING_FINISHED, SimpleEvent); wxDEFINE_EVENT(EVT_GLCANVAS_MOUSE_DRAGGING_FINISHED, SimpleEvent);
#if ENABLE_UNIQUE_BED
wxDEFINE_EVENT(EVT_GLCANVAS_UPDATE_BED_SHAPE, SimpleEvent); wxDEFINE_EVENT(EVT_GLCANVAS_UPDATE_BED_SHAPE, SimpleEvent);
#endif // ENABLE_UNIQUE_BED
GLCanvas3D::GLCanvas3D(wxGLCanvas* canvas) GLCanvas3D::GLCanvas3D(wxGLCanvas* canvas)
: m_canvas(canvas) : m_canvas(canvas)
@ -3975,9 +3455,7 @@ GLCanvas3D::GLCanvas3D(wxGLCanvas* canvas)
, m_retina_helper(nullptr) , m_retina_helper(nullptr)
#endif #endif
, m_in_render(false) , m_in_render(false)
#if ENABLE_UNIQUE_BED
, m_bed(nullptr) , m_bed(nullptr)
#endif // ENABLE_UNIQUE_BED
, m_toolbar(GLToolbar::Normal) , m_toolbar(GLToolbar::Normal)
, m_view_toolbar(nullptr) , m_view_toolbar(nullptr)
, m_use_clipping_planes(false) , m_use_clipping_planes(false)
@ -4200,7 +3678,6 @@ void GLCanvas3D::set_model(Model* model)
m_selection.set_model(m_model); m_selection.set_model(m_model);
} }
#if ENABLE_UNIQUE_BED
void GLCanvas3D::bed_shape_changed() void GLCanvas3D::bed_shape_changed()
{ {
m_camera.set_scene_box(scene_bounding_box(), *this); m_camera.set_scene_box(scene_bounding_box(), *this);
@ -4208,28 +3685,6 @@ void GLCanvas3D::bed_shape_changed()
m_dirty = true; m_dirty = true;
} }
#else
void GLCanvas3D::set_bed_shape(const Pointfs& shape)
{
bool new_shape = m_bed.set_shape(shape);
if (new_shape)
{
// Set the origin and size for painting of the coordinate system axes.
m_axes.origin = Vec3d(0.0, 0.0, (double)GROUND_Z);
set_bed_axes_length(0.1 * m_bed.get_bounding_box().max_size());
m_camera.set_scene_box(scene_bounding_box(), *this);
m_requires_zoom_to_bed = true;
m_dirty = true;
}
}
void GLCanvas3D::set_bed_axes_length(double length)
{
m_axes.length = length * Vec3d::Ones();
}
#endif // ENABLE_UNIQUE_BED
void GLCanvas3D::set_color_by(const std::string& value) void GLCanvas3D::set_color_by(const std::string& value)
{ {
@ -4255,12 +3710,9 @@ BoundingBoxf3 GLCanvas3D::volumes_bounding_box() const
BoundingBoxf3 GLCanvas3D::scene_bounding_box() const BoundingBoxf3 GLCanvas3D::scene_bounding_box() const
{ {
BoundingBoxf3 bb = volumes_bounding_box(); BoundingBoxf3 bb = volumes_bounding_box();
#if ENABLE_UNIQUE_BED
if (m_bed != nullptr) if (m_bed != nullptr)
bb.merge(m_bed->get_bounding_box()); bb.merge(m_bed->get_bounding_box());
#else
bb.merge(m_bed.get_bounding_box());
#endif // ENABLE_UNIQUE_BED
if (m_config != nullptr) if (m_config != nullptr)
{ {
double h = m_config->opt_float("max_print_height"); double h = m_config->opt_float("max_print_height");
@ -4353,12 +3805,8 @@ bool GLCanvas3D::is_toolbar_item_pressed(const std::string& name) const
void GLCanvas3D::zoom_to_bed() void GLCanvas3D::zoom_to_bed()
{ {
#if ENABLE_UNIQUE_BED
if (m_bed != nullptr) if (m_bed != nullptr)
_zoom_to_bounding_box(m_bed->get_bounding_box()); _zoom_to_bounding_box(m_bed->get_bounding_box());
#else
_zoom_to_bounding_box(m_bed.get_bounding_box());
#endif // ENABLE_UNIQUE_BED
} }
void GLCanvas3D::zoom_to_volumes() void GLCanvas3D::zoom_to_volumes()
@ -4471,20 +3919,11 @@ void GLCanvas3D::render()
if (!_set_current() || !_3DScene::init(m_canvas)) if (!_set_current() || !_3DScene::init(m_canvas))
return; return;
#if ENABLE_UNIQUE_BED
if ((m_bed != nullptr) && m_bed->get_shape().empty()) if ((m_bed != nullptr) && m_bed->get_shape().empty())
{ {
// this happens at startup when no data is still saved under <>\AppData\Roaming\Slic3rPE // this happens at startup when no data is still saved under <>\AppData\Roaming\Slic3rPE
post_event(SimpleEvent(EVT_GLCANVAS_UPDATE_BED_SHAPE)); post_event(SimpleEvent(EVT_GLCANVAS_UPDATE_BED_SHAPE));
} }
#else
if (m_bed.get_shape().empty())
{
// this happens at startup when no data is still saved under <>\AppData\Roaming\Slic3rPE
if (m_config != nullptr)
set_bed_shape(m_config->opt<ConfigOptionPoints>("bed_shape")->values);
}
#endif // ENABLE_UNIQUE_BED
if (m_requires_zoom_to_bed) if (m_requires_zoom_to_bed)
{ {
@ -4506,11 +3945,7 @@ void GLCanvas3D::render()
// absolute value of the rotation // absolute value of the rotation
theta = 360.f - theta; theta = 360.f - theta;
#if ENABLE_UNIQUE_BED
bool is_custom_bed = (m_bed == nullptr) || m_bed->is_custom(); bool is_custom_bed = (m_bed == nullptr) || m_bed->is_custom();
#else
bool is_custom_bed = m_bed.is_custom();
#endif // ENABLE_UNIQUE_BED
#if ENABLE_IMGUI #if ENABLE_IMGUI
wxGetApp().imgui()->new_frame(); wxGetApp().imgui()->new_frame();
@ -6259,16 +5694,10 @@ void GLCanvas3D::_resize(unsigned int w, unsigned int h)
BoundingBoxf3 GLCanvas3D::_max_bounding_box() const BoundingBoxf3 GLCanvas3D::_max_bounding_box() const
{ {
#if ENABLE_UNIQUE_BED
BoundingBoxf3 bb = volumes_bounding_box(); BoundingBoxf3 bb = volumes_bounding_box();
if (m_bed != nullptr) if (m_bed != nullptr)
bb.merge(m_bed->get_bounding_box()); bb.merge(m_bed->get_bounding_box());
return bb; return bb;
#else
BoundingBoxf3 bb = m_bed.get_bounding_box();
bb.merge(volumes_bounding_box());
return bb;
#endif // ENABLE_UNIQUE_BED
} }
void GLCanvas3D::_zoom_to_bounding_box(const BoundingBoxf3& bbox) void GLCanvas3D::_zoom_to_bounding_box(const BoundingBoxf3& bbox)
@ -6472,22 +5901,14 @@ void GLCanvas3D::_render_bed(float theta) const
scale_factor = m_retina_helper->get_scale_factor(); scale_factor = m_retina_helper->get_scale_factor();
#endif #endif
#if ENABLE_UNIQUE_BED
if (m_bed != nullptr) if (m_bed != nullptr)
m_bed->render(theta, m_use_VBOs, scale_factor); m_bed->render(theta, m_use_VBOs, scale_factor);
#else
m_bed.render(theta, m_use_VBOs, scale_factor);
#endif // ENABLE_UNIQUE_BED
} }
void GLCanvas3D::_render_axes() const void GLCanvas3D::_render_axes() const
{ {
#if ENABLE_UNIQUE_BED
if (m_bed != nullptr) if (m_bed != nullptr)
m_bed->render_axes(); m_bed->render_axes();
#else
m_axes.render();
#endif // ENABLE_UNIQUE_BED
} }
void GLCanvas3D::_render_objects() const void GLCanvas3D::_render_objects() const
@ -6505,21 +5926,12 @@ void GLCanvas3D::_render_objects() const
// Update the layer editing selection to the first object selected, update the current object maximum Z. // Update the layer editing selection to the first object selected, update the current object maximum Z.
const_cast<LayersEditing&>(m_layers_editing).select_object(*m_model, this->is_layers_editing_enabled() ? m_selection.get_object_idx() : -1); const_cast<LayersEditing&>(m_layers_editing).select_object(*m_model, this->is_layers_editing_enabled() ? m_selection.get_object_idx() : -1);
#if ENABLE_UNIQUE_BED
if ((m_config != nullptr) && (m_bed != nullptr)) if ((m_config != nullptr) && (m_bed != nullptr))
{ {
const BoundingBoxf3& bed_bb = m_bed->get_bounding_box(); const BoundingBoxf3& bed_bb = m_bed->get_bounding_box();
m_volumes.set_print_box((float)bed_bb.min(0), (float)bed_bb.min(1), 0.0f, (float)bed_bb.max(0), (float)bed_bb.max(1), (float)m_config->opt_float("max_print_height")); m_volumes.set_print_box((float)bed_bb.min(0), (float)bed_bb.min(1), 0.0f, (float)bed_bb.max(0), (float)bed_bb.max(1), (float)m_config->opt_float("max_print_height"));
m_volumes.check_outside_state(m_config, nullptr); m_volumes.check_outside_state(m_config, nullptr);
} }
#else
if (m_config != nullptr)
{
const BoundingBoxf3& bed_bb = m_bed.get_bounding_box();
m_volumes.set_print_box((float)bed_bb.min(0), (float)bed_bb.min(1), 0.0f, (float)bed_bb.max(0), (float)bed_bb.max(1), (float)m_config->opt_float("max_print_height"));
m_volumes.check_outside_state(m_config, nullptr);
}
#endif // ENABLE_UNIQUE_BED
} }
if (m_use_clipping_planes) if (m_use_clipping_planes)

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

@ -8,9 +8,7 @@
#include "3DScene.hpp" #include "3DScene.hpp"
#include "GLToolbar.hpp" #include "GLToolbar.hpp"
#include "Event.hpp" #include "Event.hpp"
#if ENABLE_UNIQUE_BED
#include "3DBed.hpp" #include "3DBed.hpp"
#endif // ENABLE_UNIQUE_BED
#include <float.h> #include <float.h>
@ -28,11 +26,6 @@ class wxGLCanvas;
// Support for Retina OpenGL on Mac OS // Support for Retina OpenGL on Mac OS
#define ENABLE_RETINA_GL __APPLE__ #define ENABLE_RETINA_GL __APPLE__
#if !ENABLE_UNIQUE_BED
class GLUquadric;
typedef class GLUquadric GLUquadricObj;
#endif // !ENABLE_UNIQUE_BED
namespace Slic3r { namespace Slic3r {
class GLShader; class GLShader;
@ -50,23 +43,6 @@ class GLGizmoBase;
class RetinaHelper; class RetinaHelper;
#endif #endif
#if !ENABLE_UNIQUE_BED
class GeometryBuffer
{
std::vector<float> m_vertices;
std::vector<float> m_tex_coords;
public:
bool set_from_triangles(const Polygons& triangles, float z, bool generate_tex_coords);
bool set_from_lines(const Lines& lines, float z);
const float* get_vertices() const;
const float* get_tex_coords() const;
unsigned int get_vertices_count() const;
};
#endif // !ENABLE_UNIQUE_BED
class Size class Size
{ {
int m_width; int m_width;
@ -138,9 +114,7 @@ wxDECLARE_EVENT(EVT_GLCANVAS_INSTANCE_SCALED, SimpleEvent);
wxDECLARE_EVENT(EVT_GLCANVAS_ENABLE_ACTION_BUTTONS, Event<bool>); wxDECLARE_EVENT(EVT_GLCANVAS_ENABLE_ACTION_BUTTONS, Event<bool>);
wxDECLARE_EVENT(EVT_GLCANVAS_UPDATE_GEOMETRY, Vec3dsEvent<2>); wxDECLARE_EVENT(EVT_GLCANVAS_UPDATE_GEOMETRY, Vec3dsEvent<2>);
wxDECLARE_EVENT(EVT_GLCANVAS_MOUSE_DRAGGING_FINISHED, SimpleEvent); wxDECLARE_EVENT(EVT_GLCANVAS_MOUSE_DRAGGING_FINISHED, SimpleEvent);
#if ENABLE_UNIQUE_BED
wxDECLARE_EVENT(EVT_GLCANVAS_UPDATE_BED_SHAPE, SimpleEvent); wxDECLARE_EVENT(EVT_GLCANVAS_UPDATE_BED_SHAPE, SimpleEvent);
#endif // ENABLE_UNIQUE_BED
// this describes events being passed from GLCanvas3D to SlaSupport gizmo // this describes events being passed from GLCanvas3D to SlaSupport gizmo
enum class SLAGizmoEventType { enum class SLAGizmoEventType {
@ -218,78 +192,6 @@ class GLCanvas3D
void set_scene_box(const BoundingBoxf3& box, GLCanvas3D& canvas); void set_scene_box(const BoundingBoxf3& box, GLCanvas3D& canvas);
}; };
#if !ENABLE_UNIQUE_BED
class Bed
{
public:
enum EType : unsigned char
{
MK2,
MK3,
SL1,
Custom,
Num_Types
};
private:
EType m_type;
Pointfs m_shape;
BoundingBoxf3 m_bounding_box;
Polygon m_polygon;
GeometryBuffer m_triangles;
GeometryBuffer m_gridlines;
mutable GLTexture m_top_texture;
mutable GLTexture m_bottom_texture;
mutable GLBed m_model;
mutable float m_scale_factor;
public:
Bed();
EType get_type() const { return m_type; }
bool is_prusa() const;
bool is_custom() const;
const Pointfs& get_shape() const;
// Return true if the bed shape changed, so the calee will update the UI.
bool set_shape(const Pointfs& shape);
const BoundingBoxf3& get_bounding_box() const;
bool contains(const Point& point) const;
Point point_projection(const Point& point) const;
void render(float theta, bool useVBOs, float scale_factor) const;
private:
void _calc_bounding_box();
void _calc_triangles(const ExPolygon& poly);
void _calc_gridlines(const ExPolygon& poly, const BoundingBox& bed_bbox);
EType _detect_type(const Pointfs& shape) const;
void _render_prusa(const std::string &key, float theta, bool useVBOs) const;
void _render_custom() const;
};
struct Axes
{
static const double Radius;
static const double ArrowBaseRadius;
static const double ArrowLength;
Vec3d origin;
Vec3d length;
GLUquadricObj* m_quadric;
Axes();
~Axes();
void render() const;
private:
void render_axis(double length) const;
};
#endif // !ENABLE_UNIQUE_BED
class Shader class Shader
{ {
GLShader* m_shader; GLShader* m_shader;
@ -885,12 +787,7 @@ private:
WarningTexture m_warning_texture; WarningTexture m_warning_texture;
wxTimer m_timer; wxTimer m_timer;
Camera m_camera; Camera m_camera;
#if ENABLE_UNIQUE_BED
Bed3D* m_bed; Bed3D* m_bed;
#else
Bed m_bed;
Axes m_axes;
#endif // ENABLE_UNIQUE_BED
LayersEditing m_layers_editing; LayersEditing m_layers_editing;
Shader m_shader; Shader m_shader;
Mouse m_mouse; Mouse m_mouse;
@ -945,9 +842,7 @@ public:
wxGLCanvas* get_wxglcanvas() { return m_canvas; } wxGLCanvas* get_wxglcanvas() { return m_canvas; }
const wxGLCanvas* get_wxglcanvas() const { return m_canvas; } const wxGLCanvas* get_wxglcanvas() const { return m_canvas; }
#if ENABLE_UNIQUE_BED
void set_bed(Bed3D* bed) { m_bed = bed; } void set_bed(Bed3D* bed) { m_bed = bed; }
#endif // ENABLE_UNIQUE_BED
void set_view_toolbar(GLToolbar* toolbar) { m_view_toolbar = toolbar; } void set_view_toolbar(GLToolbar* toolbar) { m_view_toolbar = toolbar; }
@ -970,16 +865,7 @@ public:
const Selection& get_selection() const { return m_selection; } const Selection& get_selection() const { return m_selection; }
Selection& get_selection() { return m_selection; } Selection& get_selection() { return m_selection; }
#if ENABLE_UNIQUE_BED
void bed_shape_changed(); void bed_shape_changed();
#else
// Set the bed shape to a single closed 2D polygon(array of two element arrays),
// triangulate the bed and store the triangles into m_bed.m_triangles,
// fills the m_bed.m_grid_lines and sets m_bed.m_origin.
// Sets m_bed.m_polygon to limit the object placement.
void set_bed_shape(const Pointfs& shape);
void set_bed_axes_length(double length);
#endif // ENABLE_UNIQUE_BED
void set_clipping_plane(unsigned int id, const ClippingPlane& plane) void set_clipping_plane(unsigned int id, const ClippingPlane& plane)
{ {

19
src/slic3r/GUI/GUI_Preview.cpp
View file

@ -89,13 +89,11 @@ bool View3D::init(wxWindow* parent, Model* model, DynamicPrintConfig* config, Ba
return true; return true;
} }
#if ENABLE_UNIQUE_BED
void View3D::set_bed(Bed3D* bed) void View3D::set_bed(Bed3D* bed)
{ {
if (m_canvas != nullptr) if (m_canvas != nullptr)
m_canvas->set_bed(bed); m_canvas->set_bed(bed);
} }
#endif // ENABLE_UNIQUE_BED
void View3D::set_view_toolbar(GLToolbar* toolbar) void View3D::set_view_toolbar(GLToolbar* toolbar)
{ {
@ -109,19 +107,11 @@ void View3D::set_as_dirty()
m_canvas->set_as_dirty(); m_canvas->set_as_dirty();
} }
#if ENABLE_UNIQUE_BED
void View3D::bed_shape_changed() void View3D::bed_shape_changed()
{ {
if (m_canvas != nullptr) if (m_canvas != nullptr)
m_canvas->bed_shape_changed(); m_canvas->bed_shape_changed();
} }
#else
void View3D::set_bed_shape(const Pointfs& shape)
{
if (m_canvas != nullptr)
m_canvas->set_bed_shape(shape);
}
#endif // ENABLE_UNIQUE_BED
void View3D::select_view(const std::string& direction) void View3D::select_view(const std::string& direction)
{ {
@ -353,13 +343,11 @@ Preview::~Preview()
} }
} }
#if ENABLE_UNIQUE_BED
void Preview::set_bed(Bed3D* bed) void Preview::set_bed(Bed3D* bed)
{ {
if (m_canvas != nullptr) if (m_canvas != nullptr)
m_canvas->set_bed(bed); m_canvas->set_bed(bed);
} }
#endif // ENABLE_UNIQUE_BED
void Preview::set_view_toolbar(GLToolbar* toolbar) void Preview::set_view_toolbar(GLToolbar* toolbar)
{ {
@ -392,18 +380,11 @@ void Preview::set_enabled(bool enabled)
m_enabled = enabled; m_enabled = enabled;
} }
#if ENABLE_UNIQUE_BED
void Preview::bed_shape_changed() void Preview::bed_shape_changed()
{ {
if (m_canvas != nullptr) if (m_canvas != nullptr)
m_canvas->bed_shape_changed(); m_canvas->bed_shape_changed();
} }
#else
vvoid Preview::set_bed_shape(const Pointfs& shape)
{
m_canvas->set_bed_shape(shape);
}
#endif // ENABLE_UNIQUE_BED
void Preview::select_view(const std::string& direction) void Preview::select_view(const std::string& direction)
{ {

14
src/slic3r/GUI/GUI_Preview.hpp
View file

@ -27,9 +27,7 @@ namespace GUI {
class GLCanvas3D; class GLCanvas3D;
class GLToolbar; class GLToolbar;
#if ENABLE_UNIQUE_BED
class Bed3D; class Bed3D;
#endif // ENABLE_UNIQUE_BED
class View3D : public wxPanel class View3D : public wxPanel
{ {
@ -51,17 +49,11 @@ public:
wxGLCanvas* get_wxglcanvas() { return m_canvas_widget; } wxGLCanvas* get_wxglcanvas() { return m_canvas_widget; }
GLCanvas3D* get_canvas3d() { return m_canvas; } GLCanvas3D* get_canvas3d() { return m_canvas; }
#if ENABLE_UNIQUE_BED
void set_bed(Bed3D* bed); void set_bed(Bed3D* bed);
#endif // ENABLE_UNIQUE_BED
void set_view_toolbar(GLToolbar* toolbar); void set_view_toolbar(GLToolbar* toolbar);
void set_as_dirty(); void set_as_dirty();
#if ENABLE_UNIQUE_BED
void bed_shape_changed(); void bed_shape_changed();
#else
void set_bed_shape(const Pointfs& shape);
#endif // ENABLE_UNIQUE_BED
void select_view(const std::string& direction); void select_view(const std::string& direction);
void select_all(); void select_all();
@ -124,19 +116,13 @@ public:
wxGLCanvas* get_wxglcanvas() { return m_canvas_widget; } wxGLCanvas* get_wxglcanvas() { return m_canvas_widget; }
GLCanvas3D* get_canvas3d() { return m_canvas; } GLCanvas3D* get_canvas3d() { return m_canvas; }
#if ENABLE_UNIQUE_BED
void set_bed(Bed3D* bed); void set_bed(Bed3D* bed);
#endif // ENABLE_UNIQUE_BED
void set_view_toolbar(GLToolbar* toolbar); void set_view_toolbar(GLToolbar* toolbar);
void set_number_extruders(unsigned int number_extruders); void set_number_extruders(unsigned int number_extruders);
void set_canvas_as_dirty(); void set_canvas_as_dirty();
void set_enabled(bool enabled); void set_enabled(bool enabled);
#if ENABLE_UNIQUE_BED
void bed_shape_changed(); void bed_shape_changed();
#else
void set_bed_shape(const Pointfs& shape);
#endif // ENABLE_UNIQUE_BED
void select_view(const std::string& direction); void select_view(const std::string& direction);
void set_viewport_from_scene(GLCanvas3D* canvas); void set_viewport_from_scene(GLCanvas3D* canvas);
void set_viewport_into_scene(GLCanvas3D* canvas); void set_viewport_into_scene(GLCanvas3D* canvas);

21
src/slic3r/GUI/Plater.cpp
View file

@ -49,9 +49,7 @@
#include "GLCanvas3D.hpp" #include "GLCanvas3D.hpp"
#include "GLToolbar.hpp" #include "GLToolbar.hpp"
#include "GUI_Preview.hpp" #include "GUI_Preview.hpp"
#if ENABLE_UNIQUE_BED
#include "3DBed.hpp" #include "3DBed.hpp"
#endif // ENABLE_UNIQUE_BED
#include "Tab.hpp" #include "Tab.hpp"
#include "PresetBundle.hpp" #include "PresetBundle.hpp"
#include "BackgroundSlicingProcess.hpp" #include "BackgroundSlicingProcess.hpp"
@ -955,9 +953,7 @@ struct Plater::priv
wxPanel* current_panel; wxPanel* current_panel;
std::vector<wxPanel*> panels; std::vector<wxPanel*> panels;
Sidebar *sidebar; Sidebar *sidebar;
#if ENABLE_UNIQUE_BED
Bed3D bed; Bed3D bed;
#endif // ENABLE_UNIQUE_BED
View3D* view3D; View3D* view3D;
GLToolbar view_toolbar; GLToolbar view_toolbar;
Preview *preview; Preview *preview;
@ -1062,13 +1058,11 @@ struct Plater::priv
void update_object_menu(); void update_object_menu();
#if ENABLE_UNIQUE_BED
// Set the bed shape to a single closed 2D polygon(array of two element arrays), // Set the bed shape to a single closed 2D polygon(array of two element arrays),
// triangulate the bed and store the triangles into m_bed.m_triangles, // triangulate the bed and store the triangles into m_bed.m_triangles,
// fills the m_bed.m_grid_lines and sets m_bed.m_origin. // fills the m_bed.m_grid_lines and sets m_bed.m_origin.
// Sets m_bed.m_polygon to limit the object placement. // Sets m_bed.m_polygon to limit the object placement.
void set_bed_shape(const Pointfs& shape); void set_bed_shape(const Pointfs& shape);
#endif // ENABLE_UNIQUE_BED
private: private:
bool init_object_menu(); bool init_object_menu();
@ -1145,10 +1139,8 @@ Plater::priv::priv(Plater *q, MainFrame *main_frame)
view3D->Bind(wxEVT_NAVIGATION_KEY, [this](wxNavigationKeyEvent &evt) { if (evt.IsFromTab()) this->select_next_view_3D(); }); view3D->Bind(wxEVT_NAVIGATION_KEY, [this](wxNavigationKeyEvent &evt) { if (evt.IsFromTab()) this->select_next_view_3D(); });
preview->Bind(wxEVT_NAVIGATION_KEY, [this](wxNavigationKeyEvent &evt) { if (evt.IsFromTab()) this->select_next_view_3D(); }); preview->Bind(wxEVT_NAVIGATION_KEY, [this](wxNavigationKeyEvent &evt) { if (evt.IsFromTab()) this->select_next_view_3D(); });
#if ENABLE_UNIQUE_BED
view3D->set_bed(&bed); view3D->set_bed(&bed);
preview->set_bed(&bed); preview->set_bed(&bed);
#endif // ENABLE_UNIQUE_BED
panels.push_back(view3D); panels.push_back(view3D);
panels.push_back(preview); panels.push_back(preview);
@ -1206,16 +1198,12 @@ Plater::priv::priv(Plater *q, MainFrame *main_frame)
view3D_canvas->Bind(EVT_GLTOOLBAR_SPLIT_VOLUMES, &priv::on_action_split_volumes, this); view3D_canvas->Bind(EVT_GLTOOLBAR_SPLIT_VOLUMES, &priv::on_action_split_volumes, this);
view3D_canvas->Bind(EVT_GLTOOLBAR_LAYERSEDITING, &priv::on_action_layersediting, this); view3D_canvas->Bind(EVT_GLTOOLBAR_LAYERSEDITING, &priv::on_action_layersediting, this);
view3D_canvas->Bind(EVT_GLCANVAS_INIT, [this](SimpleEvent&) { init_view_toolbar(); }); view3D_canvas->Bind(EVT_GLCANVAS_INIT, [this](SimpleEvent&) { init_view_toolbar(); });
#if ENABLE_UNIQUE_BED
view3D_canvas->Bind(EVT_GLCANVAS_UPDATE_BED_SHAPE, [this](SimpleEvent&) { set_bed_shape(config->option<ConfigOptionPoints>("bed_shape")->values); }); view3D_canvas->Bind(EVT_GLCANVAS_UPDATE_BED_SHAPE, [this](SimpleEvent&) { set_bed_shape(config->option<ConfigOptionPoints>("bed_shape")->values); });
#endif // ENABLE_UNIQUE_BED
// Preview events: // Preview events:
preview->get_wxglcanvas()->Bind(EVT_GLCANVAS_VIEWPORT_CHANGED, &priv::on_viewport_changed, this); preview->get_wxglcanvas()->Bind(EVT_GLCANVAS_VIEWPORT_CHANGED, &priv::on_viewport_changed, this);
preview->get_wxglcanvas()->Bind(EVT_GLCANVAS_QUESTION_MARK, [this](SimpleEvent&) { wxGetApp().keyboard_shortcuts(); }); preview->get_wxglcanvas()->Bind(EVT_GLCANVAS_QUESTION_MARK, [this](SimpleEvent&) { wxGetApp().keyboard_shortcuts(); });
#if ENABLE_UNIQUE_BED
preview->get_wxglcanvas()->Bind(EVT_GLCANVAS_UPDATE_BED_SHAPE, [this](SimpleEvent&) { set_bed_shape(config->option<ConfigOptionPoints>("bed_shape")->values); }); preview->get_wxglcanvas()->Bind(EVT_GLCANVAS_UPDATE_BED_SHAPE, [this](SimpleEvent&) { set_bed_shape(config->option<ConfigOptionPoints>("bed_shape")->values); });
#endif // ENABLE_UNIQUE_BED
view3D_canvas->Bind(EVT_GLCANVAS_INIT, [this](SimpleEvent&) { init_view_toolbar(); }); view3D_canvas->Bind(EVT_GLCANVAS_INIT, [this](SimpleEvent&) { init_view_toolbar(); });
@ -2666,7 +2654,6 @@ bool Plater::priv::can_mirror() const
return get_selection().is_from_single_instance(); return get_selection().is_from_single_instance();
} }
#if ENABLE_UNIQUE_BED
void Plater::priv::set_bed_shape(const Pointfs& shape) void Plater::priv::set_bed_shape(const Pointfs& shape)
{ {
bool new_shape = bed.set_shape(shape); bool new_shape = bed.set_shape(shape);
@ -2676,7 +2663,6 @@ void Plater::priv::set_bed_shape(const Pointfs& shape)
if (preview) preview->bed_shape_changed(); if (preview) preview->bed_shape_changed();
} }
} }
#endif // ENABLE_UNIQUE_BED
void Plater::priv::update_object_menu() void Plater::priv::update_object_menu()
{ {
@ -3117,14 +3103,7 @@ void Plater::on_config_change(const DynamicPrintConfig &config)
} }
if (bed_shape_changed) if (bed_shape_changed)
{
#if ENABLE_UNIQUE_BED
p->set_bed_shape(p->config->option<ConfigOptionPoints>("bed_shape")->values); p->set_bed_shape(p->config->option<ConfigOptionPoints>("bed_shape")->values);
#else
if (p->view3D) p->view3D->set_bed_shape(p->config->option<ConfigOptionPoints>("bed_shape")->values);
if (p->preview) p->preview->set_bed_shape(p->config->option<ConfigOptionPoints>("bed_shape")->values);
#endif // ENABLE_UNIQUE_BED
}
if (update_scheduled) if (update_scheduled)
update(); update();

2
src/slic3r/GUI/Plater.hpp
View file

@ -10,10 +10,8 @@
#include "Preset.hpp" #include "Preset.hpp"
#if ENABLE_UNIQUE_BED
#include "3DScene.hpp" #include "3DScene.hpp"
#include "GLTexture.hpp" #include "GLTexture.hpp"
#endif // ENABLE_UNIQUE_BED
class wxButton; class wxButton;
class wxBoxSizer; class wxBoxSizer;