juli/OrcaSlicer
1
1
Fork 0
mirror of https://github.com/OrcaSlicer/OrcaSlicer.git synced 2026-09-10 02:37:04 +00:00
Code Issues Packages Projects Releases Wiki Activity

Measure: Port of BBS' improved version of measure gizmo

Browse Source 
Co-authored-by:  zhou.xu <zhou.xu@bambulab.com>
This commit is contained in:
Noisyfox
2024-11-05 21:45:50 +08:00
parent 1088d0a6c7
commit 6e9257c8ac
16 changed files with 1672 additions and 866 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
src/slic3r/GUI/Gizmos/GLGizmoBase.hpp
View File

@@ -8,6 +8,7 @@
#include "slic3r/GUI/GLModel.hpp"
#include "slic3r/GUI/MeshUtils.hpp"
#include "slic3r/GUI/SceneRaycaster.hpp"
#include "slic3r/GUI/3DScene.hpp"
#include <cereal/archives/binary.hpp>
@@ -181,6 +182,13 @@ public:
virtual bool apply_clipping_plane() { return true; }
/// <summary>
/// Implement when want to process mouse events in gizmo
/// Click, Right click, move, drag, ...
/// </summary>
/// <param name="mouse_event">Keep information about mouse click</param>
/// <returns>Return True when use the information and don't want to propagate it otherwise False.</returns>
virtual bool on_mouse(const wxMouseEvent &mouse_event) { return false; }
unsigned int get_sprite_id() const { return m_sprite_id; }
int get_hover_id() const { return m_hover_id; }
@@ -209,14 +217,6 @@ public:
/// </summary>
virtual void data_changed(bool is_serializing){};
/// <summary>
/// Implement when want to process mouse events in gizmo
/// Click, Right click, move, drag, ...
/// </summary>
/// <param name="mouse_event">Keep information about mouse click</param>
/// <returns>Return True when use the information and don't want to propagate it otherwise False.</returns>
virtual bool on_mouse(const wxMouseEvent &mouse_event) { return false; }
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(); }

1677
src/slic3r/GUI/Gizmos/GLGizmoMeasure.cpp
View File

File diff suppressed because it is too large Load Diff

209
src/slic3r/GUI/Gizmos/GLGizmoMeasure.hpp
View File

