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

Tech ENABLE_SINKING_CONTOURS set as default

Browse source
This commit is contained in:
enricoturri1966 2021-09-14 15:45:21 +02:00
parent bf21abfbfa
commit f132ca9c3c
8 changed files with 1 additions and 99 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/libslic3r/Technologies.hpp
View file

@ -41,8 +41,6 @@
//==================== //====================
#define ENABLE_2_4_0_ALPHA1 1 #define ENABLE_2_4_0_ALPHA1 1
// Enable drawing contours, at cut level, for sinking volumes
#define ENABLE_SINKING_CONTOURS (1 && ENABLE_2_4_0_ALPHA1)
// Enable implementation of retract acceleration in gcode processor // Enable implementation of retract acceleration in gcode processor
#define ENABLE_RETRACT_ACCELERATION (1 && ENABLE_2_4_0_ALPHA1) #define ENABLE_RETRACT_ACCELERATION (1 && ENABLE_2_4_0_ALPHA1)
// Enable the fix for exporting and importing to/from 3mf file of mirrored volumes // Enable the fix for exporting and importing to/from 3mf file of mirrored volumes

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

@ -9,9 +9,7 @@
#include "3DScene.hpp" #include "3DScene.hpp"
#include "GLShader.hpp" #include "GLShader.hpp"
#include "GUI_App.hpp" #include "GUI_App.hpp"
#if ENABLE_ENVIRONMENT_MAP || ENABLE_SINKING_CONTOURS
#include "Plater.hpp" #include "Plater.hpp"
#endif // ENABLE_ENVIRONMENT_MAP || ENABLE_SINKING_CONTOURS
#include "libslic3r/ExtrusionEntity.hpp" #include "libslic3r/ExtrusionEntity.hpp"
#include "libslic3r/ExtrusionEntityCollection.hpp" #include "libslic3r/ExtrusionEntityCollection.hpp"
@ -25,9 +23,7 @@
#include "libslic3r/AppConfig.hpp" #include "libslic3r/AppConfig.hpp"
#include "libslic3r/PresetBundle.hpp" #include "libslic3r/PresetBundle.hpp"
#include "libslic3r/ClipperUtils.hpp" #include "libslic3r/ClipperUtils.hpp"
#if ENABLE_SINKING_CONTOURS
#include "libslic3r/Tesselate.hpp" #include "libslic3r/Tesselate.hpp"
#endif // ENABLE_SINKING_CONTOURS
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
@ -293,7 +289,6 @@ void GLIndexedVertexArray::render(
glsafe(::glBindBuffer(GL_ARRAY_BUFFER, 0)); glsafe(::glBindBuffer(GL_ARRAY_BUFFER, 0));
} }
#if ENABLE_SINKING_CONTOURS
const float GLVolume::SinkingContours::HalfWidth = 0.25f; const float GLVolume::SinkingContours::HalfWidth = 0.25f;
void GLVolume::SinkingContours::render() void GLVolume::SinkingContours::render()
@ -362,7 +357,6 @@ void GLVolume::SinkingContours::update()
else else
m_model.reset(); m_model.reset();
} }
#endif // ENABLE_SINKING_CONTOURS
const std::array<float, 4> GLVolume::SELECTED_COLOR = { 0.0f, 1.0f, 0.0f, 1.0f }; const std::array<float, 4> GLVolume::SELECTED_COLOR = { 0.0f, 1.0f, 0.0f, 1.0f };
const std::array<float, 4> GLVolume::HOVER_SELECT_COLOR = { 0.4f, 0.9f, 0.1f, 1.0f }; const std::array<float, 4> GLVolume::HOVER_SELECT_COLOR = { 0.4f, 0.9f, 0.1f, 1.0f };
@ -384,9 +378,7 @@ GLVolume::GLVolume(float r, float g, float b, float a)
: m_transformed_bounding_box_dirty(true) : m_transformed_bounding_box_dirty(true)
, m_sla_shift_z(0.0) , m_sla_shift_z(0.0)
, m_transformed_convex_hull_bounding_box_dirty(true) , m_transformed_convex_hull_bounding_box_dirty(true)
#if ENABLE_SINKING_CONTOURS
, m_sinking_contours(*this) , m_sinking_contours(*this)
#endif // ENABLE_SINKING_CONTOURS
// geometry_id == 0 -> invalid // geometry_id == 0 -> invalid
, geometry_id(std::pair<size_t, size_t>(0, 0)) , geometry_id(std::pair<size_t, size_t>(0, 0))
, extruder_id(0) , extruder_id(0)
@ -404,9 +396,7 @@ GLVolume::GLVolume(float r, float g, float b, float a)
, force_transparent(false) , force_transparent(false)
, force_native_color(false) , force_native_color(false)
, force_neutral_color(false) , force_neutral_color(false)
#if ENABLE_SINKING_CONTOURS
, force_sinking_contours(false) , force_sinking_contours(false)
#endif // ENABLE_SINKING_CONTOURS
, tverts_range(0, size_t(-1)) , tverts_range(0, size_t(-1))
, qverts_range(0, size_t(-1)) , qverts_range(0, size_t(-1))
{ {
@ -610,12 +600,10 @@ bool GLVolume::is_below_printbed() const
return transformed_convex_hull_bounding_box().max.z() < 0.0; return transformed_convex_hull_bounding_box().max.z() < 0.0;
} }
#if ENABLE_SINKING_CONTOURS
void GLVolume::render_sinking_contours() void GLVolume::render_sinking_contours()
{ {
m_sinking_contours.render(); m_sinking_contours.render();
} }
#endif // ENABLE_SINKING_CONTOURS
std::vector<int> GLVolumeCollection::load_object( std::vector<int> GLVolumeCollection::load_object(
const ModelObject *model_object, const ModelObject *model_object,
@ -839,11 +827,9 @@ GLVolumeWithIdAndZList volumes_to_render(const GLVolumePtrs& volumes, GLVolumeCo
void GLVolumeCollection::render(GLVolumeCollection::ERenderType type, bool disable_cullface, const Transform3d& view_matrix, std::function<bool(const GLVolume&)> filter_func) const void GLVolumeCollection::render(GLVolumeCollection::ERenderType type, bool disable_cullface, const Transform3d& view_matrix, std::function<bool(const GLVolume&)> filter_func) const
{ {
#if ENABLE_SINKING_CONTOURS
GLVolumeWithIdAndZList to_render = volumes_to_render(volumes, type, view_matrix, filter_func); GLVolumeWithIdAndZList to_render = volumes_to_render(volumes, type, view_matrix, filter_func);
if (to_render.empty()) if (to_render.empty())
return; return;
#endif // ENABLE_SINKING_CONTOURS
GLShaderProgram* shader = GUI::wxGetApp().get_current_shader(); GLShaderProgram* shader = GUI::wxGetApp().get_current_shader();
if (shader == nullptr) if (shader == nullptr)
@ -858,7 +844,6 @@ void GLVolumeCollection::render(GLVolumeCollection::ERenderType type, bool disab
if (disable_cullface) if (disable_cullface)
glsafe(::glDisable(GL_CULL_FACE)); glsafe(::glDisable(GL_CULL_FACE));
#if ENABLE_SINKING_CONTOURS
for (GLVolumeWithIdAndZ& volume : to_render) { for (GLVolumeWithIdAndZ& volume : to_render) {
volume.first->set_render_color(); volume.first->set_render_color();
@ -908,7 +893,7 @@ void GLVolumeCollection::render(GLVolumeCollection::ERenderType type, bool disab
glsafe(::glDisableClientState(GL_NORMAL_ARRAY)); glsafe(::glDisableClientState(GL_NORMAL_ARRAY));
} }
if (m_show_sinking_contours) if (m_show_sinking_contours) {
for (GLVolumeWithIdAndZ& volume : to_render) { for (GLVolumeWithIdAndZ& volume : to_render) {
// render sinking contours of hovered/displaced volumes // render sinking contours of hovered/displaced volumes
if (volume.first->is_sinking() && !volume.first->is_below_printbed() && if (volume.first->is_sinking() && !volume.first->is_below_printbed() &&
@ -920,48 +905,8 @@ void GLVolumeCollection::render(GLVolumeCollection::ERenderType type, bool disab
shader->start_using(); shader->start_using();
} }
} }
#else
glsafe(::glEnableClientState(GL_VERTEX_ARRAY));
glsafe(::glEnableClientState(GL_NORMAL_ARRAY));
shader->set_uniform("print_box.min", m_print_box_min, 3);
shader->set_uniform("print_box.max", m_print_box_max, 3);
shader->set_uniform("z_range", m_z_range, 2);
shader->set_uniform("clipping_plane", m_clipping_plane, 4);
shader->set_uniform("slope.normal_z", m_slope.normal_z);
#if ENABLE_ENVIRONMENT_MAP
unsigned int environment_texture_id = GUI::wxGetApp().plater()->get_environment_texture_id();
bool use_environment_texture = environment_texture_id > 0 && GUI::wxGetApp().app_config->get("use_environment_map") == "1";
shader->set_uniform("use_environment_tex", use_environment_texture);
if (use_environment_texture)
glsafe(::glBindTexture(GL_TEXTURE_2D, environment_texture_id));
#endif // ENABLE_ENVIRONMENT_MAP
glcheck();
GLVolumeWithIdAndZList to_render = volumes_to_render(this->volumes, type, view_matrix, filter_func);
for (GLVolumeWithIdAndZ& volume : to_render) {
volume.first->set_render_color();
shader->set_uniform("uniform_color", volume.first->render_color);
shader->set_uniform("print_box.actived", volume.first->shader_outside_printer_detection_enabled);
shader->set_uniform("print_box.volume_world_matrix", volume.first->world_matrix());
shader->set_uniform("slope.actived", m_slope.active && !volume.first->is_modifier && !volume.first->is_wipe_tower);
shader->set_uniform("slope.volume_world_normal_matrix", static_cast<Matrix3f>(volume.first->world_matrix().matrix().block(0, 0, 3, 3).inverse().transpose().cast<float>()));
volume.first->render();
} }
#if ENABLE_ENVIRONMENT_MAP
if (use_environment_texture)
glsafe(::glBindTexture(GL_TEXTURE_2D, 0));
#endif // ENABLE_ENVIRONMENT_MAP
glsafe(::glBindBuffer(GL_ARRAY_BUFFER, 0));
glsafe(::glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0));
glsafe(::glDisableClientState(GL_VERTEX_ARRAY));
glsafe(::glDisableClientState(GL_NORMAL_ARRAY));
#endif // ENABLE_SINKING_CONTOURS
if (disable_cullface) if (disable_cullface)
glsafe(::glEnable(GL_CULL_FACE)); glsafe(::glEnable(GL_CULL_FACE));

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

@ -8,9 +8,7 @@
#include "libslic3r/Utils.hpp" #include "libslic3r/Utils.hpp"
#include "libslic3r/Geometry.hpp" #include "libslic3r/Geometry.hpp"
#if ENABLE_SINKING_CONTOURS
#include "GLModel.hpp" #include "GLModel.hpp"
#endif // ENABLE_SINKING_CONTOURS
#include <functional> #include <functional>
@ -260,9 +258,7 @@ public:
enum EHoverState : unsigned char enum EHoverState : unsigned char
{ {
HS_None, HS_None,
#if ENABLE_SINKING_CONTOURS
HS_Hover, HS_Hover,
#endif // ENABLE_SINKING_CONTOURS
HS_Select, HS_Select,
HS_Deselect HS_Deselect
}; };
@ -287,7 +283,6 @@ private:
// Whether or not is needed to recalculate the transformed convex hull bounding box. // Whether or not is needed to recalculate the transformed convex hull bounding box.
bool m_transformed_convex_hull_bounding_box_dirty; bool m_transformed_convex_hull_bounding_box_dirty;
#if ENABLE_SINKING_CONTOURS
class SinkingContours class SinkingContours
{ {
static const float HalfWidth; static const float HalfWidth;
@ -305,7 +300,6 @@ private:
}; };
SinkingContours m_sinking_contours; SinkingContours m_sinking_contours;
#endif // ENABLE_SINKING_CONTOURS
public: public:
// Color of the triangles / quads held by this volume. // Color of the triangles / quads held by this volume.
@ -367,10 +361,8 @@ public:
bool force_native_color : 1; bool force_native_color : 1;
// Whether or not render this volume in neutral // Whether or not render this volume in neutral
bool force_neutral_color : 1; bool force_neutral_color : 1;
#if ENABLE_SINKING_CONTOURS
// Whether or not to force rendering of sinking contours // Whether or not to force rendering of sinking contours
bool force_sinking_contours : 1; bool force_sinking_contours : 1;
#endif // ENABLE_SINKING_CONTOURS
}; };
// Is mouse or rectangle selection over this object to select/deselect it ? // Is mouse or rectangle selection over this object to select/deselect it ?
@ -499,9 +491,7 @@ public:
bool is_sinking() const; bool is_sinking() const;
bool is_below_printbed() const; bool is_below_printbed() const;
#if ENABLE_SINKING_CONTOURS
void render_sinking_contours(); void render_sinking_contours();
#endif // ENABLE_SINKING_CONTOURS
// Return an estimate of the memory consumed by this class. // Return an estimate of the memory consumed by this class.
size_t cpu_memory_used() const { size_t cpu_memory_used() const {

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

@ -2926,7 +2926,6 @@ void GLCanvas3D::on_mouse(wxMouseEvent& evt)
return; return;
} }
#if ENABLE_SINKING_CONTOURS
for (GLVolume* volume : m_volumes.volumes) { for (GLVolume* volume : m_volumes.volumes) {
volume->force_sinking_contours = false; volume->force_sinking_contours = false;
} }
@ -2938,7 +2937,6 @@ void GLCanvas3D::on_mouse(wxMouseEvent& evt)
} }
m_dirty = true; m_dirty = true;
}; };
#endif // ENABLE_SINKING_CONTOURS
if (m_gizmos.on_mouse(evt)) { if (m_gizmos.on_mouse(evt)) {
if (wxWindow::FindFocus() != m_canvas) if (wxWindow::FindFocus() != m_canvas)
@ -2964,7 +2962,6 @@ void GLCanvas3D::on_mouse(wxMouseEvent& evt)
default: { break; } default: { break; }
} }
} }
#if ENABLE_SINKING_CONTOURS
else if (evt.Dragging()) { else if (evt.Dragging()) {
switch (m_gizmos.get_current_type()) switch (m_gizmos.get_current_type())
{ {
@ -2978,7 +2975,6 @@ void GLCanvas3D::on_mouse(wxMouseEvent& evt)
default: { break; } default: { break; }
} }
} }
#endif // ENABLE_SINKING_CONTOURS
return; return;
} }
@ -3288,10 +3284,8 @@ void GLCanvas3D::on_mouse(wxMouseEvent& evt)
else else
evt.Skip(); evt.Skip();
#if ENABLE_SINKING_CONTOURS
if (m_moving) if (m_moving)
show_sinking_contours(); show_sinking_contours();
#endif // ENABLE_SINKING_CONTOURS
#ifdef __WXMSW__ #ifdef __WXMSW__
if (on_enter_workaround) if (on_enter_workaround)
@ -5648,11 +5642,8 @@ void GLCanvas3D::_update_volumes_hover_state()
} }
} }
} }
#if ENABLE_SINKING_CONTOURS
else if (volume.selected) else if (volume.selected)
volume.hover = GLVolume::HS_Hover; volume.hover = GLVolume::HS_Hover;
#endif // ENABLE_SINKING_CONTOURS
} }
} }

