// Include GLGizmoBase.hpp before I18N.hpp as it includes some libigl code, which overrides our localization "L" macro. #include "GLGizmoMeasure.hpp" #include "slic3r/GUI/GLCanvas3D.hpp" #include "slic3r/GUI/GUI_App.hpp" #include "slic3r/GUI/Plater.hpp" #include "slic3r/GUI/GUI_ObjectManipulation.hpp" #include "slic3r/GUI/Gizmos/GLGizmosCommon.hpp" #include "libslic3r/Model.hpp" #include "libslic3r/PresetBundle.hpp" #include #include #if ENABLE_MEASURE_GIZMO namespace Slic3r { namespace GUI { using Edge = std::pair; using Plane = std::tuple; using Circle = std::tuple; static const Slic3r::ColorRGBA SELECTED_1ST_COLOR = { 0.25f, 0.75f, 0.75f, 1.0f }; static const Slic3r::ColorRGBA SELECTED_2ND_COLOR = { 0.75f, 0.25f, 0.75f, 1.0f }; static const int POINT_ID = 100; static const int EDGE_ID = 200; static const int CIRCLE_ID = 300; static const int PLANE_ID = 400; static const float TRIANGLE_BASE = 16.0f; static const float TRIANGLE_HEIGHT = TRIANGLE_BASE * 1.618033f; static const std::string CTRL_STR = #ifdef __APPLE__ "⌘" #else "Ctrl" #endif //__APPLE__ ; static std::string surface_feature_type_as_string(Measure::SurfaceFeatureType type) { switch (type) { default: case Measure::SurfaceFeatureType::Undef: { return L("Undefined"); } case Measure::SurfaceFeatureType::Point: { return L("Vertex"); } case Measure::SurfaceFeatureType::Edge: { return L("Edge"); } case Measure::SurfaceFeatureType::Circle: { return L("Circle"); } case Measure::SurfaceFeatureType::Plane: { return L("Plane"); } } } static std::string point_on_feature_type_as_string(Measure::SurfaceFeatureType type, int hover_id) { std::string ret; switch (type) { case Measure::SurfaceFeatureType::Point: { ret = _u8L("Vertex"); break; } case Measure::SurfaceFeatureType::Edge: { ret = _u8L("Point on edge"); break; } case Measure::SurfaceFeatureType::Circle: { ret = (hover_id == POINT_ID) ? _u8L("Center of circle") : _u8L("Point on circle"); break; } case Measure::SurfaceFeatureType::Plane: { ret = _u8L("Point on plane"); break; } default: { assert(false); break; } } return ret; } static std::tuple distance_point_plane(const Vec3d& v, const Plane& p) { const auto& [idx, normal, origin] = p; const Eigen::Hyperplane plane(normal, origin); return std::make_tuple(plane.absDistance(v), v, plane.projection(v)); } static std::tuple distance_point_edge(const Vec3d& v, const Edge& e) { const Eigen::ParametrizedLine line(e.first, (e.second - e.first).normalized()); return std::make_tuple(line.distance(v), v, line.projection(v)); } static std::tuple distance_point_circle(const Vec3d& v, const Circle& c) { const auto& [center, radius, normal] = c; const Eigen::Hyperplane plane(normal, center); const Vec3d p_on_circle = center + radius * (plane.projection(v) - center).normalized(); return std::make_tuple((v - p_on_circle).norm(), v, p_on_circle); } static std::tuple distance_edge_edge(const Edge& e1, const Edge& e2) { std::vector> distances; distances.emplace_back(std::make_tuple((e2.first - e1.first).norm(), e1.first, e2.first)); distances.emplace_back(std::make_tuple((e2.second - e1.first).norm(), e1.first, e2.second)); distances.emplace_back(std::make_tuple((e2.first - e1.second).norm(), e1.second, e2.first)); distances.emplace_back(std::make_tuple((e2.second - e1.second).norm(), e1.second, e2.second)); distances.emplace_back(distance_point_edge(e1.first, e2)); distances.emplace_back(distance_point_edge(e1.second, e2)); distances.emplace_back(distance_point_edge(e2.first, e1)); distances.emplace_back(distance_point_edge(e2.second, e1)); std::sort(distances.begin(), distances.end(), [](const std::tuple& item1, const std::tuple& item2) { return std::get<0>(item1) < std::get<0>(item2); }); return distances.front(); } static std::tuple distance_edge_circle(const Edge& e, const Circle& c) { const auto& [center, radius, normal] = c; const Vec3d e1e2_unit = (e.second - e.first).normalized(); double dot = std::abs(e1e2_unit.dot(normal)); if (dot < EPSILON) { // edge parallel to circle's plane const Eigen::Hyperplane plane(e1e2_unit, center); const Eigen::ParametrizedLine line(e.first, e1e2_unit); const Vec3d inter = line.intersectionPoint(plane); return distance_point_circle(inter, c); } else if (std::abs(dot - 1.0) < EPSILON) // edge parallel to circle's normal return distance_point_circle(e.first, c); else { const auto [distance1, v11, v12] = distance_point_circle(e.first, c); const auto [distance2, v21, v22] = distance_point_circle(e.second, c); return (distance1 <= distance2) ? std::make_tuple(distance1, v11, v12) : std::make_tuple(distance2, v21, v22); } } static std::tuple distance_plane_plane(const Plane& p1, const Plane& p2) { const auto& [idx1, normal1, origin1] = p1; const auto& [idx2, normal2, origin2] = p2; return (std::abs(std::abs(normal1.dot(normal2)) - 1.0) < EPSILON) ? distance_point_plane(origin2, p1) : std::make_tuple(0.0, Vec3d::Zero(), Vec3d::Zero()); } static GLModel::Geometry init_plane_data(const indexed_triangle_set& its, const std::vector>& planes_triangles, int idx) { assert(0 <= idx && idx < (int)planes_triangles.size()); const std::vector& triangle_indices = planes_triangles[idx]; GLModel::Geometry init_data; init_data.format = { GUI::GLModel::Geometry::EPrimitiveType::Triangles, GLModel::Geometry::EVertexLayout::P3N3 }; unsigned int i = 0; for (int idx : triangle_indices) { const Vec3f& v0 = its.vertices[its.indices[idx][0]]; const Vec3f& v1 = its.vertices[its.indices[idx][1]]; const Vec3f& v2 = its.vertices[its.indices[idx][2]]; const Vec3f n = (v1 - v0).cross(v2 - v0).normalized(); init_data.add_vertex(v0, n); init_data.add_vertex(v1, n); init_data.add_vertex(v2, n); init_data.add_triangle(i, i + 1, i + 2); i += 3; } return init_data; } GLGizmoMeasure::GLGizmoMeasure(GLCanvas3D& parent, const std::string& icon_filename, unsigned int sprite_id) : GLGizmoBase(parent, icon_filename, sprite_id) { GLModel::Geometry sphere_geometry = smooth_sphere(16, 7.5f); m_sphere.mesh_raycaster = std::make_unique(std::make_shared(sphere_geometry.get_as_indexed_triangle_set())); m_sphere.model.init_from(std::move(sphere_geometry)); GLModel::Geometry cylinder_geometry = smooth_cylinder(16, 5.0f, 1.0f); m_cylinder.mesh_raycaster = std::make_unique(std::make_shared(cylinder_geometry.get_as_indexed_triangle_set())); m_cylinder.model.init_from(std::move(cylinder_geometry)); } bool GLGizmoMeasure::on_mouse(const wxMouseEvent &mouse_event) { m_mouse_pos = { double(mouse_event.GetX()), double(mouse_event.GetY()) }; if (mouse_event.Moving()) { // only for sure m_mouse_left_down = false; return false; } else if (mouse_event.LeftDown()) { if (m_hover_id != -1) { m_mouse_left_down = true; auto item_from_feature = [this]() { const SelectedFeatures::Item item = { (m_mode == EMode::ExtendedSelection) ? point_on_feature_type_as_string(m_curr_feature->get_type(), m_hover_id) : surface_feature_type_as_string(m_curr_feature->get_type()), (m_mode == EMode::ExtendedSelection) ? Measure::SurfaceFeature(*m_curr_point_on_feature_position) : m_curr_feature }; return item; }; if (m_selected_features.first.feature.has_value()) { const SelectedFeatures::Item item = item_from_feature(); if (m_selected_features.first != item) m_selected_features.second = item; } else m_selected_features.first = item_from_feature(); return true; } // fix: prevent restart gizmo when reselect object // take responsibility for left up if (m_parent.get_first_hover_volume_idx() >= 0) m_mouse_left_down = true; } else if (mouse_event.LeftUp()) { if (m_mouse_left_down) { // responsible for mouse left up after selecting plane m_mouse_left_down = false; return true; } } else if (mouse_event.RightDown() && mouse_event.CmdDown()) { m_selected_features.reset(); m_imgui->set_requires_extra_frame(); } else if (mouse_event.Leaving()) m_mouse_left_down = false; return false; } void GLGizmoMeasure::data_changed() { const Selection& selection = m_parent.get_selection(); const ModelObject* model_object = nullptr; const ModelVolume* model_volume = nullptr; if (selection.is_single_full_instance() || selection.is_from_single_object() ) { model_object = selection.get_model()->objects[selection.get_object_idx()]; model_volume = model_object->volumes[selection.get_first_volume()->volume_idx()]; } if (model_object != m_old_model_object || model_volume != m_old_model_volume) update_if_needed(); m_last_inv_zoom = 0.0f; m_last_plane_idx = -1; m_selected_features.reset(); } bool GLGizmoMeasure::gizmo_event(SLAGizmoEventType action, const Vec2d& mouse_position, bool shift_down, bool alt_down, bool control_down) { if (action == SLAGizmoEventType::CtrlDown) { if (m_ctrl_kar_filter.is_first()) { if (m_curr_feature.has_value()) { m_mode = EMode::ExtendedSelection; disable_scene_raycasters(); } } m_ctrl_kar_filter.increase_count(); } else if (action == SLAGizmoEventType::CtrlUp) { m_ctrl_kar_filter.reset_count(); m_mode = EMode::BasicSelection; restore_scene_raycasters_state(); } return true; } bool GLGizmoMeasure::on_init() { m_shortcut_key = WXK_CONTROL_U; return true; } void GLGizmoMeasure::on_set_state() { if (m_state == Off) { m_ctrl_kar_filter.reset_count(); m_curr_feature.reset(); m_curr_point_on_feature_position.reset(); restore_scene_raycasters_state(); } else { m_mode = EMode::BasicSelection; // store current state of scene raycaster for later use m_scene_raycaster_state.clear(); m_scene_raycasters = m_parent.get_raycasters_for_picking(SceneRaycaster::EType::Volume); if (m_scene_raycasters != nullptr) { for (const auto& r : *m_scene_raycasters) { m_scene_raycaster_state.emplace_back(r->is_active()); } } } } CommonGizmosDataID GLGizmoMeasure::on_get_requirements() const { return CommonGizmosDataID(int(CommonGizmosDataID::SelectionInfo) | int(CommonGizmosDataID::Raycaster)); } std::string GLGizmoMeasure::on_get_name() const { return _u8L("Measure"); } bool GLGizmoMeasure::on_is_activable() const { const Selection& selection = m_parent.get_selection(); bool res = (wxGetApp().preset_bundle->printers.get_edited_preset().printer_technology() == ptSLA) ? selection.is_single_full_instance() : selection.is_single_volume() || selection.is_single_volume_instance(); if (res) res &= !selection.get_first_volume()->is_sinking(); return res; } void GLGizmoMeasure::on_render() { #if ENABLE_MEASURE_GIZMO_DEBUG render_debug_dialog(); #endif // ENABLE_MEASURE_GIZMO_DEBUG // do not render if the user is panning/rotating the 3d scene if (m_parent.is_mouse_dragging()) return; const Selection& selection = m_parent.get_selection(); if ((wxGetApp().preset_bundle->printers.get_edited_preset().printer_technology() == ptSLA && selection.is_single_full_instance()) || (selection.is_single_volume() || selection.is_single_volume_instance())) { update_if_needed(); m_volume_matrix = selection.get_first_volume()->world_matrix(); const Camera& camera = wxGetApp().plater()->get_camera(); const float inv_zoom = (float)camera.get_inv_zoom(); Vec3f position_on_model; Vec3f normal_on_model; size_t model_facet_idx; const bool mouse_on_object = m_c->raycaster()->raycasters().front()->unproject_on_mesh(m_mouse_pos, m_volume_matrix, camera, position_on_model, normal_on_model, nullptr, &model_facet_idx); const bool is_hovering_on_locked_feature = m_mode == EMode::ExtendedSelection && m_hover_id != -1; if (m_mode == EMode::BasicSelection) { std::optional curr_feature = mouse_on_object ? m_measuring->get_feature(model_facet_idx, position_on_model.cast()) : std::nullopt; m_curr_point_on_feature_position.reset(); if (m_curr_feature != curr_feature) { GLGizmoMeasure::on_unregister_raycasters_for_picking(); m_curr_feature = curr_feature; if (!m_curr_feature.has_value()) return; switch (m_curr_feature->get_type()) { default: { assert(false); break; } case Measure::SurfaceFeatureType::Point: { m_raycasters.insert({ POINT_ID, m_parent.add_raycaster_for_picking(SceneRaycaster::EType::Gizmo, POINT_ID, *m_sphere.mesh_raycaster) }); break; } case Measure::SurfaceFeatureType::Edge: { m_raycasters.insert({ EDGE_ID, m_parent.add_raycaster_for_picking(SceneRaycaster::EType::Gizmo, EDGE_ID, *m_cylinder.mesh_raycaster) }); break; } case Measure::SurfaceFeatureType::Circle: { const auto [center, radius, normal] = m_curr_feature->get_circle(); if (m_last_inv_zoom != inv_zoom || m_last_circle != m_curr_feature) { m_last_inv_zoom = inv_zoom; m_last_circle = m_curr_feature; m_circle.reset(); GLModel::Geometry circle_geometry = smooth_torus(64, 16, float(radius), 5.0f * inv_zoom); m_circle.mesh_raycaster = std::make_unique(std::make_shared(circle_geometry.get_as_indexed_triangle_set())); m_circle.model.init_from(std::move(circle_geometry)); } m_raycasters.insert({ CIRCLE_ID, m_parent.add_raycaster_for_picking(SceneRaycaster::EType::Gizmo, CIRCLE_ID, *m_circle.mesh_raycaster) }); m_raycasters.insert({ POINT_ID, m_parent.add_raycaster_for_picking(SceneRaycaster::EType::Gizmo, POINT_ID, *m_sphere.mesh_raycaster) }); break; } case Measure::SurfaceFeatureType::Plane: { const auto [idx, normal, point] = m_curr_feature->get_plane(); if (m_last_plane_idx != idx) { m_last_plane_idx = idx; const indexed_triangle_set its = (m_old_model_volume != nullptr) ? m_old_model_volume->mesh().its : m_old_model_object->volumes.front()->mesh().its; const std::vector> planes_triangles = m_measuring->get_planes_triangle_indices(); GLModel::Geometry init_data = init_plane_data(its, planes_triangles, idx); m_plane.reset(); m_plane.mesh_raycaster = std::make_unique(std::make_shared(init_data.get_as_indexed_triangle_set())); m_plane.model.init_from(std::move(init_data)); } m_raycasters.insert({ PLANE_ID, m_parent.add_raycaster_for_picking(SceneRaycaster::EType::Gizmo, PLANE_ID, *m_plane.mesh_raycaster) }); break; } } } } else if (is_hovering_on_locked_feature) { auto position_on_feature = [this](int feature_type_id, const Camera& camera, std::function callback = nullptr) -> Vec3d { auto it = m_raycasters.find(feature_type_id); if (it != m_raycasters.end() && it->second != nullptr) { Vec3f p; Vec3f n; const Transform3d& trafo = it->second->get_transform(); bool res = it->second->get_raycaster()->closest_hit(m_mouse_pos, trafo, camera, p, n); assert(res); if (res) { if (callback) p = callback(p); return trafo * p.cast(); } } return Vec3d::Zero(); }; switch (m_curr_feature->get_type()) { default: { assert(false); break; } case Measure::SurfaceFeatureType::Point: { m_curr_point_on_feature_position = m_curr_feature->get_point(); break; } case Measure::SurfaceFeatureType::Edge: { m_curr_point_on_feature_position = m_volume_matrix.inverse() * position_on_feature(EDGE_ID, camera, [](const Vec3f& v) { return Vec3f(0.0f, 0.0f, v.z()); }); break; } case Measure::SurfaceFeatureType::Plane: { m_curr_point_on_feature_position = m_volume_matrix.inverse() * position_on_feature(PLANE_ID, camera); break; } case Measure::SurfaceFeatureType::Circle: { const auto [center, radius, normal] = m_curr_feature->get_circle(); if (m_hover_id == POINT_ID) m_curr_point_on_feature_position = center; else { const float r = radius; // needed for the following lambda m_curr_point_on_feature_position = m_volume_matrix.inverse() * position_on_feature(CIRCLE_ID, camera, [r](const Vec3f& v) { float angle = std::atan2(v.y(), v.x()); if (angle < 0.0f) angle += 2.0f * float(M_PI); return Vec3f(float(r) * std::cos(angle), float(r) * std::sin(angle), 0.0f); }); } break; } } } if (!m_curr_feature.has_value() && !m_selected_features.first.feature.has_value()) return; GLShaderProgram* shader = wxGetApp().get_shader("gouraud_light"); if (shader == nullptr) return; shader->start_using(); shader->set_uniform("emission_factor", 0.25f); shader->set_uniform("projection_matrix", camera.get_projection_matrix()); glsafe(::glClear(GL_DEPTH_BUFFER_BIT)); glsafe(::glEnable(GL_DEPTH_TEST)); const Transform3d& view_matrix = camera.get_view_matrix(); auto set_matrix_uniforms = [shader, &view_matrix](const Transform3d& model_matrix) { const Transform3d view_model_matrix = view_matrix * model_matrix; shader->set_uniform("view_model_matrix", view_model_matrix); const Matrix3d view_normal_matrix = view_matrix.matrix().block(0, 0, 3, 3) * model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose(); shader->set_uniform("view_normal_matrix", view_normal_matrix); }; auto render_feature = [this, set_matrix_uniforms](const Measure::SurfaceFeature& feature, const std::vector& colors, const Transform3d& model_matrix, float inv_zoom, bool update_raycasters) { switch (feature.get_type()) { default: { assert(false); break; } case Measure::SurfaceFeatureType::Point: { const Vec3d& position = feature.get_point(); const Transform3d feature_matrix = model_matrix * Geometry::translation_transform(position) * Geometry::scale_transform(inv_zoom); set_matrix_uniforms(feature_matrix); m_sphere.model.set_color(colors.front()); m_sphere.model.render(); if (update_raycasters) { auto it = m_raycasters.find(POINT_ID); if (it != m_raycasters.end() && it->second != nullptr) it->second->set_transform(feature_matrix); } break; } case Measure::SurfaceFeatureType::Circle: { const auto& [center, radius, normal] = feature.get_circle(); // render center const Transform3d center_matrix = model_matrix * Geometry::translation_transform(center) * Geometry::scale_transform(inv_zoom); set_matrix_uniforms(center_matrix); m_sphere.model.set_color(colors.front()); m_sphere.model.render(); if (update_raycasters) { auto it = m_raycasters.find(POINT_ID); if (it != m_raycasters.end() && it->second != nullptr) it->second->set_transform(center_matrix); } // render circle const Transform3d circle_matrix = model_matrix * Geometry::translation_transform(center) * Eigen::Quaternion::FromTwoVectors(Vec3d::UnitZ(), normal); set_matrix_uniforms(circle_matrix); m_circle.model.set_color(colors.back()); m_circle.model.render(); if (update_raycasters) { auto it = m_raycasters.find(CIRCLE_ID); if (it != m_raycasters.end() && it->second != nullptr) it->second->set_transform(circle_matrix); } break; } case Measure::SurfaceFeatureType::Edge: { const auto& [start, end] = feature.get_edge(); const Transform3d feature_matrix = model_matrix * Geometry::translation_transform(start) * Eigen::Quaternion::FromTwoVectors(Vec3d::UnitZ(), end - start) * Geometry::scale_transform({ (double)inv_zoom, (double)inv_zoom, (end - start).norm() }); set_matrix_uniforms(feature_matrix); m_cylinder.model.set_color(colors.front()); m_cylinder.model.render(); if (update_raycasters) { auto it = m_raycasters.find(EDGE_ID); if (it != m_raycasters.end() && it->second != nullptr) it->second->set_transform(feature_matrix); } break; } case Measure::SurfaceFeatureType::Plane: { const auto& [idx, normal, pt] = feature.get_plane(); assert(idx < m_plane_models_cache.size()); set_matrix_uniforms(model_matrix); m_plane_models_cache[idx].set_color(colors.front()); m_plane_models_cache[idx].render(); if (update_raycasters) { auto it = m_raycasters.find(PLANE_ID); if (it != m_raycasters.end() && it->second != nullptr) it->second->set_transform(model_matrix); } break; } } }; auto hover_selection_color = [this]() { return saturate(!m_selected_features.first.feature.has_value() ? SELECTED_1ST_COLOR : SELECTED_2ND_COLOR, 1.5f); }; auto hovering_color = [this, hover_selection_color, &selection]() { return (m_mode == EMode::ExtendedSelection) ? selection.get_first_volume()->render_color : hover_selection_color(); }; if (m_curr_feature.has_value()) { std::vector colors; if (m_selected_features.first.feature.has_value() && *m_curr_feature == *m_selected_features.first.feature) colors.emplace_back(SELECTED_1ST_COLOR); else if (m_selected_features.second.feature.has_value() && *m_curr_feature == *m_selected_features.second.feature) colors.emplace_back(SELECTED_2ND_COLOR); else { switch (m_curr_feature->get_type()) { default: { assert(false); break; } case Measure::SurfaceFeatureType::Point: { colors.emplace_back(hover_selection_color()); break; } case Measure::SurfaceFeatureType::Circle: { colors.emplace_back((m_hover_id == POINT_ID) ? hover_selection_color() : hovering_color()); colors.emplace_back(hovering_color()); break; } case Measure::SurfaceFeatureType::Edge: case Measure::SurfaceFeatureType::Plane: { colors.emplace_back(hovering_color()); break; } } } render_feature(*m_curr_feature, colors, m_volume_matrix, inv_zoom, true); } if (m_selected_features.first.feature.has_value() && (!m_curr_feature.has_value() || *m_curr_feature != *m_selected_features.first.feature)) { std::vector colors; colors.emplace_back(SELECTED_1ST_COLOR); render_feature(*m_selected_features.first.feature, colors, m_volume_matrix, inv_zoom, false); } if (m_selected_features.second.feature.has_value() && (!m_curr_feature.has_value() || *m_curr_feature != *m_selected_features.second.feature)) { std::vector colors; colors.emplace_back(SELECTED_2ND_COLOR); render_feature(*m_selected_features.second.feature, colors, m_volume_matrix, inv_zoom, false); } if (is_hovering_on_locked_feature && m_curr_point_on_feature_position.has_value()) { if (m_hover_id != POINT_ID) { const Transform3d matrix = m_volume_matrix * Geometry::translation_transform(*m_curr_point_on_feature_position) * Geometry::scale_transform(inv_zoom); set_matrix_uniforms(matrix); m_sphere.model.set_color(hover_selection_color()); m_sphere.model.render(); } } shader->stop_using(); } render_dimensioning(); } void GLGizmoMeasure::update_if_needed() { auto update_plane_models_cache = [this](const indexed_triangle_set& its) { m_plane_models_cache.clear(); const std::vector> planes_triangles = m_measuring->get_planes_triangle_indices(); for (int idx = 0; idx < (int)planes_triangles.size(); ++idx) { m_plane_models_cache.emplace_back(GLModel()); GLModel::Geometry init_data = init_plane_data(its, planes_triangles, idx); m_plane_models_cache.back().init_from(std::move(init_data)); } }; auto do_update = [this, update_plane_models_cache](const ModelObject* object, const ModelVolume* volume) { const indexed_triangle_set& its = (volume != nullptr) ? volume->mesh().its : object->volumes.front()->mesh().its; m_measuring.reset(new Measure::Measuring(its)); update_plane_models_cache(its); // Let's save what we calculated it from: m_volumes_matrices.clear(); m_volumes_types.clear(); m_first_instance_scale = Vec3d::Ones(); m_first_instance_mirror = Vec3d::Ones(); if (object != nullptr) { for (const ModelVolume* vol : object->volumes) { m_volumes_matrices.push_back(vol->get_matrix()); m_volumes_types.push_back(vol->type()); } m_first_instance_scale = object->instances.front()->get_scaling_factor(); m_first_instance_mirror = object->instances.front()->get_mirror(); } m_old_model_object = object; m_old_model_volume = volume; }; const ModelObject* mo = m_c->selection_info()->model_object(); const ModelVolume* mv = m_c->selection_info()->model_volume(); if (m_state != On || (mo == nullptr && mv == nullptr)) return; if (mo == nullptr) mo = mv->get_object(); if (mo->instances.empty()) return; if (!m_measuring || mo != m_old_model_object || mv != m_old_model_volume || mo->volumes.size() != m_volumes_matrices.size()) do_update(mo, mv); // We want to recalculate when the scale changes - some planes could (dis)appear. if (!mo->instances.front()->get_scaling_factor().isApprox(m_first_instance_scale) || !mo->instances.front()->get_mirror().isApprox(m_first_instance_mirror)) do_update(mo, mv); for (unsigned int i = 0; i < mo->volumes.size(); ++i) { if (!mo->volumes[i]->get_matrix().isApprox(m_volumes_matrices[i]) || mo->volumes[i]->type() != m_volumes_types[i]) { do_update(mo, mv); break; } } } void GLGizmoMeasure::disable_scene_raycasters() { if (m_scene_raycasters != nullptr) { for (auto r : *m_scene_raycasters) { r->set_active(false); } } } void GLGizmoMeasure::restore_scene_raycasters_state() { if (m_scene_raycasters != nullptr) { assert(m_scene_raycasters->size() == m_scene_raycaster_state.size()); for (size_t i = 0; i < m_scene_raycasters->size(); ++i) { (*m_scene_raycasters)[i]->set_active(m_scene_raycaster_state[i]); } } } class DimensioningHelper { struct Cache { std::array viewport; Matrix4d ndc_to_ss_matrix; Transform3d ndc_to_ss_matrix_inverse; }; static Cache s_cache; public: static Vec3d model_to_world(const Vec3d& model, const Transform3d& world_matrix) { return world_matrix * model; } static Vec4d world_to_clip(const Vec3d& world, const Matrix4d& projection_view_matrix) { return projection_view_matrix * Vec4d(world.x(), world.y(), world.z(), 1.0); } static Vec3d clip_to_ndc(const Vec4d& clip) { return Vec3d(clip.x(), clip.y(), clip.z()) / clip.w(); } static Vec2d ndc_to_ss(const Vec3d& ndc, const std::array& viewport) { const double half_w = 0.5 * double(viewport[2]); const double half_h = 0.5 * double(viewport[3]); return { half_w * ndc.x() + double(viewport[0]) + half_w, half_h * ndc.y() + double(viewport[1]) + half_h }; }; static Vec4d model_to_clip(const Vec3d& model, const Transform3d& world_matrix, const Matrix4d& projection_view_matrix) { return world_to_clip(model_to_world(model, world_matrix), projection_view_matrix); } static Vec3d model_to_ndc(const Vec3d& model, const Transform3d& world_matrix, const Matrix4d& projection_view_matrix) { return clip_to_ndc(world_to_clip(model_to_world(model, world_matrix), projection_view_matrix)); } static Vec2d model_to_ss(const Vec3d& model, const Transform3d& world_matrix, const Matrix4d& projection_view_matrix, const std::array& viewport) { return ndc_to_ss(clip_to_ndc(world_to_clip(model_to_world(model, world_matrix), projection_view_matrix)), viewport); } static const Matrix4d& ndc_to_ss_matrix(const std::array& viewport) { update(viewport); return s_cache.ndc_to_ss_matrix; } static const Transform3d ndc_to_ss_matrix_inverse(const std::array& viewport) { update(viewport); return s_cache.ndc_to_ss_matrix_inverse; } private: static void update(const std::array& viewport) { if (s_cache.viewport == viewport) return; const double half_w = 0.5 * double(viewport[2]); const double half_h = 0.5 * double(viewport[3]); s_cache.ndc_to_ss_matrix << half_w, 0.0, 0.0, double(viewport[0]) + half_w, 0.0, half_h, 0.0, double(viewport[1]) + half_h, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0; s_cache.ndc_to_ss_matrix_inverse = s_cache.ndc_to_ss_matrix.inverse(); s_cache.viewport = viewport; } }; DimensioningHelper::Cache DimensioningHelper::s_cache = { { 0, 0, 0, 0 }, Matrix4d::Identity(), Transform3d::Identity() }; void GLGizmoMeasure::render_dimensioning() { if (!m_selected_features.first.feature.has_value() || !m_selected_features.second.feature.has_value()) return; GLShaderProgram* shader = wxGetApp().get_shader("flat"); if (shader == nullptr) return; auto point_point = [this, shader](const Vec3d& v1, const Vec3d& v2) { if (v1.isApprox(v2)) return; const Camera& camera = wxGetApp().plater()->get_camera(); const Matrix4d projection_view_matrix = camera.get_projection_matrix().matrix() * camera.get_view_matrix().matrix(); const std::array& viewport = camera.get_viewport(); // screen coordinates const Vec2d v1ss = DimensioningHelper::model_to_ss(v1, m_volume_matrix, projection_view_matrix, viewport); const Vec2d v2ss = DimensioningHelper::model_to_ss(v2, m_volume_matrix, projection_view_matrix, viewport); if (v1ss.isApprox(v2ss)) return; const Vec2d v12ss = v2ss - v1ss; const double v12ss_len = v12ss.norm(); const bool overlap = v12ss_len - 2.0 * TRIANGLE_HEIGHT < 0.0; const auto q12ss = Eigen::Quaternion::FromTwoVectors(Vec3d::UnitX(), Vec3d(v12ss.x(), v12ss.y(), 0.0)); const auto q21ss = Eigen::Quaternion::FromTwoVectors(Vec3d::UnitX(), Vec3d(-v12ss.x(), -v12ss.y(), 0.0)); shader->set_uniform("projection_matrix", Transform3d::Identity()); const Vec3d v1ss_3 = { v1ss.x(), v1ss.y(), 0.0 }; const Vec3d v2ss_3 = { v2ss.x(), v2ss.y(), 0.0 }; const Transform3d ss_to_ndc_matrix = DimensioningHelper::ndc_to_ss_matrix_inverse(viewport); // stem shader->set_uniform("view_model_matrix", overlap ? ss_to_ndc_matrix * Geometry::translation_transform(v1ss_3) * q12ss * Geometry::translation_transform(-2.0 * TRIANGLE_HEIGHT * Vec3d::UnitX()) * Geometry::scale_transform({ v12ss_len + 4.0 * TRIANGLE_HEIGHT, 1.0f, 1.0f }) : ss_to_ndc_matrix * Geometry::translation_transform(v1ss_3) * q12ss * Geometry::scale_transform({ v12ss_len, 1.0f, 1.0f })); m_dimensioning.line.render(); // arrow 1 shader->set_uniform("view_model_matrix", overlap ? ss_to_ndc_matrix * Geometry::translation_transform(v1ss_3) * q12ss : ss_to_ndc_matrix * Geometry::translation_transform(v1ss_3) * q21ss); m_dimensioning.triangle.render(); // arrow 2 shader->set_uniform("view_model_matrix", overlap ? ss_to_ndc_matrix * Geometry::translation_transform(v2ss_3) * q21ss : ss_to_ndc_matrix * Geometry::translation_transform(v2ss_3) * q12ss); m_dimensioning.triangle.render(); }; auto point_edge = [this, shader, point_point](const Vec3d& v, const Edge& e) { const auto [distance, v1, v_proj] = distance_point_edge(v, e); point_point(v1, v_proj); const Vec3d e1e2 = e.second - e.first; const Vec3d v_proje1 = v_proj - e.first; const bool on_e1_side = v_proje1.dot(e1e2) < 0.0; const bool on_e2_side = v_proje1.norm() > e1e2.norm(); if (on_e1_side || on_e2_side) { const Camera& camera = wxGetApp().plater()->get_camera(); const Matrix4d projection_view_matrix = camera.get_projection_matrix().matrix() * camera.get_view_matrix().matrix(); const std::array& viewport = camera.get_viewport(); const Transform3d ss_to_ndc_matrix = DimensioningHelper::ndc_to_ss_matrix_inverse(viewport); const Vec2d v_projss = DimensioningHelper::model_to_ss(v_proj, m_volume_matrix, projection_view_matrix, viewport); auto render_extension = [this, &v_projss, &projection_view_matrix, &viewport, &ss_to_ndc_matrix, shader](const Vec3d& p) { const Vec2d pss = DimensioningHelper::model_to_ss(p, m_volume_matrix, projection_view_matrix, viewport); if (!pss.isApprox(v_projss)) { const Vec2d pv_projss = v_projss - pss; const double pv_projss_len = pv_projss.norm(); const auto q = Eigen::Quaternion::FromTwoVectors(Vec3d::UnitX(), Vec3d(pv_projss.x(), pv_projss.y(), 0.0)); shader->set_uniform("projection_matrix", Transform3d::Identity()); shader->set_uniform("view_model_matrix", ss_to_ndc_matrix * Geometry::translation_transform({ pss.x(), pss.y(), 0.0 }) * q * Geometry::scale_transform({ pv_projss_len, 1.0f, 1.0f })); m_dimensioning.line.render(); } }; render_extension(on_e1_side ? e.first : e.second); } }; auto point_plane = [point_point](const Vec3d& v, const Plane& p) { const auto [distance, v1, v2] = distance_point_plane(v, p); point_point(v1, v2); }; auto point_circle = [point_point](const Vec3d& v, const Circle& c) { const auto [distance, v1, v2] = distance_point_circle(v, c); point_point(v1, v2); }; auto edge_edge = [point_point](const Edge& e1, const Edge& e2) { const auto [distance, v1, v2] = distance_edge_edge(e1, e2); point_point(v1, v2); }; auto edge_circle = [point_point](const Edge& e, const Circle& c) { const auto [distance, v1, v2] = distance_edge_circle(e, c); point_point(v1, v2); }; auto plane_plane = [point_point](const Plane& p1, const Plane& p2) { const auto [distance, v1, v2] = distance_plane_plane(p1, p2); point_point(v1, v2); }; shader->start_using(); if (!m_dimensioning.line.is_initialized()) { GLModel::Geometry init_data; init_data.format = { GLModel::Geometry::EPrimitiveType::Lines, GLModel::Geometry::EVertexLayout::P3 }; init_data.color = ColorRGBA::WHITE(); init_data.reserve_vertices(2); init_data.reserve_indices(2); // vertices init_data.add_vertex(Vec3f(0.0f, 0.0f, 0.0f)); init_data.add_vertex(Vec3f(1.0f, 0.0f, 0.0f)); // indices init_data.add_line(0, 1); m_dimensioning.line.init_from(std::move(init_data)); } if (!m_dimensioning.triangle.is_initialized()) { GLModel::Geometry init_data; init_data.format = { GLModel::Geometry::EPrimitiveType::Triangles, GLModel::Geometry::EVertexLayout::P3 }; init_data.color = ColorRGBA::WHITE(); init_data.reserve_vertices(3); init_data.reserve_indices(3); // vertices init_data.add_vertex(Vec3f(0.0f, 0.0f, 0.0f)); init_data.add_vertex(Vec3f(-TRIANGLE_HEIGHT, 0.5f * TRIANGLE_BASE, 0.0f)); init_data.add_vertex(Vec3f(-TRIANGLE_HEIGHT, -0.5f * TRIANGLE_BASE, 0.0f)); // indices init_data.add_triangle(0, 1, 2); m_dimensioning.triangle.init_from(std::move(init_data)); } glsafe(::glDisable(GL_DEPTH_TEST)); // point-point if (m_selected_features.first.feature->get_type() == Measure::SurfaceFeatureType::Point && m_selected_features.second.feature->get_type() == Measure::SurfaceFeatureType::Point) { point_point(m_selected_features.first.feature->get_point(), m_selected_features.second.feature->get_point()); } // point-edge else if (m_selected_features.first.feature->get_type() == Measure::SurfaceFeatureType::Point && m_selected_features.second.feature->get_type() == Measure::SurfaceFeatureType::Edge) { point_edge(m_selected_features.first.feature->get_point(), m_selected_features.second.feature->get_edge()); } // point-plane else if (m_selected_features.first.feature->get_type() == Measure::SurfaceFeatureType::Point && m_selected_features.second.feature->get_type() == Measure::SurfaceFeatureType::Plane) { point_plane(m_selected_features.first.feature->get_point(), m_selected_features.second.feature->get_plane()); } // point-circle else if (m_selected_features.first.feature->get_type() == Measure::SurfaceFeatureType::Point && m_selected_features.second.feature->get_type() == Measure::SurfaceFeatureType::Circle) { point_circle(m_selected_features.first.feature->get_point(), m_selected_features.second.feature->get_circle()); } // edge-point else if (m_selected_features.first.feature->get_type() == Measure::SurfaceFeatureType::Edge && m_selected_features.second.feature->get_type() == Measure::SurfaceFeatureType::Point) { point_edge(m_selected_features.second.feature->get_point(), m_selected_features.first.feature->get_edge()); } // plane-point else if (m_selected_features.first.feature->get_type() == Measure::SurfaceFeatureType::Plane && m_selected_features.second.feature->get_type() == Measure::SurfaceFeatureType::Point) { point_plane(m_selected_features.second.feature->get_point(), m_selected_features.first.feature->get_plane()); } // circle-point else if (m_selected_features.first.feature->get_type() == Measure::SurfaceFeatureType::Circle && m_selected_features.second.feature->get_type() == Measure::SurfaceFeatureType::Point) { point_circle(m_selected_features.second.feature->get_point(), m_selected_features.first.feature->get_circle()); } // edge-edge else if (m_selected_features.first.feature->get_type() == Measure::SurfaceFeatureType::Edge && m_selected_features.second.feature->get_type() == Measure::SurfaceFeatureType::Edge) { edge_edge(m_selected_features.first.feature->get_edge(), m_selected_features.second.feature->get_edge()); } // edge-circle else if (m_selected_features.first.feature->get_type() == Measure::SurfaceFeatureType::Edge && m_selected_features.second.feature->get_type() == Measure::SurfaceFeatureType::Circle) { edge_circle(m_selected_features.first.feature->get_edge(), m_selected_features.second.feature->get_circle()); } // plane-plane else if (m_selected_features.first.feature->get_type() == Measure::SurfaceFeatureType::Plane && m_selected_features.second.feature->get_type() == Measure::SurfaceFeatureType::Plane) { plane_plane(m_selected_features.first.feature->get_plane(), m_selected_features.second.feature->get_plane()); } // circle-edge else if (m_selected_features.first.feature->get_type() == Measure::SurfaceFeatureType::Circle && m_selected_features.second.feature->get_type() == Measure::SurfaceFeatureType::Edge) { edge_circle(m_selected_features.second.feature->get_edge(), m_selected_features.first.feature->get_circle()); } glsafe(::glEnable(GL_DEPTH_TEST)); shader->stop_using(); } static void add_row_to_table(std::function col_1 = nullptr, std::function col_2 = nullptr) { assert(col_1 != nullptr && col_2 != nullptr); ImGui::TableNextRow(); ImGui::TableSetColumnIndex(0); col_1(); ImGui::TableSetColumnIndex(1); col_2(); }; static void add_strings_row_to_table(ImGuiWrapper& imgui, const std::string& col_1, const ImVec4& col_1_color, const std::string& col_2, const ImVec4& col_2_color) { add_row_to_table([&]() { imgui.text_colored(col_1_color, col_1); }, [&]() { imgui.text_colored(col_2_color, col_2); }); }; static std::string format_double(double value) { char buf[1024]; sprintf(buf, "%.3f", value); return std::string(buf); }; static std::string format_vec3(const Vec3d& v) { char buf[1024]; sprintf(buf, "X: %.3f, Y: %.3f, Z: %.3f", v.x(), v.y(), v.z()); return std::string(buf); }; #if ENABLE_MEASURE_GIZMO_DEBUG void GLGizmoMeasure::render_debug_dialog() { auto add_feature_data = [this](const SelectedFeatures::Item& item) { add_strings_row_to_table(*m_imgui, "Type", ImGuiWrapper::COL_ORANGE_LIGHT, item.source, ImGui::GetStyleColorVec4(ImGuiCol_Text)); switch (item.feature->get_type()) { case Measure::SurfaceFeatureType::Point: { add_strings_row_to_table(*m_imgui, "m_pt1", ImGuiWrapper::COL_ORANGE_LIGHT, format_vec3(item.feature->get_point()), ImGui::GetStyleColorVec4(ImGuiCol_Text)); break; } case Measure::SurfaceFeatureType::Edge: { auto [from, to] = item.feature->get_edge(); add_strings_row_to_table(*m_imgui, "m_pt1", ImGuiWrapper::COL_ORANGE_LIGHT, format_vec3(from), ImGui::GetStyleColorVec4(ImGuiCol_Text)); add_strings_row_to_table(*m_imgui, "m_pt2", ImGuiWrapper::COL_ORANGE_LIGHT, format_vec3(to), ImGui::GetStyleColorVec4(ImGuiCol_Text)); break; } case Measure::SurfaceFeatureType::Plane: { auto [idx, normal, origin] = item.feature->get_plane(); add_strings_row_to_table(*m_imgui, "m_pt1", ImGuiWrapper::COL_ORANGE_LIGHT, format_vec3(normal), ImGui::GetStyleColorVec4(ImGuiCol_Text)); add_strings_row_to_table(*m_imgui, "m_pt2", ImGuiWrapper::COL_ORANGE_LIGHT, format_vec3(origin), ImGui::GetStyleColorVec4(ImGuiCol_Text)); add_strings_row_to_table(*m_imgui, "m_value", ImGuiWrapper::COL_ORANGE_LIGHT, format_double(idx), ImGui::GetStyleColorVec4(ImGuiCol_Text)); break; } case Measure::SurfaceFeatureType::Circle: { auto [center, radius, normal] = item.feature->get_circle(); add_strings_row_to_table(*m_imgui, "m_pt1", ImGuiWrapper::COL_ORANGE_LIGHT, format_vec3(center), ImGui::GetStyleColorVec4(ImGuiCol_Text)); add_strings_row_to_table(*m_imgui, "m_pt2", ImGuiWrapper::COL_ORANGE_LIGHT, format_vec3(normal), ImGui::GetStyleColorVec4(ImGuiCol_Text)); add_strings_row_to_table(*m_imgui, "m_value", ImGuiWrapper::COL_ORANGE_LIGHT, format_double(radius), ImGui::GetStyleColorVec4(ImGuiCol_Text)); break; } } std::optional extra_point = item.feature->get_extra_point(); if (extra_point.has_value()) add_strings_row_to_table(*m_imgui, "m_pt3", ImGuiWrapper::COL_ORANGE_LIGHT, format_vec3(*extra_point), ImGui::GetStyleColorVec4(ImGuiCol_Text)); }; m_imgui->begin(_L("Measure tool debug"), ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse); if (!m_selected_features.first.feature.has_value() && !m_selected_features.second.feature.has_value()) m_imgui->text("Empty selection"); else { const ImGuiTableFlags flags = ImGuiTableFlags_BordersOuter | ImGuiTableFlags_BordersH; if (m_selected_features.first.feature.has_value()) { m_imgui->text_colored(ImGuiWrapper::COL_ORANGE_LIGHT, "Selection 1"); if (ImGui::BeginTable("Selection 1", 2, flags)) { add_feature_data(m_selected_features.first); ImGui::EndTable(); } } if (m_selected_features.second.feature.has_value()) { m_imgui->text_colored(ImGuiWrapper::COL_ORANGE_LIGHT, "Selection 2"); if (ImGui::BeginTable("Selection 2", 2, flags)) { add_feature_data(m_selected_features.second); ImGui::EndTable(); } } } m_imgui->end(); } #endif // ENABLE_MEASURE_GIZMO_DEBUG void GLGizmoMeasure::on_render_input_window(float x, float y, float bottom_limit) { static std::optional last_feature; static EMode last_mode = EMode::BasicSelection; static SelectedFeatures last_selected_features; static float last_y = 0.0f; static float last_h = 0.0f; m_imgui->begin(_L("Measure tool"), ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse); // adjust window position to avoid overlap the view toolbar const float win_h = ImGui::GetWindowHeight(); y = std::min(y, bottom_limit - win_h); ImGui::SetWindowPos(ImVec2(x, y), ImGuiCond_Always); if (last_h != win_h || last_y != y) { // ask canvas for another frame to render the window in the correct position m_imgui->set_requires_extra_frame(); if (last_h != win_h) last_h = win_h; if (last_y != y) last_y = y; } if (ImGui::BeginTable("Commands", 2)) { add_row_to_table( [this]() { m_imgui->text_colored(ImGuiWrapper::COL_ORANGE_LIGHT, _u8L("Left mouse button")); }, [this]() { m_imgui->text_colored(ImGui::GetStyleColorVec4(ImGuiCol_Text), (m_mode == EMode::BasicSelection) ? _u8L("Select feature") : _u8L("Select point")); ImGui::SameLine(); const ImVec2 pos = ImGui::GetCursorScreenPos(); const float rect_size = ImGui::GetTextLineHeight(); ImGui::GetWindowDrawList()->AddRectFilled({ pos.x + 1.0f, pos.y + 1.0f }, { pos.x + rect_size, pos.y + rect_size }, ImGuiWrapper::to_ImU32(m_selected_features.first.feature.has_value() ? SELECTED_2ND_COLOR : SELECTED_1ST_COLOR)); ImGui::Dummy(ImVec2(rect_size, rect_size)); } ); if (m_selected_features.first.feature.has_value()) add_strings_row_to_table(*m_imgui, CTRL_STR + "+" + _u8L("Right mouse button"), ImGuiWrapper::COL_ORANGE_LIGHT, _u8L("Restart selection"), ImGui::GetStyleColorVec4(ImGuiCol_Text)); if (m_mode == EMode::BasicSelection && m_hover_id != -1) add_strings_row_to_table(*m_imgui, CTRL_STR, ImGuiWrapper::COL_ORANGE_LIGHT, _u8L("Enable point selection"), ImGui::GetStyleColorVec4(ImGuiCol_Text)); ImGui::EndTable(); } const bool use_inches = wxGetApp().app_config->get("use_inches") == "1"; const std::string units = use_inches ? _u8L(" (in)") : _u8L(" (mm)"); if (m_curr_feature.has_value()) { const Measure::SurfaceFeatureType feature_type = m_curr_feature->get_type(); if (m_mode == EMode::BasicSelection) { if (feature_type != Measure::SurfaceFeatureType::Undef) { ImGui::Separator(); m_imgui->text(surface_feature_type_as_string(feature_type) + ":"); if (ImGui::BeginTable("Data", 2)) { switch (feature_type) { default: { assert(false); break; } case Measure::SurfaceFeatureType::Point: { Vec3d position = m_volume_matrix * m_curr_feature->get_point(); if (use_inches) position = ObjectManipulation::mm_to_in * position; add_strings_row_to_table(*m_imgui, _u8L("Position"), ImGuiWrapper::COL_ORANGE_LIGHT, format_vec3(position), ImGui::GetStyleColorVec4(ImGuiCol_Text)); break; } case Measure::SurfaceFeatureType::Edge: { auto [from, to] = m_curr_feature->get_edge(); from = m_volume_matrix * from; to = m_volume_matrix * to; if (use_inches) { from = ObjectManipulation::mm_to_in * from; to = ObjectManipulation::mm_to_in * to; } add_strings_row_to_table(*m_imgui, _u8L("From"), ImGuiWrapper::COL_ORANGE_LIGHT, format_vec3(from), ImGui::GetStyleColorVec4(ImGuiCol_Text)); add_strings_row_to_table(*m_imgui, _u8L("To"), ImGuiWrapper::COL_ORANGE_LIGHT, format_vec3(to), ImGui::GetStyleColorVec4(ImGuiCol_Text)); add_strings_row_to_table(*m_imgui, _u8L("Length") + units, ImGuiWrapper::COL_ORANGE_LIGHT, format_double((to - from).norm()), ImGui::GetStyleColorVec4(ImGuiCol_Text)); break; } case Measure::SurfaceFeatureType::Circle: { auto [center, radius, normal] = m_curr_feature->get_circle(); center = m_volume_matrix * center; normal = m_volume_matrix.matrix().block(0, 0, 3, 3).inverse().transpose() * normal; if (use_inches) { center = ObjectManipulation::mm_to_in * center; radius = ObjectManipulation::mm_to_in * radius; } add_strings_row_to_table(*m_imgui, _u8L("Center"), ImGuiWrapper::COL_ORANGE_LIGHT, format_vec3(center), ImGui::GetStyleColorVec4(ImGuiCol_Text)); add_strings_row_to_table(*m_imgui, _u8L("Radius") + units, ImGuiWrapper::COL_ORANGE_LIGHT, format_double(radius), ImGui::GetStyleColorVec4(ImGuiCol_Text)); add_strings_row_to_table(*m_imgui, _u8L("Normal"), ImGuiWrapper::COL_ORANGE_LIGHT, format_vec3(normal), ImGui::GetStyleColorVec4(ImGuiCol_Text)); break; } case Measure::SurfaceFeatureType::Plane: { auto [idx, normal, origin] = m_curr_feature->get_plane(); origin = m_volume_matrix * origin; normal = m_volume_matrix.matrix().block(0, 0, 3, 3).inverse().transpose() * normal; if (use_inches) origin = ObjectManipulation::mm_to_in * origin; add_strings_row_to_table(*m_imgui, _u8L("Origin"), ImGuiWrapper::COL_ORANGE_LIGHT, format_vec3(origin), ImGui::GetStyleColorVec4(ImGuiCol_Text)); add_strings_row_to_table(*m_imgui, _u8L("Normal"), ImGuiWrapper::COL_ORANGE_LIGHT, format_vec3(normal), ImGui::GetStyleColorVec4(ImGuiCol_Text)); break; } } ImGui::EndTable(); } } } else if (m_mode == EMode::ExtendedSelection) { if (m_hover_id != -1 && m_curr_point_on_feature_position.has_value()) { ImGui::Separator(); m_imgui->text(point_on_feature_type_as_string(feature_type, m_hover_id) + ":"); if (ImGui::BeginTable("Data", 2)) { Vec3d position = m_volume_matrix * *m_curr_point_on_feature_position; if (use_inches) position = ObjectManipulation::mm_to_in * position; add_strings_row_to_table(*m_imgui, _u8L("Position"), ImGuiWrapper::COL_ORANGE_LIGHT, format_vec3(position), ImGui::GetStyleColorVec4(ImGuiCol_Text)); ImGui::EndTable(); } } } } ImGui::Separator(); const ImGuiTableFlags flags = ImGuiTableFlags_BordersOuter | ImGuiTableFlags_BordersH; if (ImGui::BeginTable("Selection", 2, flags)) { add_strings_row_to_table(*m_imgui, _u8L("Selection") + " 1:", ImGuiWrapper::to_ImVec4(SELECTED_1ST_COLOR), m_selected_features.first.feature.has_value() ? m_selected_features.first.source : _u8L("None"), ImGuiWrapper::to_ImVec4(SELECTED_1ST_COLOR)); add_strings_row_to_table(*m_imgui, _u8L("Selection") + " 2:", ImGuiWrapper::to_ImVec4(SELECTED_2ND_COLOR), m_selected_features.second.feature.has_value() ? m_selected_features.second.source : _u8L("None"), ImGuiWrapper::to_ImVec4(SELECTED_2ND_COLOR)); ImGui::EndTable(); } //if (m_selected_features.first.feature.has_value()) { // if (m_imgui->button(_u8L("Restart"))) { // m_selected_features.reset(); // m_imgui->set_requires_extra_frame(); // } //} if (m_selected_features.second.feature.has_value()) { const Measure::MeasurementResult measure = Measure::get_measurement(*m_selected_features.first.feature, *m_selected_features.second.feature); ImGui::Separator(); if (measure.has_any_data()) { m_imgui->text(_u8L("Measure") + ":"); if (ImGui::BeginTable("Measure", 2)) { if (measure.angle.has_value()) { add_strings_row_to_table(*m_imgui, _u8L("Angle") + _u8L(" (°)"), ImGuiWrapper::COL_ORANGE_LIGHT, format_double(Geometry::rad2deg(*measure.angle)), ImGui::GetStyleColorVec4(ImGuiCol_Text)); } if (measure.distance_infinite.has_value()) { double distance = *measure.distance_infinite; if (use_inches) distance = ObjectManipulation::mm_to_in * distance; add_strings_row_to_table(*m_imgui, _u8L("Distance Infinite") + units, ImGuiWrapper::COL_ORANGE_LIGHT, format_double(distance), ImGui::GetStyleColorVec4(ImGuiCol_Text)); } if (measure.distance_strict.has_value()) { double distance = *measure.distance_strict; if (use_inches) distance = ObjectManipulation::mm_to_in * distance; add_strings_row_to_table(*m_imgui, _u8L("Distance Strict") + units, ImGuiWrapper::COL_ORANGE_LIGHT, format_double(distance), ImGui::GetStyleColorVec4(ImGuiCol_Text)); } if (measure.distance_xyz.has_value()) { Vec3d distance = *measure.distance_xyz; if (use_inches) distance = ObjectManipulation::mm_to_in * distance; add_strings_row_to_table(*m_imgui, _u8L("Distance XYZ") + units, ImGuiWrapper::COL_ORANGE_LIGHT, format_vec3(distance), ImGui::GetStyleColorVec4(ImGuiCol_Text)); } ImGui::EndTable(); } } else m_imgui->text(_u8L("No measure available")); } if (last_feature != m_curr_feature || last_mode != m_mode || last_selected_features != m_selected_features) { // the dialog may have changed its size, ask for an extra frame to render it properly last_feature = m_curr_feature; last_mode = m_mode; last_selected_features = m_selected_features; m_imgui->set_requires_extra_frame(); } m_imgui->end(); } void GLGizmoMeasure::on_register_raycasters_for_picking() { // the features are rendered on top of the scene, so the raytraced picker should take it into account m_parent.set_raycaster_gizmos_on_top(true); } void GLGizmoMeasure::on_unregister_raycasters_for_picking() { m_parent.remove_raycasters_for_picking(SceneRaycaster::EType::Gizmo); m_parent.set_raycaster_gizmos_on_top(false); m_raycasters.clear(); } } // namespace GUI } // namespace Slic3r #endif // ENABLE_MEASURE_GIZMO