@@ -12,16 +12,85 @@
namespace Slic3r {
enum class ModelVolumeType : int;
namespace Measure { class Measuring; }
namespace GUI {
enum class SLAGizmoEventType : unsigned char;
enum class EMeasureMode : unsigned char {
ONLY_MEASURE,
ONLY_ASSEMBLY
};
enum class AssemblyMode : unsigned char {
FACE_FACE,
POINT_POINT,
};
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 Slic3r::ColorRGBA NEUTRAL_COLOR = {0.5f, 0.5f, 0.5f, 1.0f};
static const Slic3r::ColorRGBA HOVER_COLOR = ColorRGBA::GREEN();
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 int SEL_SPHERE_1_ID = 501;
static const int SEL_SPHERE_2_ID = 502;
static const float TRIANGLE_BASE = 10.0f;
static const float TRIANGLE_HEIGHT = TRIANGLE_BASE * 1.618033f;
static const std::string CTRL_STR =
#ifdef __APPLE__
"⌘"
#else
"Ctrl"
#endif //__APPLE__
;
class TransformHelper
{
struct Cache
{
std::array<int, 4> 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);
static Vec4d world_to_clip(const Vec3d &world, const Matrix4d &projection_view_matrix);
static Vec3d clip_to_ndc(const Vec4d &clip);
static Vec2d ndc_to_ss(const Vec3d &ndc, const std::array<int, 4> &viewport);
static Vec4d model_to_clip(const Vec3d &model, const Transform3d &world_matrix, const Matrix4d &projection_view_matrix);
static Vec3d model_to_ndc(const Vec3d &model, const Transform3d &world_matrix, const Matrix4d &projection_view_matrix);
static Vec2d model_to_ss(const Vec3d &model, const Transform3d &world_matrix, const Matrix4d &projection_view_matrix, const std::array<int, 4> &viewport);
static Vec2d world_to_ss(const Vec3d &world, const Matrix4d &projection_view_matrix, const std::array<int, 4> &viewport);
static const Matrix4d & ndc_to_ss_matrix(const std::array<int, 4> &viewport);
static const Transform3d ndc_to_ss_matrix_inverse(const std::array<int, 4> &viewport);
private:
static void update(const std::array<int, 4> &viewport);
};
class GLGizmoMeasure : public GLGizmoBase
{
protected:
using PickRaycaster = SceneRaycasterItem;
enum GripperType {
UNDEFINE,
POINT,
EDGE,
CIRCLE,
CIRCLE_1,
CIRCLE_2,
PLANE,
PLANE_1,
PLANE_2,
SPHERE_1,
SPHERE_2,
};
enum class EMode : unsigned char
{
FeatureSelection,
@@ -69,30 +138,49 @@ class GLGizmoMeasure : public GLGizmoBase
}
};
struct VolumeCacheItem
{
const ModelObject* object{ nullptr };
const ModelInstance* instance{ nullptr };
const ModelVolume* volume{ nullptr };
Transform3d world_trafo;
//struct VolumeCacheItem
//{
// const ModelObject* object{ nullptr };
// const ModelInstance* instance{ nullptr };
// const ModelVolume* volume{ nullptr };
// Transform3d world_trafo;
bool operator == (const VolumeCacheItem& other) const {
return this->object == other.object && this->instance == other.instance && this->volume == other.volume &&
this->world_trafo.isApprox(other.world_trafo);
}
};
// bool operator == (const VolumeCacheItem& other) const {
// return this->object == other.object && this->instance == other.instance && this->volume == other.volume &&
// this->world_trafo.isApprox(other.world_trafo);
// }
//};
std::vector<VolumeCacheItem> m_volumes_cache;
//std::vector<VolumeCacheItem> m_volumes_cache;
EMode m_mode{ EMode::FeatureSelection };
Measure::MeasurementResult m_measurement_result;
std::map<GLVolume*, std::shared_ptr<Measure::Measuring>> m_mesh_measure_map;
std::shared_ptr<Measure::Measuring> m_curr_measuring{nullptr};
std::unique_ptr<Measure::Measuring> m_measuring; // PIMPL
//first feature
PickingModel m_sphere;
PickingModel m_cylinder;
PickingModel m_circle;
PickingModel m_plane;
struct CircleGLModel
{
PickingModel circle;
Measure::SurfaceFeature *last_circle_feature{nullptr};
float inv_zoom{0};
};
CircleGLModel m_curr_circle;
CircleGLModel m_feature_circle_first;
CircleGLModel m_feature_circle_second;
void init_circle_glmodel(GripperType gripper_type, const Measure::SurfaceFeature &feature, CircleGLModel &circle_gl_model, float inv_zoom);
struct PlaneGLModel {
int plane_idx{0};
PickingModel plane;
};
PlaneGLModel m_curr_plane;
PlaneGLModel m_feature_plane_first;
PlaneGLModel m_feature_plane_second;
void init_plane_glmodel(GripperType gripper_type, const Measure::SurfaceFeature &feature, PlaneGLModel &plane_gl_model);
struct Dimensioning
{
GLModel line;
@@ -101,40 +189,36 @@ class GLGizmoMeasure : public GLGizmoBase
};
Dimensioning m_dimensioning;
// Uses a standalone raycaster and not the shared one because of the
// difference in how the mesh is updated
std::unique_ptr<MeshRaycaster> m_raycaster;
std::vector<GLModel> m_plane_models_cache;
std::map<int, std::shared_ptr<SceneRaycasterItem>> m_raycasters;
std::map<GLVolume*, std::shared_ptr<PickRaycaster>> m_mesh_raycaster_map;
std::map<GripperType, std::shared_ptr<PickRaycaster>> m_gripper_id_raycast_map;
std::vector<GLVolume*> m_hit_different_volumes;
std::vector<GLVolume*> m_hit_order_volumes;
GLVolume* m_last_hit_volume;
//std::vector<std::shared_ptr<GLModel>> m_plane_models_cache;
unsigned int m_last_active_item_imgui{0};
Vec3d m_buffered_distance;
Vec3d m_distance;
// used to keep the raycasters for point/center spheres
std::vector<std::shared_ptr<SceneRaycasterItem>> m_selected_sphere_raycasters;
//std::vector<std::shared_ptr<PickRaycaster>> m_selected_sphere_raycasters;
std::optional<Measure::SurfaceFeature> m_curr_feature;
std::optional<Vec3d> m_curr_point_on_feature_position;
struct SceneRaycasterState
{
std::shared_ptr<SceneRaycasterItem> raycaster{ nullptr };
bool state{true};
};
std::vector<SceneRaycasterState> m_scene_raycasters;
// These hold information to decide whether recalculation is necessary:
float m_last_inv_zoom{ 0.0f };
std::optional<Measure::SurfaceFeature> m_last_circle;
std::optional<Measure::SurfaceFeature> m_last_circle_feature;
int m_last_plane_idx{ -1 };
bool m_mouse_left_down{ false }; // for detection left_up of this gizmo
Vec2d m_mouse_pos{ Vec2d::Zero() };
bool m_mouse_left_down_mesh_deal{false};//for pick mesh
KeyAutoRepeatFilter m_shift_kar_filter;
SelectedFeatures m_selected_features;
bool m_pending_scale{ false };
int m_pending_scale{ 0 };
bool m_set_center_coincidence{false};
bool m_editing_distance{ false };
bool m_is_editing_distance_first_frame{ true };
bool m_can_set_xyz_distance{false};
void update_if_needed();
void disable_scene_raycasters();
@@ -148,7 +232,6 @@ class GLGizmoMeasure : public GLGizmoBase
public:
GLGizmoMeasure(GLCanvas3D& parent, const std::string& icon_filename, unsigned int sprite_id);
/// <summary>
/// Apply rotation on select plane
/// </summary>
@@ -158,12 +241,12 @@ public:
void data_changed(bool is_serializing) override;
bool gizmo_event(SLAGizmoEventType action, const Vec2d& mouse_position, bool shift_down, bool alt_down, bool control_down);
virtual bool gizmo_event(SLAGizmoEventType action, const Vec2d& mouse_position, bool shift_down, bool alt_down, bool control_down);
bool wants_enter_leave_snapshots() const override { return true; }
std::string get_gizmo_entering_text() const override { return _u8L("Entering Measure gizmo"); }
std::string get_gizmo_leaving_text() const override { return _u8L("Leaving Measure gizmo"); }
std::string get_action_snapshot_name() const override { return _u8L("Measure gizmo editing"); }
//std::string get_action_snapshot_name() const override { return _u8L("Measure gizmo editing"); }
protected:
bool on_init() override;
@@ -172,20 +255,56 @@ protected:
void on_render() override;
void on_set_state() override;
//virtual void on_render_for_picking() override;
void show_selection_ui();
void show_distance_xyz_ui();
//void show_point_point_assembly();
void init_render_input_window();
virtual void on_render_input_window(float x, float y, float bottom_limit) override;
virtual void on_register_raycasters_for_picking() override;
virtual void on_unregister_raycasters_for_picking() override;
void remove_selected_sphere_raycaster(int id);
void update_measurement_result();
// Orca
void show_tooltip_information(float caption_max, float x, float y);
void reset_all_pick();
void reset_gripper_pick(GripperType id,bool is_all = false);
void register_single_mesh_pick();
//void update_single_mesh_pick(GLVolume* v);
private:
std::string format_double(double value);
std::string format_vec3(const Vec3d &v);
std::string surface_feature_type_as_string(Measure::SurfaceFeatureType type);
std::string point_on_feature_type_as_string(Measure::SurfaceFeatureType type, int hover_id);
std::string center_on_feature_type_as_string(Measure::SurfaceFeatureType type);
bool is_feature_with_center(const Measure::SurfaceFeature &feature);
Vec3d get_feature_offset(const Measure::SurfaceFeature &feature);
void reset_all_feature();
void reset_feature1_render();
void reset_feature2_render();
void reset_feature1();
void reset_feature2();
bool is_two_volume_in_same_model_object();
Measure::Measuring* get_measuring_of_mesh(GLVolume *v, Transform3d &tran);
void update_world_plane_features(Measure::Measuring *cur_measuring, Measure::SurfaceFeature &feautre);
void update_feature_by_tran(Measure::SurfaceFeature & feature);
void set_distance(bool same_model_object, const Vec3d &displacement, bool take_shot = true);
protected:
// 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_show_reset_first_tip{false};
bool m_selected_wrong_feature_waring_tip{false};
EMeasureMode m_measure_mode{EMeasureMode::ONLY_MEASURE};
AssemblyMode m_assembly_mode{AssemblyMode::FACE_FACE};
bool m_flip_volume_2{false};
float m_space_size;
float m_input_size_max;
bool m_use_inches;
bool m_only_select_plane{false};
std::string m_units;
mutable bool m_same_model_object;
mutable unsigned int m_current_active_imgui_id;
};
} // namespace GUI