4
src/slic3r/GUI/GLModel.cpp
View file

@ -7,9 +7,7 @@
#include "libslic3r/TriangleMesh.hpp" #include "libslic3r/TriangleMesh.hpp"
#include "libslic3r/Model.hpp" #include "libslic3r/Model.hpp"
#if ENABLE_SINKING_CONTOURS
#include "libslic3r/Polygon.hpp" #include "libslic3r/Polygon.hpp"
#endif // ENABLE_SINKING_CONTOURS
#include <boost/filesystem/operations.hpp> #include <boost/filesystem/operations.hpp>
#include <boost/algorithm/string/predicate.hpp> #include <boost/algorithm/string/predicate.hpp>
@ -116,7 +114,6 @@ void GLModel::init_from(const indexed_triangle_set& its)
this->init_from(its, bounding_box(its)); this->init_from(its, bounding_box(its));
} }
#if ENABLE_SINKING_CONTOURS
void GLModel::init_from(const Polygons& polygons, float z) void GLModel::init_from(const Polygons& polygons, float z)
{ {
auto append_polygon = [](const Polygon& polygon, float z, GUI::GLModel::InitializationData& data) { auto append_polygon = [](const Polygon& polygon, float z, GUI::GLModel::InitializationData& data) {
@ -143,7 +140,6 @@ void GLModel::init_from(const Polygons& polygons, float z)
} }
init_from(init_data); init_from(init_data);
} }
#endif // ENABLE_SINKING_CONTOURS
bool GLModel::init_from_file(const std::string& filename) bool GLModel::init_from_file(const std::string& filename)
{ {

4
src/slic3r/GUI/GLModel.hpp
View file

@ -9,10 +9,8 @@
namespace Slic3r { namespace Slic3r {
class TriangleMesh; class TriangleMesh;
#if ENABLE_SINKING_CONTOURS
class Polygon; class Polygon;
using Polygons = std::vector<Polygon>; using Polygons = std::vector<Polygon>;
#endif // ENABLE_SINKING_CONTOURS
namespace GUI { namespace GUI {
@ -72,9 +70,7 @@ namespace GUI {
void init_from(const InitializationData& data); void init_from(const InitializationData& data);
void init_from(const indexed_triangle_set& its, const BoundingBoxf3& bbox); void init_from(const indexed_triangle_set& its, const BoundingBoxf3& bbox);
void init_from(const indexed_triangle_set& its); void init_from(const indexed_triangle_set& its);
#if ENABLE_SINKING_CONTOURS
void init_from(const Polygons& polygons, float z); void init_from(const Polygons& polygons, float z);
#endif // ENABLE_SINKING_CONTOURS
bool init_from_file(const std::string& filename); bool init_from_file(const std::string& filename);
// if entity_id == -1 set the color of all entities // if entity_id == -1 set the color of all entities

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

@ -16,9 +16,7 @@
#include "slic3r/GUI/GUI_ObjectManipulation.hpp" #include "slic3r/GUI/GUI_ObjectManipulation.hpp"
#include "libslic3r/AppConfig.hpp" #include "libslic3r/AppConfig.hpp"
#include "libslic3r/Model.hpp" #include "libslic3r/Model.hpp"
#if ENABLE_SINKING_CONTOURS
#include "libslic3r/TriangleMeshSlicer.hpp" #include "libslic3r/TriangleMeshSlicer.hpp"
#endif // ENABLE_SINKING_CONTOURS
namespace Slic3r { namespace Slic3r {
namespace GUI { namespace GUI {
@ -92,9 +90,7 @@ void GLGizmoCut::on_render()
m_max_z = box.max.z(); m_max_z = box.max.z();
set_cut_z(m_cut_z); set_cut_z(m_cut_z);
#if ENABLE_SINKING_CONTOURS
update_contours(); update_contours();
#endif // ENABLE_SINKING_CONTOURS
const float min_x = box.min.x() - Margin; const float min_x = box.min.x() - Margin;
const float max_x = box.max.x() + Margin; const float max_x = box.max.x() + Margin;
@ -143,13 +139,11 @@ void GLGizmoCut::on_render()
shader->stop_using(); shader->stop_using();
#if ENABLE_SINKING_CONTOURS
glsafe(::glPushMatrix()); glsafe(::glPushMatrix());
glsafe(::glTranslated(m_cut_contours.shift.x(), m_cut_contours.shift.y(), m_cut_contours.shift.z())); glsafe(::glTranslated(m_cut_contours.shift.x(), m_cut_contours.shift.y(), m_cut_contours.shift.z()));
glsafe(::glLineWidth(2.0f)); glsafe(::glLineWidth(2.0f));
m_cut_contours.contours.render(); m_cut_contours.contours.render();
glsafe(::glPopMatrix()); glsafe(::glPopMatrix());
#endif // ENABLE_SINKING_CONTOURS
} }
void GLGizmoCut::on_render_for_picking() void GLGizmoCut::on_render_for_picking()
@ -275,7 +269,6 @@ BoundingBoxf3 GLGizmoCut::bounding_box() const
return ret; return ret;
} }
#if ENABLE_SINKING_CONTOURS
void GLGizmoCut::update_contours() void GLGizmoCut::update_contours()
{ {
const Selection& selection = m_parent.get_selection(); const Selection& selection = m_parent.get_selection();
@ -315,7 +308,6 @@ void GLGizmoCut::update_contours()
else else
m_cut_contours.contours.reset(); m_cut_contours.contours.reset();
} }
#endif // ENABLE_SINKING_CONTOURS
} // namespace GUI } // namespace GUI
} // namespace Slic3r } // namespace Slic3r

6
src/slic3r/GUI/Gizmos/GLGizmoCut.hpp
View file

@ -2,11 +2,9 @@
#define slic3r_GLGizmoCut_hpp_ #define slic3r_GLGizmoCut_hpp_
#include "GLGizmoBase.hpp" #include "GLGizmoBase.hpp"
#if ENABLE_SINKING_CONTOURS
#include "slic3r/GUI/GLModel.hpp" #include "slic3r/GUI/GLModel.hpp"
#include "libslic3r/TriangleMesh.hpp" #include "libslic3r/TriangleMesh.hpp"
#include "libslic3r/ObjectID.hpp" #include "libslic3r/ObjectID.hpp"
#endif // ENABLE_SINKING_CONTOURS
namespace Slic3r { namespace Slic3r {
namespace GUI { namespace GUI {
@ -26,7 +24,6 @@ class GLGizmoCut : public GLGizmoBase
bool m_keep_lower{ true }; bool m_keep_lower{ true };
bool m_rotate_lower{ false }; bool m_rotate_lower{ false };
#if ENABLE_SINKING_CONTOURS
struct CutContours struct CutContours
{ {
TriangleMesh mesh; TriangleMesh mesh;
@ -39,7 +36,6 @@ class GLGizmoCut : public GLGizmoBase
}; };
CutContours m_cut_contours; CutContours m_cut_contours;
#endif // ENABLE_SINKING_CONTOURS
public: public:
GLGizmoCut(GLCanvas3D& parent, const std::string& icon_filename, unsigned int sprite_id); GLGizmoCut(GLCanvas3D& parent, const std::string& icon_filename, unsigned int sprite_id);
@ -66,9 +62,7 @@ private:
void perform_cut(const Selection& selection); void perform_cut(const Selection& selection);
double calc_projection(const Linef3& mouse_ray) const; double calc_projection(const Linef3& mouse_ray) const;
BoundingBoxf3 bounding_box() const; BoundingBoxf3 bounding_box() const;
#if ENABLE_SINKING_CONTOURS
void update_contours(); void update_contours();
#endif // ENABLE_SINKING_CONTOURS
}; };
} // namespace GUI } // namespace GUI