From df47ba7122cd3ed9f11d4eebdf7839b9300828bd Mon Sep 17 00:00:00 2001 From: enricoturri1966 Date: Mon, 13 Jun 2022 13:09:24 +0200 Subject: [PATCH] Tech ENABLE_RAYCAST_PICKING - Raytraced picking of gizmos - Move Gizmo --- src/slic3r/GUI/3DBed.cpp | 2 +- src/slic3r/GUI/CoordAxes.cpp | 5 +- src/slic3r/GUI/GLCanvas3D.cpp | 22 ++- src/slic3r/GUI/GLCanvas3D.hpp | 15 +- src/slic3r/GUI/Gizmos/GLGizmoBase.cpp | 151 ++++++++++++++++++- src/slic3r/GUI/Gizmos/GLGizmoBase.hpp | 57 ++++++- src/slic3r/GUI/Gizmos/GLGizmoCut.cpp | 4 +- src/slic3r/GUI/Gizmos/GLGizmoCut.hpp | 2 + src/slic3r/GUI/Gizmos/GLGizmoFlatten.cpp | 2 + src/slic3r/GUI/Gizmos/GLGizmoFlatten.hpp | 2 + src/slic3r/GUI/Gizmos/GLGizmoHollow.cpp | 2 + src/slic3r/GUI/Gizmos/GLGizmoHollow.hpp | 2 + src/slic3r/GUI/Gizmos/GLGizmoMove.cpp | 13 ++ src/slic3r/GUI/Gizmos/GLGizmoMove.hpp | 5 + src/slic3r/GUI/Gizmos/GLGizmoPainterBase.hpp | 3 + src/slic3r/GUI/Gizmos/GLGizmoRotate.cpp | 2 + src/slic3r/GUI/Gizmos/GLGizmoRotate.hpp | 4 + src/slic3r/GUI/Gizmos/GLGizmoScale.cpp | 2 + src/slic3r/GUI/Gizmos/GLGizmoScale.hpp | 2 + src/slic3r/GUI/Gizmos/GLGizmoSimplify.hpp | 4 +- src/slic3r/GUI/Gizmos/GLGizmoSlaSupports.cpp | 2 + src/slic3r/GUI/Gizmos/GLGizmoSlaSupports.hpp | 2 + src/slic3r/GUI/Gizmos/GLGizmosCommon.hpp | 2 +- src/slic3r/GUI/Gizmos/GLGizmosManager.cpp | 10 ++ src/slic3r/GUI/Gizmos/GLGizmosManager.hpp | 2 + src/slic3r/GUI/SceneRaycaster.cpp | 74 +++++---- src/slic3r/GUI/SceneRaycaster.hpp | 11 +- 27 files changed, 330 insertions(+), 74 deletions(-) diff --git a/src/slic3r/GUI/3DBed.cpp b/src/slic3r/GUI/3DBed.cpp index 18451960a..0c28ad54a 100644 --- a/src/slic3r/GUI/3DBed.cpp +++ b/src/slic3r/GUI/3DBed.cpp @@ -253,7 +253,7 @@ bool Bed3D::set_shape(const Pointfs& bed_shape, const double max_print_height, c #if ENABLE_RAYCAST_PICKING // unregister from picking - wxGetApp().plater()->canvas3D()->remove_all_picking_raycasters(SceneRaycaster::EType::Bed); + wxGetApp().plater()->canvas3D()->remove_raycasters_for_picking(SceneRaycaster::EType::Bed); #endif // ENABLE_RAYCAST_PICKING // Let the calee to update the UI. diff --git a/src/slic3r/GUI/CoordAxes.cpp b/src/slic3r/GUI/CoordAxes.cpp index b1c3ba9e0..1ac234d5b 100644 --- a/src/slic3r/GUI/CoordAxes.cpp +++ b/src/slic3r/GUI/CoordAxes.cpp @@ -29,10 +29,11 @@ void CoordAxes::render(float emission_factor) #if ENABLE_LEGACY_OPENGL_REMOVAL auto render_axis = [this](GLShaderProgram& shader, const Transform3d& transform) { const Camera& camera = wxGetApp().plater()->get_camera(); - const Transform3d matrix = camera.get_view_matrix() * transform; + const Transform3d& view_matrix = camera.get_view_matrix(); + const Transform3d matrix = view_matrix * transform; shader.set_uniform("view_model_matrix", matrix); shader.set_uniform("projection_matrix", camera.get_projection_matrix()); - shader.set_uniform("normal_matrix", (Matrix3d)matrix.matrix().block(0, 0, 3, 3).inverse().transpose()); + shader.set_uniform("view_normal_matrix", (Matrix3d)(view_matrix.matrix().block(0, 0, 3, 3) * transform.matrix().block(0, 0, 3, 3).inverse().transpose())); m_arrow.render(); #else auto render_axis = [this](const Transform3f& transform) { diff --git a/src/slic3r/GUI/GLCanvas3D.cpp b/src/slic3r/GUI/GLCanvas3D.cpp index ed291fdf6..c40d05aa7 100644 --- a/src/slic3r/GUI/GLCanvas3D.cpp +++ b/src/slic3r/GUI/GLCanvas3D.cpp @@ -1958,6 +1958,12 @@ void GLCanvas3D::reload_scene(bool refresh_immediately, bool force_full_scene_re m_hover_volume_idxs.clear(); +#if ENABLE_RAYCAST_PICKING + GLGizmoBase* curr_gizmo = m_gizmos.get_current(); + if (curr_gizmo != nullptr) + curr_gizmo->unregister_raycasters_for_picking(); +#endif // ENABLE_RAYCAST_PICKING + struct ModelVolumeState { ModelVolumeState(const GLVolume* volume) : model_volume(nullptr), geometry_id(volume->geometry_id), volume_idx(-1) {} @@ -2403,11 +2409,16 @@ void GLCanvas3D::reload_scene(bool refresh_immediately, bool force_full_scene_re #if ENABLE_RAYCAST_PICKING // refresh volume raycasters for picking - m_scene_raycaster.reset(SceneRaycaster::EType::Volume); + m_scene_raycaster.remove_raycasters(SceneRaycaster::EType::Volume); for (size_t i = 0; i < m_volumes.volumes.size(); ++i) { assert(m_volumes.volumes[i]->mesh_raycaster != nullptr); add_raycaster_for_picking(SceneRaycaster::EType::Volume, i, *m_volumes.volumes[i]->mesh_raycaster, m_volumes.volumes[i]->world_matrix()); } + + // refresh gizmo elements raycasters for picking + m_scene_raycaster.remove_raycasters(SceneRaycaster::EType::Gizmo); + if (curr_gizmo != nullptr && !m_selection.is_empty()) + curr_gizmo->register_raycasters_for_picking(); #endif // ENABLE_RAYCAST_PICKING // and force this canvas to be redrawn. @@ -5432,9 +5443,14 @@ void GLCanvas3D::_refresh_if_shown_on_screen() #if ENABLE_RAYCAST_PICKING void GLCanvas3D::_picking_pass() { - if (!m_picking_enabled || m_mouse.dragging || m_mouse.position == Vec2d(DBL_MAX, DBL_MAX)) + if (!m_picking_enabled || m_mouse.dragging || m_mouse.position == Vec2d(DBL_MAX, DBL_MAX)) { + ImGuiWrapper& imgui = *wxGetApp().imgui(); + imgui.begin(std::string("Hit result"), ImGuiWindowFlags_AlwaysAutoResize); + imgui.text("Picking disabled"); + imgui.end(); return; - + } + m_hover_volume_idxs.clear(); const ClippingPlane clipping_plane = m_gizmos.get_clipping_plane().inverted_normal(); diff --git a/src/slic3r/GUI/GLCanvas3D.hpp b/src/slic3r/GUI/GLCanvas3D.hpp index a39771b40..da3c78044 100644 --- a/src/slic3r/GUI/GLCanvas3D.hpp +++ b/src/slic3r/GUI/GLCanvas3D.hpp @@ -663,11 +663,18 @@ public: void post_event(wxEvent &&event); #if ENABLE_RAYCAST_PICKING - int add_raycaster_for_picking(SceneRaycaster::EType type, int id, const MeshRaycaster& raycaster, const Transform3d& trafo) { - return m_scene_raycaster.add_raycaster(type, id, raycaster, trafo); + void add_raycaster_for_picking(SceneRaycaster::EType type, PickingId id, const MeshRaycaster& raycaster, const Transform3d& trafo) { + m_scene_raycaster.add_raycaster(type, id, raycaster, trafo); } - void remove_all_picking_raycasters(SceneRaycaster::EType type) { - m_scene_raycaster.reset(type); + void remove_raycasters_for_picking(SceneRaycaster::EType type, PickingId id) { + m_scene_raycaster.remove_raycasters(type, id); + } + void remove_raycasters_for_picking(SceneRaycaster::EType type) { + m_scene_raycaster.remove_raycasters(type); + } + + void set_raycaster_gizmos_on_top(bool value) { + m_scene_raycaster.set_gizmos_on_top(value); } #endif // ENABLE_RAYCAST_PICKING diff --git a/src/slic3r/GUI/Gizmos/GLGizmoBase.cpp b/src/slic3r/GUI/Gizmos/GLGizmoBase.cpp index ba6595a84..eb629c5c6 100644 --- a/src/slic3r/GUI/Gizmos/GLGizmoBase.cpp +++ b/src/slic3r/GUI/Gizmos/GLGizmoBase.cpp @@ -18,16 +18,29 @@ const float GLGizmoBase::Grabber::SizeFactor = 0.05f; const float GLGizmoBase::Grabber::MinHalfSize = 1.5f; const float GLGizmoBase::Grabber::DraggingScaleFactor = 1.25f; +#if ENABLE_RAYCAST_PICKING +PickingModel GLGizmoBase::Grabber::s_cube; +PickingModel GLGizmoBase::Grabber::s_cone; +#else GLModel GLGizmoBase::Grabber::s_cube; GLModel GLGizmoBase::Grabber::s_cone; +#endif // ENABLE_RAYCAST_PICKING GLGizmoBase::Grabber::~Grabber() { +#if ENABLE_RAYCAST_PICKING + if (s_cube.model.is_initialized()) + s_cube.model.reset(); + + if (s_cone.model.is_initialized()) + s_cone.model.reset(); +#else if (s_cube.is_initialized()) s_cube.reset(); if (s_cone.is_initialized()) s_cone.reset(); +#endif // ENABLE_RAYCAST_PICKING } float GLGizmoBase::Grabber::get_half_size(float size) const @@ -40,6 +53,21 @@ float GLGizmoBase::Grabber::get_dragging_half_size(float size) const return get_half_size(size) * DraggingScaleFactor; } +#if ENABLE_RAYCAST_PICKING +void GLGizmoBase::Grabber::register_raycasters_for_picking(int id) +{ + picking_id = id; + assert(elements_registered_for_picking == false); +} + +void GLGizmoBase::Grabber::unregister_raycasters_for_picking() +{ + wxGetApp().plater()->canvas3D()->remove_raycasters_for_picking(SceneRaycaster::EType::Gizmo, picking_id); + picking_id = -1; + elements_registered_for_picking = false; +} +#endif // ENABLE_RAYCAST_PICKING + void GLGizmoBase::Grabber::render(float size, const ColorRGBA& render_color, bool picking) { #if ENABLE_LEGACY_OPENGL_REMOVAL @@ -48,35 +76,69 @@ void GLGizmoBase::Grabber::render(float size, const ColorRGBA& render_color, boo return; #endif // ENABLE_LEGACY_OPENGL_REMOVAL +#if ENABLE_RAYCAST_PICKING + if (!s_cube.model.is_initialized()) { +#else if (!s_cube.is_initialized()) { +#endif // ENABLE_RAYCAST_PICKING // This cannot be done in constructor, OpenGL is not yet // initialized at that point (on Linux at least). indexed_triangle_set its = its_make_cube(1.0, 1.0, 1.0); its_translate(its, -0.5f * Vec3f::Ones()); #if ENABLE_LEGACY_OPENGL_REMOVAL +#if ENABLE_RAYCAST_PICKING + s_cube.model.init_from(its); + s_cube.mesh_raycaster = std::make_unique(std::make_shared(std::move(its))); +#else s_cube.init_from(its); +#endif // ENABLE_RAYCAST_PICKING #else s_cube.init_from(its, BoundingBoxf3{ { -0.5, -0.5, -0.5 }, { 0.5, 0.5, 0.5 } }); #endif // ENABLE_LEGACY_OPENGL_REMOVAL } +#if ENABLE_RAYCAST_PICKING + if (!s_cone.model.is_initialized()) { + indexed_triangle_set its = its_make_cone(0.375, 1.5, double(PI) / 18.0); + s_cone.model.init_from(its); + s_cone.mesh_raycaster = std::make_unique(std::make_shared(std::move(its))); + } +#else if (!s_cone.is_initialized()) s_cone.init_from(its_make_cone(0.375, 1.5, double(PI) / 18.0)); +#endif // ENABLE_RAYCAST_PICKING const float half_size = dragging ? get_dragging_half_size(size) : get_half_size(size); #if ENABLE_LEGACY_OPENGL_REMOVAL +#if ENABLE_RAYCAST_PICKING + s_cube.model.set_color(render_color); + s_cone.model.set_color(render_color); +#else s_cube.set_color(render_color); s_cone.set_color(render_color); +#endif // ENABLE_RAYCAST_PICKING const Camera& camera = wxGetApp().plater()->get_camera(); + shader->set_uniform("projection_matrix", camera.get_projection_matrix()); +#if ENABLE_RAYCAST_PICKING + const Transform3d& view_matrix = camera.get_view_matrix(); + const Matrix3d view_matrix_no_offset = view_matrix.matrix().block(0, 0, 3, 3); + std::vector elements_matrices(7, Transform3d::Identity()); // 1 + count of EGrabberExtensions == 7 + elements_matrices[0] = matrix * Geometry::assemble_transform(center, angles, 2.0 * half_size * Vec3d::Ones()); + Transform3d view_model_matrix = view_matrix * elements_matrices[0]; +#else const Transform3d& view_matrix = camera.get_view_matrix(); const Transform3d model_matrix = matrix * Geometry::assemble_transform(center, angles, 2.0 * half_size * Vec3d::Ones()); const Transform3d view_model_matrix = view_matrix * model_matrix; +#endif // ENABLE_RAYCAST_PICKING shader->set_uniform("view_model_matrix", view_model_matrix); - shader->set_uniform("projection_matrix", camera.get_projection_matrix()); +#if ENABLE_RAYCAST_PICKING + Matrix3d view_normal_matrix = view_matrix_no_offset * elements_matrices[0].matrix().block(0, 0, 3, 3).inverse().transpose(); +#else const Matrix3d view_normal_matrix = view_matrix.matrix().block(0, 0, 3, 3) * model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose(); +#endif // ENABLE_RAYCAST_PICKING shader->set_uniform("view_normal_matrix", view_normal_matrix); #else s_cube.set_color(-1, render_color); @@ -88,32 +150,74 @@ void GLGizmoBase::Grabber::render(float size, const ColorRGBA& render_color, boo glsafe(::glRotated(Geometry::rad2deg(angles.x()), 1.0, 0.0, 0.0)); glsafe(::glScaled(2.0 * half_size, 2.0 * half_size, 2.0 * half_size)); #endif // ENABLE_LEGACY_OPENGL_REMOVAL +#if ENABLE_RAYCAST_PICKING + s_cube.model.render(); +#else s_cube.render(); +#endif // ENABLE_RAYCAST_PICKING + + auto render_extension = [&view_matrix, &view_matrix_no_offset, shader](const Transform3d& matrix) { + const Transform3d view_model_matrix = view_matrix * matrix; + shader->set_uniform("view_model_matrix", view_model_matrix); + const Matrix3d view_normal_matrix = view_matrix_no_offset * matrix.matrix().block(0, 0, 3, 3).inverse().transpose(); + shader->set_uniform("view_normal_matrix", view_normal_matrix); + s_cone.model.render(); + }; #if ENABLE_LEGACY_OPENGL_REMOVAL if ((int(extensions) & int(GLGizmoBase::EGrabberExtension::PosX)) != 0) { +#if ENABLE_RAYCAST_PICKING + elements_matrices[1] = elements_matrices[0] * Geometry::assemble_transform(Vec3d::UnitX(), Vec3d(0.0, 0.5 * double(PI), 0.0)); + render_extension(elements_matrices[1]); +#else shader->set_uniform("view_model_matrix", view_model_matrix * Geometry::assemble_transform(Vec3d::UnitX(), Vec3d(0.0, 0.5 * double(PI), 0.0))); s_cone.render(); +#endif // ENABLE_RAYCAST_PICKING } if ((int(extensions) & int(GLGizmoBase::EGrabberExtension::NegX)) != 0) { +#if ENABLE_RAYCAST_PICKING + elements_matrices[2] = elements_matrices[0] * Geometry::assemble_transform(-Vec3d::UnitX(), Vec3d(0.0, -0.5 * double(PI), 0.0)); + render_extension(elements_matrices[2]); +#else shader->set_uniform("view_model_matrix", view_model_matrix * Geometry::assemble_transform(-Vec3d::UnitX(), Vec3d(0.0, -0.5 * double(PI), 0.0))); s_cone.render(); +#endif // ENABLE_RAYCAST_PICKING } if ((int(extensions) & int(GLGizmoBase::EGrabberExtension::PosY)) != 0) { +#if ENABLE_RAYCAST_PICKING + elements_matrices[3] = elements_matrices[0] * Geometry::assemble_transform(Vec3d::UnitY(), Vec3d(-0.5 * double(PI), 0.0, 0.0)); + render_extension(elements_matrices[3]); +#else shader->set_uniform("view_model_matrix", view_model_matrix * Geometry::assemble_transform(Vec3d::UnitY(), Vec3d(-0.5 * double(PI), 0.0, 0.0))); s_cone.render(); +#endif // ENABLE_RAYCAST_PICKING } if ((int(extensions) & int(GLGizmoBase::EGrabberExtension::NegY)) != 0) { +#if ENABLE_RAYCAST_PICKING + elements_matrices[4] = elements_matrices[0] * Geometry::assemble_transform(-Vec3d::UnitY(), Vec3d(0.5 * double(PI), 0.0, 0.0)); + render_extension(elements_matrices[4]); +#else shader->set_uniform("view_model_matrix", view_model_matrix * Geometry::assemble_transform(-Vec3d::UnitY(), Vec3d(0.5 * double(PI), 0.0, 0.0))); s_cone.render(); +#endif // ENABLE_RAYCAST_PICKING } if ((int(extensions) & int(GLGizmoBase::EGrabberExtension::PosZ)) != 0) { +#if ENABLE_RAYCAST_PICKING + elements_matrices[5] = elements_matrices[0] * Geometry::assemble_transform(Vec3d::UnitZ()); + render_extension(elements_matrices[5]); +#else shader->set_uniform("view_model_matrix", view_model_matrix * Geometry::assemble_transform(Vec3d::UnitZ())); s_cone.render(); +#endif // ENABLE_RAYCAST_PICKING } if ((int(extensions) & int(GLGizmoBase::EGrabberExtension::NegZ)) != 0) { +#if ENABLE_RAYCAST_PICKING + elements_matrices[6] = elements_matrices[0] * Geometry::assemble_transform(-Vec3d::UnitZ(), Vec3d(double(PI), 0.0, 0.0)); + render_extension(elements_matrices[6]); +#else shader->set_uniform("view_model_matrix", view_model_matrix * Geometry::assemble_transform(-Vec3d::UnitZ(), Vec3d(double(PI), 0.0, 0.0))); s_cone.render(); +#endif // ENABLE_RAYCAST_PICKING } #else if ((int(extensions) & int(GLGizmoBase::EGrabberExtension::PosX)) != 0) { @@ -161,20 +265,33 @@ void GLGizmoBase::Grabber::render(float size, const ColorRGBA& render_color, boo #if !ENABLE_LEGACY_OPENGL_REMOVAL glsafe(::glPopMatrix()); #endif // !ENABLE_LEGACY_OPENGL_REMOVAL + +#if ENABLE_RAYCAST_PICKING + if (!elements_registered_for_picking) { + GLCanvas3D& canvas = *wxGetApp().plater()->canvas3D(); + canvas.add_raycaster_for_picking(SceneRaycaster::EType::Gizmo, picking_id, *s_cube.mesh_raycaster, elements_matrices[0]); + if ((int(extensions) & int(GLGizmoBase::EGrabberExtension::PosX)) != 0) + canvas.add_raycaster_for_picking(SceneRaycaster::EType::Gizmo, picking_id, *s_cone.mesh_raycaster, elements_matrices[1]); + if ((int(extensions) & int(GLGizmoBase::EGrabberExtension::NegX)) != 0) + canvas.add_raycaster_for_picking(SceneRaycaster::EType::Gizmo, picking_id, *s_cone.mesh_raycaster, elements_matrices[2]); + if ((int(extensions) & int(GLGizmoBase::EGrabberExtension::PosY)) != 0) + canvas.add_raycaster_for_picking(SceneRaycaster::EType::Gizmo, picking_id, *s_cone.mesh_raycaster, elements_matrices[3]); + if ((int(extensions) & int(GLGizmoBase::EGrabberExtension::NegY)) != 0) + canvas.add_raycaster_for_picking(SceneRaycaster::EType::Gizmo, picking_id, *s_cone.mesh_raycaster, elements_matrices[4]); + if ((int(extensions) & int(GLGizmoBase::EGrabberExtension::PosZ)) != 0) + canvas.add_raycaster_for_picking(SceneRaycaster::EType::Gizmo, picking_id, *s_cone.mesh_raycaster, elements_matrices[5]); + if ((int(extensions) & int(GLGizmoBase::EGrabberExtension::NegZ)) != 0) + canvas.add_raycaster_for_picking(SceneRaycaster::EType::Gizmo, picking_id, *s_cone.mesh_raycaster, elements_matrices[6]); + elements_registered_for_picking = true; + } +#endif // ENABLE_RAYCAST_PICKING } GLGizmoBase::GLGizmoBase(GLCanvas3D& parent, const std::string& icon_filename, unsigned int sprite_id) : m_parent(parent) - , m_group_id(-1) - , m_state(Off) - , m_shortcut_key(0) , m_icon_filename(icon_filename) , m_sprite_id(sprite_id) - , m_hover_id(-1) - , m_dragging(false) , m_imgui(wxGetApp().imgui()) - , m_first_input_window_render(true) - , m_dirty(false) { } @@ -198,6 +315,22 @@ bool GLGizmoBase::update_items_state() return res; } +#if ENABLE_RAYCAST_PICKING +void GLGizmoBase::register_grabbers_for_picking() +{ + for (size_t i = 0; i < m_grabbers.size(); ++i) { + m_grabbers[i].register_raycasters_for_picking(i); + } +} + +void GLGizmoBase::unregister_grabbers_for_picking() +{ + for (size_t i = 0; i < m_grabbers.size(); ++i) { + m_grabbers[i].unregister_raycasters_for_picking(); + } +} +#endif // ENABLE_RAYCAST_PICKING + ColorRGBA GLGizmoBase::picking_color_component(unsigned int id) const { id = BASE_ID - id; @@ -226,6 +359,7 @@ void GLGizmoBase::render_grabbers(float size) const shader->stop_using(); } +#if !ENABLE_RAYCAST_PICKING void GLGizmoBase::render_grabbers_for_picking(const BoundingBoxf3& box) const { #if ENABLE_LEGACY_OPENGL_REMOVAL @@ -246,6 +380,7 @@ void GLGizmoBase::render_grabbers_for_picking(const BoundingBoxf3& box) const } #endif // ENABLE_LEGACY_OPENGL_REMOVAL } +#endif // !ENABLE_RAYCAST_PICKING // help function to process grabbers // call start_dragging, stop_dragging, on_dragging diff --git a/src/slic3r/GUI/Gizmos/GLGizmoBase.hpp b/src/slic3r/GUI/Gizmos/GLGizmoBase.hpp index db8484f0b..87fbaa6a4 100644 --- a/src/slic3r/GUI/Gizmos/GLGizmoBase.hpp +++ b/src/slic3r/GUI/Gizmos/GLGizmoBase.hpp @@ -6,6 +6,9 @@ #include "slic3r/GUI/I18N.hpp" #include "slic3r/GUI/GLModel.hpp" +#if ENABLE_RAYCAST_PICKING +#include "slic3r/GUI/MeshUtils.hpp" +#endif // ENABLE_RAYCAST_PICKING #include @@ -65,21 +68,38 @@ protected: #endif // ENABLE_LEGACY_OPENGL_REMOVAL ColorRGBA color{ ColorRGBA::WHITE() }; EGrabberExtension extensions{ EGrabberExtension::None }; +#if ENABLE_RAYCAST_PICKING + // the picking id shared by all the elements + int picking_id{ -1 }; + bool elements_registered_for_picking{ false }; +#endif // ENABLE_RAYCAST_PICKING Grabber() = default; ~Grabber(); void render(bool hover, float size) { render(size, hover ? complementary(color) : color, false); } +#if !ENABLE_RAYCAST_PICKING void render_for_picking(float size) { render(size, color, true); } +#endif // !ENABLE_RAYCAST_PICKING float get_half_size(float size) const; float get_dragging_half_size(float size) const; +#if ENABLE_RAYCAST_PICKING + void register_raycasters_for_picking(int id); + void unregister_raycasters_for_picking(); +#endif // ENABLE_RAYCAST_PICKING + private: void render(float size, const ColorRGBA& render_color, bool picking); +#if ENABLE_RAYCAST_PICKING + static PickingModel s_cube; + static PickingModel s_cone; +#else static GLModel s_cube; static GLModel s_cone; +#endif // ENABLE_RAYCAST_PICKING }; public: @@ -102,17 +122,19 @@ public: protected: GLCanvas3D& m_parent; - int m_group_id; // TODO: remove only for rotate - EState m_state; - int m_shortcut_key; + + int m_group_id{ -1 }; // TODO: remove only for rotate + EState m_state{ Off }; + int m_shortcut_key{ 0 }; std::string m_icon_filename; unsigned int m_sprite_id; - int m_hover_id; - bool m_dragging; + int m_hover_id{ -1 }; + bool m_dragging{ false }; mutable std::vector m_grabbers; ImGuiWrapper* m_imgui; - bool m_first_input_window_render; - CommonGizmosDataPool* m_c; + bool m_first_input_window_render{ true }; + CommonGizmosDataPool* m_c{ nullptr }; + public: GLGizmoBase(GLCanvas3D& parent, const std::string& icon_filename, @@ -153,7 +175,9 @@ public: bool update_items_state(); void render() { on_render(); } +#if !ENABLE_RAYCAST_PICKING void render_for_picking() { on_render_for_picking(); } +#endif // !ENABLE_RAYCAST_PICKING void render_input_window(float x, float y, float bottom_limit); /// @@ -174,6 +198,12 @@ public: /// Keep information about mouse click /// Return True when use the information and don't want to propagate it otherwise False. virtual bool on_mouse(const wxMouseEvent &mouse_event) { return false; } + +#if ENABLE_RAYCAST_PICKING + void register_raycasters_for_picking() { register_grabbers_for_picking(); on_register_raycasters_for_picking(); } + void unregister_raycasters_for_picking() { unregister_grabbers_for_picking(); on_unregister_raycasters_for_picking(); } +#endif // ENABLE_RAYCAST_PICKING + protected: virtual bool on_init() = 0; virtual void on_load(cereal::BinaryInputArchive& ar) {} @@ -193,16 +223,27 @@ protected: virtual void on_dragging(const UpdateData& data) {} virtual void on_render() = 0; +#if !ENABLE_RAYCAST_PICKING virtual void on_render_for_picking() = 0; +#endif // !ENABLE_RAYCAST_PICKING virtual void on_render_input_window(float x, float y, float bottom_limit) {} +#if ENABLE_RAYCAST_PICKING + void register_grabbers_for_picking(); + void unregister_grabbers_for_picking(); + virtual void on_register_raycasters_for_picking() {} + virtual void on_unregister_raycasters_for_picking() {} +#endif // ENABLE_RAYCAST_PICKING + // Returns the picking color for the given id, based on the BASE_ID constant // No check is made for clashing with other picking color (i.e. GLVolumes) ColorRGBA picking_color_component(unsigned int id) const; void render_grabbers(const BoundingBoxf3& box) const; void render_grabbers(float size) const; +#if !ENABLE_RAYCAST_PICKING void render_grabbers_for_picking(const BoundingBoxf3& box) const; +#endif // !ENABLE_RAYCAST_PICKING std::string format(float value, unsigned int decimals) const; @@ -225,7 +266,7 @@ protected: private: // Flag for dirty visible state of Gizmo // When True then need new rendering - bool m_dirty; + bool m_dirty{ false }; }; } // namespace GUI diff --git a/src/slic3r/GUI/Gizmos/GLGizmoCut.cpp b/src/slic3r/GUI/Gizmos/GLGizmoCut.cpp index a83fcde2c..9eebd583e 100644 --- a/src/slic3r/GUI/Gizmos/GLGizmoCut.cpp +++ b/src/slic3r/GUI/Gizmos/GLGizmoCut.cpp @@ -269,11 +269,13 @@ void GLGizmoCut::on_render() #endif // !ENABLE_GL_CORE_PROFILE } -void GLGizmoCut::on_render_for_picking() +#if !ENABLE_RAYCAST_PICKING + void GLGizmoCut::on_render_for_picking() { glsafe(::glDisable(GL_DEPTH_TEST)); render_grabbers_for_picking(m_parent.get_selection().get_bounding_box()); } +#endif // !ENABLE_RAYCAST_PICKING void GLGizmoCut::on_render_input_window(float x, float y, float bottom_limit) { diff --git a/src/slic3r/GUI/Gizmos/GLGizmoCut.hpp b/src/slic3r/GUI/Gizmos/GLGizmoCut.hpp index d81b53e5f..6283d9e31 100644 --- a/src/slic3r/GUI/Gizmos/GLGizmoCut.hpp +++ b/src/slic3r/GUI/Gizmos/GLGizmoCut.hpp @@ -68,7 +68,9 @@ protected: virtual void on_start_dragging() override; virtual void on_dragging(const UpdateData& data) override; virtual void on_render() override; +#if !ENABLE_RAYCAST_PICKING virtual void on_render_for_picking() override; +#endif // !ENABLE_RAYCAST_PICKING virtual void on_render_input_window(float x, float y, float bottom_limit) override; private: diff --git a/src/slic3r/GUI/Gizmos/GLGizmoFlatten.cpp b/src/slic3r/GUI/Gizmos/GLGizmoFlatten.cpp index fea23034b..b13e57c52 100644 --- a/src/slic3r/GUI/Gizmos/GLGizmoFlatten.cpp +++ b/src/slic3r/GUI/Gizmos/GLGizmoFlatten.cpp @@ -154,6 +154,7 @@ void GLGizmoFlatten::on_render() #endif // ENABLE_LEGACY_OPENGL_REMOVAL } +#if !ENABLE_RAYCAST_PICKING void GLGizmoFlatten::on_render_for_picking() { const Selection& selection = m_parent.get_selection(); @@ -204,6 +205,7 @@ void GLGizmoFlatten::on_render_for_picking() shader->stop_using(); #endif // ENABLE_LEGACY_OPENGL_REMOVAL } +#endif // !ENABLE_RAYCAST_PICKING void GLGizmoFlatten::set_flattening_data(const ModelObject* model_object) { diff --git a/src/slic3r/GUI/Gizmos/GLGizmoFlatten.hpp b/src/slic3r/GUI/Gizmos/GLGizmoFlatten.hpp index 3244056a4..895b99a5b 100644 --- a/src/slic3r/GUI/Gizmos/GLGizmoFlatten.hpp +++ b/src/slic3r/GUI/Gizmos/GLGizmoFlatten.hpp @@ -67,7 +67,9 @@ protected: std::string on_get_name() const override; bool on_is_activable() const override; void on_render() override; +#if !ENABLE_RAYCAST_PICKING void on_render_for_picking() override; +#endif // !ENABLE_RAYCAST_PICKING void on_set_state() override; CommonGizmosDataID on_get_requirements() const override; }; diff --git a/src/slic3r/GUI/Gizmos/GLGizmoHollow.cpp b/src/slic3r/GUI/Gizmos/GLGizmoHollow.cpp index 3485075ec..f559217c1 100644 --- a/src/slic3r/GUI/Gizmos/GLGizmoHollow.cpp +++ b/src/slic3r/GUI/Gizmos/GLGizmoHollow.cpp @@ -90,6 +90,7 @@ void GLGizmoHollow::on_render() } +#if !ENABLE_RAYCAST_PICKING void GLGizmoHollow::on_render_for_picking() { const Selection& selection = m_parent.get_selection(); @@ -100,6 +101,7 @@ void GLGizmoHollow::on_render_for_picking() glsafe(::glEnable(GL_DEPTH_TEST)); render_points(selection, true); } +#endif // !ENABLE_RAYCAST_PICKING void GLGizmoHollow::render_points(const Selection& selection, bool picking) { diff --git a/src/slic3r/GUI/Gizmos/GLGizmoHollow.hpp b/src/slic3r/GUI/Gizmos/GLGizmoHollow.hpp index feab896cc..59d64c522 100644 --- a/src/slic3r/GUI/Gizmos/GLGizmoHollow.hpp +++ b/src/slic3r/GUI/Gizmos/GLGizmoHollow.hpp @@ -46,7 +46,9 @@ public: private: bool on_init() override; void on_render() override; +#if !ENABLE_RAYCAST_PICKING void on_render_for_picking() override; +#endif // !ENABLE_RAYCAST_PICKING void render_points(const Selection& selection, bool picking = false); void hollow_mesh(bool postpone_error_messages = false); diff --git a/src/slic3r/GUI/Gizmos/GLGizmoMove.cpp b/src/slic3r/GUI/Gizmos/GLGizmoMove.cpp index 8257185b6..adb213d7c 100644 --- a/src/slic3r/GUI/Gizmos/GLGizmoMove.cpp +++ b/src/slic3r/GUI/Gizmos/GLGizmoMove.cpp @@ -360,6 +360,18 @@ void GLGizmoMove3D::on_render() #endif // ENABLE_WORLD_COORDINATE } +#if ENABLE_RAYCAST_PICKING +void GLGizmoMove3D::on_register_raycasters_for_picking() +{ + // this gizmo is rendered on top of the scene, so the raytraced picker should take it into account + m_parent.set_raycaster_gizmos_on_top(true); +} + +void GLGizmoMove3D::on_unregister_raycasters_for_picking() +{ + m_parent.set_raycaster_gizmos_on_top(false); +} +#else void GLGizmoMove3D::on_render_for_picking() { glsafe(::glDisable(GL_DEPTH_TEST)); @@ -384,6 +396,7 @@ void GLGizmoMove3D::on_render_for_picking() render_grabbers_for_picking(box); #endif // ENABLE_WORLD_COORDINATE } +#endif // ENABLE_RAYCAST_PICKING double GLGizmoMove3D::calc_projection(const UpdateData& data) const { diff --git a/src/slic3r/GUI/Gizmos/GLGizmoMove.hpp b/src/slic3r/GUI/Gizmos/GLGizmoMove.hpp index fae31b6d7..b4414f401 100644 --- a/src/slic3r/GUI/Gizmos/GLGizmoMove.hpp +++ b/src/slic3r/GUI/Gizmos/GLGizmoMove.hpp @@ -62,7 +62,12 @@ protected: void on_stop_dragging() override; void on_dragging(const UpdateData& data) override; void on_render() override; +#if ENABLE_RAYCAST_PICKING + virtual void on_register_raycasters_for_picking() override; + virtual void on_unregister_raycasters_for_picking() override; +#else void on_render_for_picking() override; +#endif // ENABLE_RAYCAST_PICKING private: double calc_projection(const UpdateData& data) const; diff --git a/src/slic3r/GUI/Gizmos/GLGizmoPainterBase.hpp b/src/slic3r/GUI/Gizmos/GLGizmoPainterBase.hpp index 1c5733967..368be5011 100644 --- a/src/slic3r/GUI/Gizmos/GLGizmoPainterBase.hpp +++ b/src/slic3r/GUI/Gizmos/GLGizmoPainterBase.hpp @@ -138,7 +138,10 @@ private: ObjectID m_old_mo_id; size_t m_old_volumes_size = 0; void on_render() override {} +#if !ENABLE_RAYCAST_PICKING void on_render_for_picking() override {} +#endif // !ENABLE_RAYCAST_PICKING + public: GLGizmoPainterBase(GLCanvas3D& parent, const std::string& icon_filename, unsigned int sprite_id); ~GLGizmoPainterBase() override; diff --git a/src/slic3r/GUI/Gizmos/GLGizmoRotate.cpp b/src/slic3r/GUI/Gizmos/GLGizmoRotate.cpp index 6db7fc5e0..8838e13ec 100644 --- a/src/slic3r/GUI/Gizmos/GLGizmoRotate.cpp +++ b/src/slic3r/GUI/Gizmos/GLGizmoRotate.cpp @@ -251,6 +251,7 @@ void GLGizmoRotate::on_render() #endif // !ENABLE_LEGACY_OPENGL_REMOVAL } +#if !ENABLE_RAYCAST_PICKING void GLGizmoRotate::on_render_for_picking() { const Selection& selection = m_parent.get_selection(); @@ -275,6 +276,7 @@ void GLGizmoRotate::on_render_for_picking() glsafe(::glPopMatrix()); #endif // !ENABLE_LEGACY_OPENGL_REMOVAL } +#endif // !ENABLE_RAYCAST_PICKING #if ENABLE_WORLD_COORDINATE void GLGizmoRotate::init_data_from_selection(const Selection& selection) diff --git a/src/slic3r/GUI/Gizmos/GLGizmoRotate.hpp b/src/slic3r/GUI/Gizmos/GLGizmoRotate.hpp index be630dc4c..b97526718 100644 --- a/src/slic3r/GUI/Gizmos/GLGizmoRotate.hpp +++ b/src/slic3r/GUI/Gizmos/GLGizmoRotate.hpp @@ -90,7 +90,9 @@ protected: void on_start_dragging() override; void on_dragging(const UpdateData &data) override; void on_render() override; +#if !ENABLE_RAYCAST_PICKING void on_render_for_picking() override; +#endif // !ENABLE_RAYCAST_PICKING private: #if ENABLE_LEGACY_OPENGL_REMOVAL @@ -175,11 +177,13 @@ protected: void on_dragging(const UpdateData &data) override; void on_render() override; +#if !ENABLE_RAYCAST_PICKING void on_render_for_picking() override { for (GLGizmoRotate& g : m_gizmos) { g.render_for_picking(); } } +#endif // !ENABLE_RAYCAST_PICKING void on_render_input_window(float x, float y, float bottom_limit) override; diff --git a/src/slic3r/GUI/Gizmos/GLGizmoScale.cpp b/src/slic3r/GUI/Gizmos/GLGizmoScale.cpp index cb526c296..e18730508 100644 --- a/src/slic3r/GUI/Gizmos/GLGizmoScale.cpp +++ b/src/slic3r/GUI/Gizmos/GLGizmoScale.cpp @@ -643,6 +643,7 @@ void GLGizmoScale3D::on_render() #endif // ENABLE_WORLD_COORDINATE } +#if !ENABLE_RAYCAST_PICKING void GLGizmoScale3D::on_render_for_picking() { glsafe(::glDisable(GL_DEPTH_TEST)); @@ -664,6 +665,7 @@ void GLGizmoScale3D::on_render_for_picking() render_grabbers_for_picking(m_parent.get_selection().get_bounding_box()); #endif // ENABLE_WORLD_COORDINATE } +#endif // !ENABLE_RAYCAST_PICKING #if ENABLE_LEGACY_OPENGL_REMOVAL void GLGizmoScale3D::render_grabbers_connection(unsigned int id_1, unsigned int id_2, const ColorRGBA& color) diff --git a/src/slic3r/GUI/Gizmos/GLGizmoScale.hpp b/src/slic3r/GUI/Gizmos/GLGizmoScale.hpp index d6bef4475..009951646 100644 --- a/src/slic3r/GUI/Gizmos/GLGizmoScale.hpp +++ b/src/slic3r/GUI/Gizmos/GLGizmoScale.hpp @@ -93,7 +93,9 @@ protected: virtual void on_stop_dragging() override; virtual void on_dragging(const UpdateData& data) override; virtual void on_render() override; +#if !ENABLE_RAYCAST_PICKING virtual void on_render_for_picking() override; +#endif // !ENABLE_RAYCAST_PICKING private: #if ENABLE_LEGACY_OPENGL_REMOVAL diff --git a/src/slic3r/GUI/Gizmos/GLGizmoSimplify.hpp b/src/slic3r/GUI/Gizmos/GLGizmoSimplify.hpp index 52269ba86..ae2814ee9 100644 --- a/src/slic3r/GUI/Gizmos/GLGizmoSimplify.hpp +++ b/src/slic3r/GUI/Gizmos/GLGizmoSimplify.hpp @@ -38,7 +38,9 @@ protected: // must implement virtual bool on_init() override { return true;}; virtual void on_render() override; - virtual void on_render_for_picking() override{}; +#if !ENABLE_RAYCAST_PICKING + virtual void on_render_for_picking() override{}; +#endif // !ENABLE_RAYCAST_PICKING CommonGizmosDataID on_get_requirements() const override; diff --git a/src/slic3r/GUI/Gizmos/GLGizmoSlaSupports.cpp b/src/slic3r/GUI/Gizmos/GLGizmoSlaSupports.cpp index fd003bba1..e95ead91f 100644 --- a/src/slic3r/GUI/Gizmos/GLGizmoSlaSupports.cpp +++ b/src/slic3r/GUI/Gizmos/GLGizmoSlaSupports.cpp @@ -111,12 +111,14 @@ void GLGizmoSlaSupports::on_render() } +#if !ENABLE_RAYCAST_PICKING void GLGizmoSlaSupports::on_render_for_picking() { const Selection& selection = m_parent.get_selection(); //glsafe(::glEnable(GL_DEPTH_TEST)); render_points(selection, true); } +#endif // !ENABLE_RAYCAST_PICKING void GLGizmoSlaSupports::render_points(const Selection& selection, bool picking) { diff --git a/src/slic3r/GUI/Gizmos/GLGizmoSlaSupports.hpp b/src/slic3r/GUI/Gizmos/GLGizmoSlaSupports.hpp index 5eb29823e..db414c0f4 100644 --- a/src/slic3r/GUI/Gizmos/GLGizmoSlaSupports.hpp +++ b/src/slic3r/GUI/Gizmos/GLGizmoSlaSupports.hpp @@ -80,7 +80,9 @@ public: private: bool on_init() override; void on_render() override; +#if !ENABLE_RAYCAST_PICKING void on_render_for_picking() override; +#endif // !ENABLE_RAYCAST_PICKING void render_points(const Selection& selection, bool picking = false); bool unsaved_changes() const; diff --git a/src/slic3r/GUI/Gizmos/GLGizmosCommon.hpp b/src/slic3r/GUI/Gizmos/GLGizmosCommon.hpp index 228f5b58c..7dd2c110e 100644 --- a/src/slic3r/GUI/Gizmos/GLGizmosCommon.hpp +++ b/src/slic3r/GUI/Gizmos/GLGizmosCommon.hpp @@ -73,7 +73,7 @@ enum class CommonGizmosDataID { // by GLGizmoManager, the gizmos keep a pointer to it. class CommonGizmosDataPool { public: - CommonGizmosDataPool(GLCanvas3D* canvas); + explicit CommonGizmosDataPool(GLCanvas3D* canvas); // Update all resources and release what is not used. // Accepts a bitmask of currently required resources. diff --git a/src/slic3r/GUI/Gizmos/GLGizmosManager.cpp b/src/slic3r/GUI/Gizmos/GLGizmosManager.cpp index eddcfd3a5..8759e880d 100644 --- a/src/slic3r/GUI/Gizmos/GLGizmosManager.cpp +++ b/src/slic3r/GUI/Gizmos/GLGizmosManager.cpp @@ -331,6 +331,7 @@ void GLGizmosManager::render_painter_gizmo() gizmo->render_painter_gizmo(); } +#if !ENABLE_RAYCAST_PICKING void GLGizmosManager::render_current_gizmo_for_picking_pass() const { if (! m_enabled || m_current == Undefined) @@ -339,6 +340,7 @@ void GLGizmosManager::render_current_gizmo_for_picking_pass() const m_gizmos[m_current]->render_for_picking(); } +#endif // !ENABLE_RAYCAST_PICKING void GLGizmosManager::render_overlay() { @@ -1117,6 +1119,10 @@ bool GLGizmosManager::activate_gizmo(EType type) if (old_gizmo.get_state() != GLGizmoBase::Off) return false; // gizmo refused to be turned off, do nothing. +#if ENABLE_RAYCAST_PICKING + old_gizmo.unregister_raycasters_for_picking(); +#endif // ENABLE_RAYCAST_PICKING + if (!m_serializing && old_gizmo.wants_enter_leave_snapshots()) Plater::TakeSnapshot snapshot(wxGetApp().plater(), @@ -1146,6 +1152,10 @@ bool GLGizmosManager::activate_gizmo(EType type) return false; // gizmo refused to be turned on. } +#if ENABLE_RAYCAST_PICKING + new_gizmo.register_raycasters_for_picking(); +#endif // ENABLE_RAYCAST_PICKING + // sucessful activation of gizmo return true; } diff --git a/src/slic3r/GUI/Gizmos/GLGizmosManager.hpp b/src/slic3r/GUI/Gizmos/GLGizmosManager.hpp index 083bfad97..8a708f62a 100644 --- a/src/slic3r/GUI/Gizmos/GLGizmosManager.hpp +++ b/src/slic3r/GUI/Gizmos/GLGizmosManager.hpp @@ -213,7 +213,9 @@ public: bool is_hiding_instances() const; void render_current_gizmo() const; +#if !ENABLE_RAYCAST_PICKING void render_current_gizmo_for_picking_pass() const; +#endif // !ENABLE_RAYCAST_PICKING void render_painter_gizmo(); void render_overlay(); diff --git a/src/slic3r/GUI/SceneRaycaster.cpp b/src/slic3r/GUI/SceneRaycaster.cpp index 8db41aef2..f250c2e00 100644 --- a/src/slic3r/GUI/SceneRaycaster.cpp +++ b/src/slic3r/GUI/SceneRaycaster.cpp @@ -33,28 +33,48 @@ SceneRaycaster::SceneRaycaster() { #endif // ENABLE_RAYCAST_PICKING_DEBUG } -int SceneRaycaster::add_raycaster(EType type, PickingId id, const MeshRaycaster& raycaster, const Transform3d& trafo) +void SceneRaycaster::add_raycaster(EType type, PickingId id, const MeshRaycaster& raycaster, const Transform3d& trafo) { switch (type) { case EType::Bed: { m_bed.emplace_back(encode_id(type, id), raycaster, trafo); - return m_bed.size() - 1; + break; } case EType::Volume: { m_volumes.emplace_back(encode_id(type, id), raycaster, trafo); - return m_volumes.size() - 1; + break; } case EType::Gizmo: { m_gizmos.emplace_back(encode_id(type, id), raycaster, trafo); - return m_gizmos.size() - 1; + break; } + default: { break; } }; - - // signal error - return -1; } -void SceneRaycaster::set_raycaster_active_state(EType type, int id, bool active) +void SceneRaycaster::remove_raycasters(EType type, PickingId id) +{ + std::vector* raycasters = get_raycasters(type); + auto it = raycasters->begin(); + while (it != raycasters->end()) { + if (it->get_id() == encode_id(type, id)) + it = raycasters->erase(it); + else + ++it; + } +} + +void SceneRaycaster::remove_raycasters(EType type) +{ + switch (type) { + case EType::Bed: { m_bed.clear(); break; } + case EType::Volume: { m_volumes.clear(); break; } + case EType::Gizmo: { m_gizmos.clear(); break; } + default: { break; } + }; +} + +void SceneRaycaster::set_raycaster_active_state(EType type, PickingId id, bool active) { std::vector* raycasters = get_raycasters(type); for (SceneRaycasterItem& item : *raycasters) { @@ -65,7 +85,7 @@ void SceneRaycaster::set_raycaster_active_state(EType type, int id, bool active) } } -void SceneRaycaster::set_raycaster_transform(EType type, int id, const Transform3d& trafo) +void SceneRaycaster::set_raycaster_transform(EType type, PickingId id, const Transform3d& trafo) { std::vector* raycasters = get_raycasters(type); for (SceneRaycasterItem& item : *raycasters) { @@ -76,31 +96,6 @@ void SceneRaycaster::set_raycaster_transform(EType type, int id, const Transform } } -void SceneRaycaster::remove_raycaster(EType type, int id) -{ - std::vector* raycasters = get_raycasters(type); - if (0 <= id && id < raycasters->size()) - raycasters->erase(raycasters->begin() + id); -} - -void SceneRaycaster::reset(EType type) -{ - switch (type) { - case EType::Bed: { - m_bed.clear(); - break; - } - case EType::Volume: { - m_volumes.clear(); - break; - } - case EType::Gizmo: { - m_gizmos.clear(); - break; - } - }; -} - SceneRaycaster::HitResult SceneRaycaster::hit(const Vec2d& mouse_pos, const Camera& camera, const ClippingPlane* clipping_plane) { double closest_hit_squared_distance = std::numeric_limits::max(); @@ -140,11 +135,14 @@ SceneRaycaster::HitResult SceneRaycaster::hit(const Vec2d& mouse_pos, const Came } }; - test_raycasters(EType::Gizmo); - if (!m_gizmos_on_top || ret.is_valid()) { - if (camera.is_looking_downward()) + if (!m_gizmos.empty()) + test_raycasters(EType::Gizmo); + + if (!m_gizmos_on_top || !ret.is_valid()) { + if (camera.is_looking_downward() && !m_bed.empty()) test_raycasters(EType::Bed); - test_raycasters(EType::Volume); + if (!m_volumes.empty()) + test_raycasters(EType::Volume); } if (ret.is_valid()) diff --git a/src/slic3r/GUI/SceneRaycaster.hpp b/src/slic3r/GUI/SceneRaycaster.hpp index 8d9496f27..e9253de8b 100644 --- a/src/slic3r/GUI/SceneRaycaster.hpp +++ b/src/slic3r/GUI/SceneRaycaster.hpp @@ -83,15 +83,12 @@ private: public: SceneRaycaster(); - // returns the internal index of the added raycaster - // can be used with remove_raycaster() - int add_raycaster(EType type, PickingId picking_id, const MeshRaycaster& raycaster, const Transform3d& trafo); + void add_raycaster(EType type, PickingId picking_id, const MeshRaycaster& raycaster, const Transform3d& trafo); + void remove_raycasters(EType type, PickingId id); + void remove_raycasters(EType type); + void set_raycaster_active_state(EType type, PickingId picking_id, bool active); void set_raycaster_transform(EType type, PickingId picking_id, const Transform3d& trafo); - // id: the value returned by add_raycaster() - void remove_raycaster(EType type, int id); - - void reset(EType type); void set_gizmos_on_top(bool value) { m_gizmos_on_top = value; }