diff --git a/src/slic3r/CMakeLists.txt b/src/slic3r/CMakeLists.txt index c8589903e..3744a8ac4 100644 --- a/src/slic3r/CMakeLists.txt +++ b/src/slic3r/CMakeLists.txt @@ -43,6 +43,8 @@ set(SLIC3R_GUI_SOURCES GUI/Gizmos/GLGizmoScale.hpp GUI/Gizmos/GLGizmoSlaSupports.cpp GUI/Gizmos/GLGizmoSlaSupports.hpp + GUI/Gizmos/GLGizmoFdmSupports.cpp + GUI/Gizmos/GLGizmoFdmSupports.hpp GUI/Gizmos/GLGizmoFlatten.cpp GUI/Gizmos/GLGizmoFlatten.hpp GUI/Gizmos/GLGizmoCut.cpp diff --git a/src/slic3r/GUI/GLCanvas3D.cpp b/src/slic3r/GUI/GLCanvas3D.cpp index d3b83057e..718aec736 100644 --- a/src/slic3r/GUI/GLCanvas3D.cpp +++ b/src/slic3r/GUI/GLCanvas3D.cpp @@ -1596,10 +1596,15 @@ void GLCanvas3D::toggle_sla_auxiliaries_visibility(bool visible, const ModelObje void GLCanvas3D::toggle_model_objects_visibility(bool visible, const ModelObject* mo, int instance_idx) { for (GLVolume* vol : m_volumes.volumes) { - if ((mo == nullptr || m_model->objects[vol->composite_id.object_id] == mo) - && (instance_idx == -1 || vol->composite_id.instance_id == instance_idx)) { - vol->is_active = visible; - vol->force_native_color = (instance_idx != -1); + if (vol->composite_id.object_id == 1000) { // wipe tower + vol->is_active = (visible && mo == nullptr); + } + else { + if ((mo == nullptr || m_model->objects[vol->composite_id.object_id] == mo) + && (instance_idx == -1 || vol->composite_id.instance_id == instance_idx)) { + vol->is_active = visible; + vol->force_native_color = (instance_idx != -1); + } } } if (visible && !mo) @@ -4794,7 +4799,7 @@ void GLCanvas3D::_picking_pass() const glsafe(::glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)); - m_camera_clipping_plane = m_gizmos.get_sla_clipping_plane(); + m_camera_clipping_plane = m_gizmos.get_clipping_plane(); if (m_camera_clipping_plane.is_active()) { ::glClipPlane(GL_CLIP_PLANE0, (GLdouble*)m_camera_clipping_plane.get_data()); ::glEnable(GL_CLIP_PLANE0); @@ -4962,7 +4967,7 @@ void GLCanvas3D::_render_objects() const #endif // !ENABLE_THUMBNAIL_GENERATOR glsafe(::glEnable(GL_DEPTH_TEST)); - m_camera_clipping_plane = m_gizmos.get_sla_clipping_plane(); + m_camera_clipping_plane = m_gizmos.get_clipping_plane(); if (m_picking_enabled) { diff --git a/src/slic3r/GUI/Gizmos/GLGizmoFdmSupports.cpp b/src/slic3r/GUI/Gizmos/GLGizmoFdmSupports.cpp new file mode 100644 index 000000000..dfe4bc9a5 --- /dev/null +++ b/src/slic3r/GUI/Gizmos/GLGizmoFdmSupports.cpp @@ -0,0 +1,422 @@ +// Include GLGizmoBase.hpp before I18N.hpp as it includes some libigl code, which overrides our localization "L" macro. +#include "GLGizmoFdmSupports.hpp" +#include "slic3r/GUI/GLCanvas3D.hpp" +#include "slic3r/GUI/Gizmos/GLGizmos.hpp" + +#include <GL/glew.h> + +#include "slic3r/GUI/GUI_App.hpp" +#include "slic3r/GUI/MeshUtils.hpp" +#include "slic3r/GUI/PresetBundle.hpp" + + + +namespace Slic3r { +namespace GUI { + +GLGizmoFdmSupports::GLGizmoFdmSupports(GLCanvas3D& parent, const std::string& icon_filename, unsigned int sprite_id) + : GLGizmoBase(parent, icon_filename, sprite_id) + , m_quadric(nullptr) + , m_its(nullptr) +{ + m_clipping_plane.reset(new ClippingPlane(Vec3d::Zero(), 0.)); + m_quadric = ::gluNewQuadric(); + if (m_quadric != nullptr) + // using GLU_FILL does not work when the instance's transformation + // contains mirroring (normals are reverted) + ::gluQuadricDrawStyle(m_quadric, GLU_FILL); +} + +GLGizmoFdmSupports::~GLGizmoFdmSupports() +{ + if (m_quadric != nullptr) + ::gluDeleteQuadric(m_quadric); +} + +bool GLGizmoFdmSupports::on_init() +{ + m_shortcut_key = WXK_CONTROL_L; + + m_desc["head_diameter"] = _(L("Head diameter")) + ": "; + m_desc["lock_supports"] = _(L("Lock supports under new islands")); + m_desc["remove_selected"] = _(L("Remove selected points")); + m_desc["remove_all"] = _(L("Remove all points")); + m_desc["apply_changes"] = _(L("Apply changes")); + m_desc["discard_changes"] = _(L("Discard changes")); + m_desc["minimal_distance"] = _(L("Minimal points distance")) + ": "; + m_desc["points_density"] = _(L("Support points density")) + ": "; + m_desc["auto_generate"] = _(L("Auto-generate points")); + m_desc["manual_editing"] = _(L("Manual editing")); + m_desc["clipping_of_view"] = _(L("Clipping of view"))+ ": "; + m_desc["reset_direction"] = _(L("Reset direction")); + + return true; +} + +void GLGizmoFdmSupports::set_fdm_support_data(ModelObject* model_object, const Selection& selection) +{ + if (! model_object || selection.is_empty()) { + m_model_object = nullptr; + return; + } + + if (m_model_object != model_object || m_model_object_id != model_object->id()) + m_model_object = model_object; + + m_active_instance = selection.get_instance_idx(); + + if (model_object && selection.is_from_single_instance()) + { + // Cache the bb - it's needed for dealing with the clipping plane quite often + // It could be done inside update_mesh but one has to account for scaling of the instance. + //FIXME calling ModelObject::instance_bounding_box() is expensive! + m_active_instance_bb_radius = m_model_object->instance_bounding_box(m_active_instance).radius(); + + if (is_mesh_update_necessary()) + update_mesh(); + + if (m_state == On) { + m_parent.toggle_model_objects_visibility(false); + m_parent.toggle_model_objects_visibility(true, m_model_object, m_active_instance); + } + else + m_parent.toggle_model_objects_visibility(true, nullptr, -1); + } +} + + + +void GLGizmoFdmSupports::on_render() const +{ + const Selection& selection = m_parent.get_selection(); + + // If current m_model_object does not match selection, ask GLCanvas3D to turn us off + if (m_state == On + && (m_model_object != selection.get_model()->objects[selection.get_object_idx()] + || m_active_instance != selection.get_instance_idx() + || m_model_object_id != m_model_object->id())) { + m_parent.post_event(SimpleEvent(EVT_GLCANVAS_RESETGIZMOS)); + return; + } + + if (! m_its || ! m_mesh) + const_cast<GLGizmoFdmSupports*>(this)->update_mesh(); + + glsafe(::glEnable(GL_BLEND)); + glsafe(::glEnable(GL_DEPTH_TEST)); + + + render_clipping_plane(selection); + + glsafe(::glDisable(GL_BLEND)); +} + + + +void GLGizmoFdmSupports::render_clipping_plane(const Selection& selection) const +{ + if (m_clipping_plane_distance == 0.f) + return; + + // Get transformation of the instance + const GLVolume* vol = selection.get_volume(*selection.get_volume_idxs().begin()); + Geometry::Transformation trafo = vol->get_instance_transformation(); + + + // Now initialize the TMS for the object, perform the cut and save the result. + if (! m_object_clipper) { + m_object_clipper.reset(new MeshClipper); + m_object_clipper->set_mesh(*m_mesh); + } + m_object_clipper->set_plane(*m_clipping_plane); + m_object_clipper->set_transformation(trafo); + + // At this point we have the triangulated cuts for both the object and supports - let's render. + if (! m_object_clipper->get_triangles().empty()) { + ::glPushMatrix(); + ::glColor3f(1.0f, 0.37f, 0.0f); + ::glBegin(GL_TRIANGLES); + for (const Vec3f& point : m_object_clipper->get_triangles()) + ::glVertex3f(point(0), point(1), point(2)); + ::glEnd(); + ::glPopMatrix(); + } +} + + +void GLGizmoFdmSupports::on_render_for_picking() const +{ + +} + + + + +bool GLGizmoFdmSupports::is_point_clipped(const Vec3d& point) const +{ + if (m_clipping_plane_distance == 0.f) + return false; + + Vec3d transformed_point = m_model_object->instances.front()->get_transformation().get_matrix() * point; + return m_clipping_plane->distance(transformed_point) < 0.; +} + + + +bool GLGizmoFdmSupports::is_mesh_update_necessary() const +{ + return ((m_state == On) && (m_model_object != nullptr) && !m_model_object->instances.empty()) + && ((m_model_object->id() != m_model_object_id) || m_its == nullptr); +} + + + +void GLGizmoFdmSupports::update_mesh() +{ + if (! m_model_object) + return; + + wxBusyCursor wait; + // this way we can use that mesh directly. + // This mesh does not account for the possible Z up SLA offset. + m_mesh = &m_model_object->volumes.front()->mesh(); + m_its = &m_mesh->its; + + // If this is different mesh than last time or if the AABB tree is uninitialized, recalculate it. + if (m_model_object_id != m_model_object->id() || ! m_mesh_raycaster) + m_mesh_raycaster.reset(new MeshRaycaster(*m_mesh)); + + m_model_object_id = m_model_object->id(); +} + + + +// Unprojects the mouse position on the mesh and saves hit point and normal of the facet into pos_and_normal +// Return false if no intersection was found, true otherwise. +bool GLGizmoFdmSupports::unproject_on_mesh(const Vec2d& mouse_pos, std::pair<Vec3f, Vec3f>& pos_and_normal) +{ + // if the gizmo doesn't have the V, F structures for igl, calculate them first: + if (! m_mesh_raycaster) + update_mesh(); + + const Camera& camera = m_parent.get_camera(); + const Selection& selection = m_parent.get_selection(); + const GLVolume* volume = selection.get_volume(*selection.get_volume_idxs().begin()); + Geometry::Transformation trafo = volume->get_instance_transformation(); + trafo.set_offset(trafo.get_offset()); + + // The raycaster query + Vec3f hit; + Vec3f normal; + if (m_mesh_raycaster->unproject_on_mesh(mouse_pos, trafo.get_matrix(), camera, hit, normal, m_clipping_plane.get())) { + // Return both the point and the facet normal. + pos_and_normal = std::make_pair(hit, normal); + return true; + } + else + return false; +} + +// Following function is called from GLCanvas3D to inform the gizmo about a mouse/keyboard event. +// The gizmo has an opportunity to react - if it does, it should return true so that the Canvas3D is +// aware that the event was reacted to and stops trying to make different sense of it. If the gizmo +// concludes that the event was not intended for it, it should return false. +bool GLGizmoFdmSupports::gizmo_event(SLAGizmoEventType action, const Vec2d& mouse_position, bool shift_down, bool alt_down, bool control_down) +{ + if (action == SLAGizmoEventType::MouseWheelUp && control_down) { + m_clipping_plane_distance = std::min(1.f, m_clipping_plane_distance + 0.01f); + update_clipping_plane(true); + return true; + } + + if (action == SLAGizmoEventType::MouseWheelDown && control_down) { + m_clipping_plane_distance = std::max(0.f, m_clipping_plane_distance - 0.01f); + update_clipping_plane(true); + return true; + } + + if (action == SLAGizmoEventType::ResetClippingPlane) { + update_clipping_plane(); + return true; + } + + return false; +} + + + + +ClippingPlane GLGizmoFdmSupports::get_fdm_clipping_plane() const +{ + if (!m_model_object || m_state == Off || m_clipping_plane_distance == 0.f) + return ClippingPlane::ClipsNothing(); + else + return ClippingPlane(-m_clipping_plane->get_normal(), m_clipping_plane->get_data()[3]); +} + + + +void GLGizmoFdmSupports::on_render_input_window(float x, float y, float bottom_limit) +{ + if (!m_model_object) + return; + + const float approx_height = m_imgui->scaled(18.0f); + y = std::min(y, bottom_limit - approx_height); + m_imgui->set_next_window_pos(x, y, ImGuiCond_Always); + m_imgui->set_next_window_bg_alpha(0.5f); + m_imgui->begin(on_get_name(), ImGuiWindowFlags_NoMove | ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoCollapse); + + // First calculate width of all the texts that are could possibly be shown. We will decide set the dialog width based on that: + + const float settings_sliders_left = std::max(m_imgui->calc_text_size(m_desc.at("minimal_distance")).x, m_imgui->calc_text_size(m_desc.at("points_density")).x) + m_imgui->scaled(1.f); + const float clipping_slider_left = std::max(m_imgui->calc_text_size(m_desc.at("clipping_of_view")).x, m_imgui->calc_text_size(m_desc.at("reset_direction")).x) + m_imgui->scaled(1.5f); + const float diameter_slider_left = m_imgui->calc_text_size(m_desc.at("head_diameter")).x + m_imgui->scaled(1.f); + const float minimal_slider_width = m_imgui->scaled(4.f); + const float buttons_width_approx = m_imgui->calc_text_size(m_desc.at("apply_changes")).x + m_imgui->calc_text_size(m_desc.at("discard_changes")).x + m_imgui->scaled(1.5f); + const float lock_supports_width_approx = m_imgui->calc_text_size(m_desc.at("lock_supports")).x + m_imgui->scaled(2.f); + + float window_width = minimal_slider_width + std::max(std::max(settings_sliders_left, clipping_slider_left), diameter_slider_left); + window_width = std::max(std::max(window_width, buttons_width_approx), lock_supports_width_approx); + + + // Following is rendered in both editing and non-editing mode: + m_imgui->text(""); + if (m_clipping_plane_distance == 0.f) + m_imgui->text(m_desc.at("clipping_of_view")); + else { + if (m_imgui->button(m_desc.at("reset_direction"))) { + wxGetApp().CallAfter([this](){ + update_clipping_plane(); + }); + } + } + + ImGui::SameLine(clipping_slider_left); + ImGui::PushItemWidth(window_width - clipping_slider_left); + if (ImGui::SliderFloat(" ", &m_clipping_plane_distance, 0.f, 1.f, "%.2f")) + update_clipping_plane(true); + + + m_imgui->end(); +} + +bool GLGizmoFdmSupports::on_is_activable() const +{ + const Selection& selection = m_parent.get_selection(); + + if (wxGetApp().preset_bundle->printers.get_edited_preset().printer_technology() != ptFFF + || !selection.is_from_single_instance()) + return false; + + // Check that none of the selected volumes is outside. Only SLA auxiliaries (supports) are allowed outside. + const Selection::IndicesList& list = selection.get_volume_idxs(); + for (const auto& idx : list) + if (selection.get_volume(idx)->is_outside) + return false; + + return true; +} + +bool GLGizmoFdmSupports::on_is_selectable() const +{ + return (wxGetApp().preset_bundle->printers.get_edited_preset().printer_technology() == ptFFF ); +} + +std::string GLGizmoFdmSupports::on_get_name() const +{ + return (_(L("FDM Support Editing")) + " [L]").ToUTF8().data(); +} + + + +void GLGizmoFdmSupports::on_set_state() +{ + if (m_state == On) + std::cout << "zapinam se..." << std::endl; + else + std::cout << "vypinam se..." << std::endl; + return; + // m_model_object pointer can be invalid (for instance because of undo/redo action), + // we should recover it from the object id + m_model_object = nullptr; + for (const auto mo : wxGetApp().model().objects) { + if (mo->id() == m_model_object_id) { + m_model_object = mo; + break; + } + } + + if (m_state == m_old_state) + return; + + if (m_state == On && m_old_state != On) { // the gizmo was just turned on + Plater::TakeSnapshot snapshot(wxGetApp().plater(), _(L("SLA gizmo turned on"))); + if (is_mesh_update_necessary()) + update_mesh(); + + // we'll now reload support points: + if (m_model_object) + ;// !!!! reload_cache(); + + m_parent.toggle_model_objects_visibility(false); + if (m_model_object) + m_parent.toggle_model_objects_visibility(true, m_model_object, m_active_instance); + } + if (m_state == Off && m_old_state != Off) { // the gizmo was just turned Off + // we are actually shutting down + Plater::TakeSnapshot snapshot(wxGetApp().plater(), _(L("FDM gizmo turned off"))); + m_parent.toggle_model_objects_visibility(true); + m_clipping_plane_distance = 0.f; + // Release clippers and the AABB raycaster. + m_its = nullptr; + m_object_clipper.reset(); + m_mesh_raycaster.reset(); + } + m_old_state = m_state; +} + + + +void GLGizmoFdmSupports::on_start_dragging() +{ + +} + + +void GLGizmoFdmSupports::on_stop_dragging() +{ + +} + + + +void GLGizmoFdmSupports::on_load(cereal::BinaryInputArchive& ar) +{ + +} + + + +void GLGizmoFdmSupports::on_save(cereal::BinaryOutputArchive& ar) const +{ + +} + + +void GLGizmoFdmSupports::update_clipping_plane(bool keep_normal) const +{ + Vec3d normal = (keep_normal && m_clipping_plane->get_normal() != Vec3d::Zero() ? + m_clipping_plane->get_normal() : -m_parent.get_camera().get_dir_forward()); + + const Vec3d& center = m_model_object->instances[m_active_instance]->get_offset(); + float dist = normal.dot(center); + *m_clipping_plane = ClippingPlane(normal, (dist - (-m_active_instance_bb_radius) - m_clipping_plane_distance * 2*m_active_instance_bb_radius)); + m_parent.set_as_dirty(); +} + + + + +} // namespace GUI +} // namespace Slic3r diff --git a/src/slic3r/GUI/Gizmos/GLGizmoFdmSupports.hpp b/src/slic3r/GUI/Gizmos/GLGizmoFdmSupports.hpp new file mode 100644 index 000000000..02a0877ee --- /dev/null +++ b/src/slic3r/GUI/Gizmos/GLGizmoFdmSupports.hpp @@ -0,0 +1,87 @@ +#ifndef slic3r_GLGizmoFdmSupports_hpp_ +#define slic3r_GLGizmoFdmSupports_hpp_ + +#include "GLGizmoBase.hpp" + +//#include "libslic3r/SLA/SLACommon.hpp" +//#include <wx/dialog.h> + +#include <cereal/types/vector.hpp> + + +namespace Slic3r { +namespace GUI { + +class ClippingPlane; +class MeshClipper; +class MeshRaycaster; +enum class SLAGizmoEventType : unsigned char; + +class GLGizmoFdmSupports : public GLGizmoBase +{ +private: + ModelObject* m_model_object = nullptr; + ObjectID m_model_object_id = 0; + int m_active_instance = -1; + float m_active_instance_bb_radius; // to cache the bb + bool unproject_on_mesh(const Vec2d& mouse_pos, std::pair<Vec3f, Vec3f>& pos_and_normal); + + + GLUquadricObj* m_quadric; + + std::unique_ptr<MeshRaycaster> m_mesh_raycaster; + const TriangleMesh* m_mesh; + const indexed_triangle_set* m_its; + mutable std::vector<Vec2f> m_triangles; + + +public: + GLGizmoFdmSupports(GLCanvas3D& parent, const std::string& icon_filename, unsigned int sprite_id); + ~GLGizmoFdmSupports() override; + void set_fdm_support_data(ModelObject* model_object, const Selection& selection); + bool gizmo_event(SLAGizmoEventType action, const Vec2d& mouse_position, bool shift_down, bool alt_down, bool control_down); + ClippingPlane get_fdm_clipping_plane() const; + + +private: + bool on_init() override; + void on_render() const override; + void on_render_for_picking() const override; + + void render_clipping_plane(const Selection& selection) const; + bool is_mesh_update_necessary() const; + void update_mesh(); + + float m_clipping_plane_distance = 0.f; + std::unique_ptr<ClippingPlane> m_clipping_plane; + + // This map holds all translated description texts, so they can be easily referenced during layout calculations + // etc. When language changes, GUI is recreated and this class constructed again, so the change takes effect. + std::map<std::string, wxString> m_desc; + + bool m_wait_for_up_event = false; + EState m_old_state = Off; // to be able to see that the gizmo has just been closed (see on_set_state) + + mutable std::unique_ptr<MeshClipper> m_object_clipper; + + + bool is_point_clipped(const Vec3d& point) const; + void update_clipping_plane(bool keep_normal = false) const; + +protected: + void on_set_state() override; + void on_start_dragging() override; + void on_stop_dragging() override; + void on_render_input_window(float x, float y, float bottom_limit) override; + std::string on_get_name() const override; + bool on_is_activable() const override; + bool on_is_selectable() const override; + void on_load(cereal::BinaryInputArchive& ar) override; + void on_save(cereal::BinaryOutputArchive& ar) const override; +}; + + +} // namespace GUI +} // namespace Slic3r + +#endif // slic3r_GLGizmoFdmSupports_hpp_ diff --git a/src/slic3r/GUI/Gizmos/GLGizmoSlaSupports.hpp b/src/slic3r/GUI/Gizmos/GLGizmoSlaSupports.hpp index bd48ecd65..b671af52c 100644 --- a/src/slic3r/GUI/Gizmos/GLGizmoSlaSupports.hpp +++ b/src/slic3r/GUI/Gizmos/GLGizmoSlaSupports.hpp @@ -32,8 +32,6 @@ private: const float RenderPointScale = 1.f; GLUquadricObj* m_quadric; - typedef Eigen::Map<const Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor | Eigen::DontAlign>> MapMatrixXfUnaligned; - typedef Eigen::Map<const Eigen::Matrix<int, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor | Eigen::DontAlign>> MapMatrixXiUnaligned; //std::unique_ptr<MeshRaycaster> m_mesh_raycaster; //const TriangleMesh* m_mesh; @@ -142,7 +140,6 @@ private: void auto_generate(); void switch_to_editing_mode(); void disable_editing_mode(); - void reset_clipping_plane_normal() const; protected: void on_set_state() override; diff --git a/src/slic3r/GUI/Gizmos/GLGizmos.hpp b/src/slic3r/GUI/Gizmos/GLGizmos.hpp index 9f97c42b4..e8e73959c 100644 --- a/src/slic3r/GUI/Gizmos/GLGizmos.hpp +++ b/src/slic3r/GUI/Gizmos/GLGizmos.hpp @@ -31,6 +31,7 @@ enum class SLAGizmoEventType : unsigned char { #include "slic3r/GUI/Gizmos/GLGizmoRotate.hpp" #include "slic3r/GUI/Gizmos/GLGizmoFlatten.hpp" #include "slic3r/GUI/Gizmos/GLGizmoSlaSupports.hpp" +#include "slic3r/GUI/Gizmos/GLGizmoFdmSupports.hpp" #include "slic3r/GUI/Gizmos/GLGizmoCut.hpp" #include "slic3r/GUI/Gizmos/GLGizmoHollow.hpp" diff --git a/src/slic3r/GUI/Gizmos/GLGizmosManager.cpp b/src/slic3r/GUI/Gizmos/GLGizmosManager.cpp index d465196f3..17cc6ff0c 100644 --- a/src/slic3r/GUI/Gizmos/GLGizmosManager.cpp +++ b/src/slic3r/GUI/Gizmos/GLGizmosManager.cpp @@ -94,11 +94,13 @@ bool GLGizmosManager::init() m_gizmos.emplace_back(new GLGizmoCut(m_parent, "cut.svg", 4)); m_gizmos.emplace_back(new GLGizmoHollow(m_parent, "hollow.svg", 5)); m_gizmos.emplace_back(new GLGizmoSlaSupports(m_parent, "sla_supports.svg", 6)); + m_gizmos.emplace_back(new GLGizmoFdmSupports(m_parent, "sla_supports.svg", 7)); m_common_gizmos_data.reset(new CommonGizmosData()); dynamic_cast<GLGizmoHollow*>(m_gizmos[Hollow].get())->set_common_data_ptr(m_common_gizmos_data.get()); dynamic_cast<GLGizmoSlaSupports*>(m_gizmos[SlaSupports].get())->set_common_data_ptr(m_common_gizmos_data.get()); + for (auto& gizmo : m_gizmos) { if (! gizmo->init()) { m_gizmos.clear(); @@ -204,6 +206,7 @@ void GLGizmosManager::update_data() ModelObject* model_object = selection.get_model()->objects[selection.get_object_idx()]; set_flattening_data(model_object); set_sla_support_data(model_object); + set_fdm_support_data(model_object); } else if (selection.is_single_volume() || selection.is_single_modifier()) { @@ -212,6 +215,7 @@ void GLGizmosManager::update_data() set_rotation(Vec3d::Zero()); set_flattening_data(nullptr); set_sla_support_data(nullptr); + set_fdm_support_data(nullptr); } else if (is_wipe_tower) { @@ -220,6 +224,7 @@ void GLGizmosManager::update_data() set_rotation(Vec3d(0., 0., (M_PI/180.) * dynamic_cast<const ConfigOptionFloat*>(config.option("wipe_tower_rotation_angle"))->value)); set_flattening_data(nullptr); set_sla_support_data(nullptr); + set_fdm_support_data(nullptr); } else { @@ -227,6 +232,7 @@ void GLGizmosManager::update_data() set_rotation(Vec3d::Zero()); set_flattening_data(selection.is_from_single_object() ? selection.get_model()->objects[selection.get_object_idx()] : nullptr); set_sla_support_data(nullptr); + set_fdm_support_data(nullptr); } } @@ -366,6 +372,14 @@ void GLGizmosManager::set_sla_support_data(ModelObject* model_object) gizmo_hollow->set_sla_support_data(model_object, m_parent.get_selection()); } +void GLGizmosManager::set_fdm_support_data(ModelObject* model_object) +{ + if (!m_enabled || m_gizmos.empty()) + return; + + dynamic_cast<GLGizmoFdmSupports*>(m_gizmos[FdmSupports].get())->set_fdm_support_data(model_object, m_parent.get_selection()); +} + // Returns true if the gizmo used the event to do something, false otherwise. bool GLGizmosManager::gizmo_event(SLAGizmoEventType action, const Vec2d& mouse_position, bool shift_down, bool alt_down, bool control_down) { @@ -379,15 +393,17 @@ bool GLGizmosManager::gizmo_event(SLAGizmoEventType action, const Vec2d& mouse_p return false; } -ClippingPlane GLGizmosManager::get_sla_clipping_plane() const +ClippingPlane GLGizmosManager::get_clipping_plane() const { - if (!m_enabled || (m_current != SlaSupports && m_current != Hollow) || m_gizmos.empty()) + if (!m_enabled || (m_current != SlaSupports && m_current != Hollow && m_current != FdmSupports) || m_gizmos.empty()) return ClippingPlane::ClipsNothing(); if (m_current == SlaSupports) return dynamic_cast<GLGizmoSlaSupports*>(m_gizmos[SlaSupports].get())->get_sla_clipping_plane(); - else + else if (m_current == Hollow) return dynamic_cast<GLGizmoHollow*>(m_gizmos[Hollow].get())->get_sla_clipping_plane(); + else + return dynamic_cast<GLGizmoFdmSupports*>(m_gizmos[FdmSupports].get())->get_fdm_clipping_plane(); } bool GLGizmosManager::wants_reslice_supports_on_undo() const @@ -407,6 +423,7 @@ void GLGizmosManager::render_current_gizmo() const void GLGizmosManager::render_current_gizmo_for_picking_pass() const { if (! m_enabled || m_current == Undefined) + return; m_gizmos[m_current]->render_for_picking(); diff --git a/src/slic3r/GUI/Gizmos/GLGizmosManager.hpp b/src/slic3r/GUI/Gizmos/GLGizmosManager.hpp index 2eac470f9..52e68e4ef 100644 --- a/src/slic3r/GUI/Gizmos/GLGizmosManager.hpp +++ b/src/slic3r/GUI/Gizmos/GLGizmosManager.hpp @@ -64,6 +64,7 @@ public: Cut, Hollow, SlaSupports, + FdmSupports, Undefined }; @@ -197,8 +198,11 @@ public: void set_flattening_data(const ModelObject* model_object); void set_sla_support_data(ModelObject* model_object); + + void set_fdm_support_data(ModelObject* model_object); + bool gizmo_event(SLAGizmoEventType action, const Vec2d& mouse_position = Vec2d::Zero(), bool shift_down = false, bool alt_down = false, bool control_down = false); - ClippingPlane get_sla_clipping_plane() const; + ClippingPlane get_clipping_plane() const; bool wants_reslice_supports_on_undo() const; void render_current_gizmo() const;