31
src/slic3r/GUI/Gizmos/GLGizmosManager.cpp
View File

@@ -61,7 +61,8 @@ std::vector<size_t> GLGizmosManager::get_selectable_idxs() const
out.reserve(m_gizmos.size());
if (m_parent.get_canvas_type() == GLCanvas3D::CanvasAssembleView) {
for (size_t i = 0; i < m_gizmos.size(); ++i)
if (m_gizmos[i]->get_sprite_id() == (unsigned int)MmuSegmentation)
if (m_gizmos[i]->get_sprite_id() == (unsigned int) Measure ||
m_gizmos[i]->get_sprite_id() == (unsigned int) MmuSegmentation)
out.push_back(i);
}
else {
@@ -158,7 +159,7 @@ void GLGizmosManager::switch_gizmos_icon_filename()
case(EType::MeshBoolean):
gizmo->set_icon_filename(m_is_dark ? "toolbar_meshboolean_dark.svg" : "toolbar_meshboolean.svg");
break;
case(EType::Measure):
case (EType::Measure):
gizmo->set_icon_filename(m_is_dark ? "toolbar_measure_dark.svg" : "toolbar_measure.svg");
break;
}
@@ -342,6 +343,8 @@ bool GLGizmosManager::check_gizmos_closed_except(EType type) const
void GLGizmosManager::set_hover_id(int id)
{
// Measure handles hover by itself
if (m_current == EType::Measure) { return; }
if (!m_enabled || m_current == Undefined)
return;
@@ -703,14 +706,7 @@ bool GLGizmosManager::on_char(wxKeyEvent& evt)
}
break;
}
case WXK_BACK:
case WXK_DELETE:
{
if ((m_current == Cut || m_current == Measure) && gizmo_event(SLAGizmoEventType::Delete))
processed = true;
break;
}
//skip some keys when gizmo
case 'A':
case 'a':
{
@@ -737,14 +733,12 @@ bool GLGizmosManager::on_char(wxKeyEvent& evt)
//}
//case WXK_BACK:
//case WXK_DELETE:
//{
// if ((m_current == SlaSupports || m_current == Hollow) && gizmo_event(SLAGizmoEventType::Delete))
// processed = true;
// break;
//}
case WXK_BACK:
case WXK_DELETE: {
if ((m_current == Cut || m_current == Measure) && gizmo_event(SLAGizmoEventType::Delete))
processed = true;
break;
}
//case 'A':
//case 'a':
//{
@@ -845,7 +839,6 @@ bool GLGizmosManager::on_key(wxKeyEvent& evt)
else if (keyCode == WXK_SHIFT)
gizmo_event(SLAGizmoEventType::ShiftUp, Vec2d::Zero(), evt.ShiftDown(), evt.AltDown(), evt.CmdDown());
}
// if (processed)
// m_parent.set_cursor(GLCanvas3D::Standard);
}